c03: delete the four re-export shims and migrate their last consumers

`docs/design/TUI_DECONSTRUCTION.md:176,185-186` forbids landing temporary
re-export shims whose last consumers are deferred: "do not land temporary
re-export shims with their last consumers left for an unspecified future
migration. Keep shims only for genuine external compatibility contracts and
identify that contract."

Four survived the earlier C03 slices — `tui/app/types.rs`, `tui/file_mention.rs`,
`tui/agent_roster.rs`, `tui/approval.rs` — and none named such a contract. There
was nothing to protect: no crate outside `crates/tui` referenced the moved
symbols. So this migrates every remaining internal consumer to the owning crate
and removes all four in one commit, because landing three of four is precisely
the deferred-consumer state the rule exists to prevent.

`crates/tui/src/turn_route_plan.rs` now imports `codewhale_config::AppMode`
directly. `AppModeUi` stays in `tui::app` — it is genuinely UI-specific and not a
shim.

`docs/design/TUI_DECONSTRUCTION.md` is updated in the same commit so the
dependency list describes the tree as it now is rather than as it was.

Also closes the coverage gap this packet's own done-evidence depended on.
`cargo test -p codewhale-config --lib app_mode` previously reported
`0 passed; 0 failed` with 693 filtered out — a filter matching nothing, which
the repo's rules count as a gap and not a pass — while C03 claimed "unchanged
serialization behavior". `AppMode`'s new owner now carries focused tests for the
setting round-trip, parse/label/cycle order, and the fallback for unknown values.

cargo test -p codewhale-config --lib --locked app_mode
  test result: ok. 5 passed; 0 failed; 693 filtered out   (was 0 passed)
cargo test -p codewhale-tui --lib --locked -- approval agent_roster context_reference app_mode
  test result: ok. 298 passed; 0 failed; 12317 filtered out
cargo test -p codewhale-execpolicy -p codewhale-config --locked
  test result: ok. 697 passed; 0 failed; 1 ignored
  test result: ok. 112 passed; 0 failed
  (plus 10, 5, 1, 1 passed across the remaining targets)
cargo check --workspace --all-targets --locked: 0 errors, 0 unused warnings

The fallback test deserves a note, since its first draft asserted the opposite:
`from_setting` returns `Agent` for an empty or unrecognized value, which is the
long-standing shipped behavior and is unchanged here. Mode is not the permission
surface — as `AppMode::parse` documents, the bypass posture the legacy YOLO
spellings imply travels on the permission surface, not on a mode.

Refs: Linear C03 / SHA-6179, GitHub #5316.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01X57KRgwqYkmmtVQScczqiL

Author: CodeWhale Bot

crates/config/src/app_mode.rs

@@ -122,3 +122,102 @@ impl AppMode {
         Self::CYCLE[(index + Self::CYCLE.len() - 1) % Self::CYCLE.len()]
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn app_mode_helpers_centralize_parse_labels_and_cycle_order() {
+        assert_eq!(AppMode::parse("agent"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("act"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("work"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("2"), Some(AppMode::Plan));
+        assert_eq!(AppMode::parse("auto"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("3"), Some(AppMode::Operate));
+        assert_eq!(AppMode::parse("operate"), Some(AppMode::Operate));
+        // Legacy YOLO spellings resolve to Act; the bypass posture they imply
+        // travels on the permission surface, not on a mode.
+        assert_eq!(AppMode::parse("YOLO"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("4"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("bypass"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("bypass-permissions"), Some(AppMode::Agent));
+        assert_eq!(AppMode::parse("multitask"), None);
+        assert_eq!(AppMode::parse("5"), None);
+        assert_eq!(AppMode::parse("fast"), None);
+        assert_eq!(AppMode::from_setting("multitask"), AppMode::Operate);
+        assert_eq!(AppMode::from_setting("5"), AppMode::Operate);
+
+        assert_eq!(AppMode::Agent.as_setting(), "agent");
+        assert_eq!(AppMode::Plan.display_name(), "Plan");
+        assert_eq!(AppMode::Agent.number(), '1');
+        assert_eq!(AppMode::Operate.number(), '3');
+        assert_eq!(
+            AppMode::CYCLE,
+            [AppMode::Plan, AppMode::Agent, AppMode::Operate]
+        );
+
+        assert_eq!(AppMode::Plan.next(), AppMode::Agent);
+        assert_eq!(AppMode::Agent.next(), AppMode::Operate);
+        assert_eq!(AppMode::Operate.next(), AppMode::Plan);
+        assert_eq!(AppMode::Plan.previous(), AppMode::Operate);
+        assert_eq!(AppMode::Agent.previous(), AppMode::Plan);
+        assert_eq!(AppMode::Operate.previous(), AppMode::Agent);
+    }
+
+    /// The durable form of a mode is the `as_setting()` string persisted into
+    /// settings and session records — `AppMode` derives no `Serialize`, so the
+    /// round-trip that has to hold is string -> mode -> string.
+    #[test]
+    fn setting_strings_round_trip_for_every_mode() {
+        for mode in AppMode::CYCLE {
+            let setting = mode.as_setting();
+            assert_eq!(
+                AppMode::from_setting(setting),
+                mode,
+                "from_setting({setting})"
+            );
+            assert_eq!(AppMode::parse(setting), Some(mode), "parse({setting})");
+        }
+
+        assert_eq!(AppMode::Agent.as_setting(), "agent");
+        assert_eq!(AppMode::Plan.as_setting(), "plan");
+        assert_eq!(AppMode::Operate.as_setting(), "operate");
+    }
+
+    /// `from_setting` is the de-facto default: an absent, empty, or unreadable
+    /// stored value must land on Act rather than panicking or picking Operate.
+    #[test]
+    fn from_setting_falls_back_to_act_for_unknown_values() {
+        assert_eq!(AppMode::from_setting(""), AppMode::Agent);
+        assert_eq!(AppMode::from_setting("   "), AppMode::Agent);
+        assert_eq!(AppMode::from_setting("nonsense"), AppMode::Agent);
+        assert_eq!(AppMode::from_setting("OPERATE"), AppMode::Operate);
+    }
+
+    #[test]
+    fn labels_and_descriptions_cover_every_mode() {
+        assert_eq!(AppMode::Agent.label(), "ACT");
+        assert_eq!(AppMode::Plan.label(), "PLAN");
+        assert_eq!(AppMode::Operate.label(), "OPERATE");
+
+        assert_eq!(AppMode::Agent.display_name(), "Act");
+        assert_eq!(AppMode::Plan.display_name(), "Plan");
+        assert_eq!(AppMode::Operate.display_name(), "Operate");
+
+        for mode in AppMode::CYCLE {
+            assert!(!mode.description().is_empty());
+        }
+    }
+
+    #[test]
+    fn operate_shares_the_agent_baseline_and_raises_the_launch_floor() {
+        assert!(AppMode::Agent.uses_agent_baseline());
+        assert!(AppMode::Operate.uses_agent_baseline());
+        assert!(!AppMode::Plan.uses_agent_baseline());
+
+        assert_eq!(AppMode::Operate.mode_delegation_launch_floor(), 4);
+        assert_eq!(AppMode::Agent.mode_delegation_launch_floor(), 1);
+        assert_eq!(AppMode::Plan.mode_delegation_launch_floor(), 1);
+    }
+}

crates/execpolicy/src/approval_mode.rs

@@ -62,3 +62,71 @@ impl ApprovalMode {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_approval_mode_labels() {
+        assert_eq!(ApprovalMode::Auto.label(), "AUTO");
+        assert_eq!(ApprovalMode::Suggest.label(), "SUGGEST");
+        assert_eq!(ApprovalMode::Never.label(), "NEVER");
+    }
+
+    #[test]
+    fn test_approval_mode_from_config_value_accepts_aliases() {
+        assert_eq!(
+            ApprovalMode::from_config_value("auto"),
+            Some(ApprovalMode::Auto)
+        );
+        assert_eq!(
+            ApprovalMode::from_config_value("on-request"),
+            Some(ApprovalMode::Suggest)
+        );
+        assert_eq!(
+            ApprovalMode::from_config_value("full_access"),
+            Some(ApprovalMode::Bypass)
+        );
+        assert_eq!(
+            ApprovalMode::from_config_value("deny"),
+            Some(ApprovalMode::Never)
+        );
+        assert_eq!(ApprovalMode::from_config_value("unknown"), None);
+    }
+
+    #[test]
+    fn permission_cycle_is_a_closed_loop_and_never_is_off_cycle() {
+        assert_eq!(
+            ApprovalMode::PERMISSION_CYCLE,
+            [
+                ApprovalMode::Suggest,
+                ApprovalMode::Auto,
+                ApprovalMode::Bypass
+            ]
+        );
+        assert_eq!(
+            ApprovalMode::Suggest.cycle_permission_next(),
+            ApprovalMode::Auto
+        );
+        assert_eq!(
+            ApprovalMode::Auto.cycle_permission_next(),
+            ApprovalMode::Bypass
+        );
+        assert_eq!(
+            ApprovalMode::Bypass.cycle_permission_next(),
+            ApprovalMode::Suggest
+        );
+        // Never is deliberately outside the Shift+Tab cycle; stepping from it
+        // must land on the safest posture rather than panicking or wrapping.
+        assert_eq!(
+            ApprovalMode::Never.cycle_permission_next(),
+            ApprovalMode::Suggest
+        );
+    }
+
+    #[test]
+    fn default_posture_is_suggest() {
+        assert_eq!(ApprovalMode::default(), ApprovalMode::Suggest);
+    }
+}

crates/tui/src/commands/groups/config/config.rs

@@ -19,8 +19,9 @@ use crate::config_persistence::{
 use crate::localization::{MessageId, resolve_locale, tr};
 use crate::reasoning_preference::ReasoningEffort;
 use crate::settings::Settings;
-use crate::tui::app::{App, AppAction, AppMode, OnboardingState, ScreenMode, SettingSelection, VimMode};
+use crate::tui::app::{App, AppAction, OnboardingState, ScreenMode, SettingSelection, VimMode};
 use anyhow::Result;
+use codewhale_config::AppMode;
 use codewhale_execpolicy::ApprovalMode;
 use std::path::{Path, PathBuf};
 

crates/tui/src/commands/groups/config/status.rs

@@ -526,8 +526,9 @@ mod tests {
     use super::*;
     use crate::config::{ApiProvider, Config};
     use crate::models::{ContentBlock, Message};
-    use crate::tui::app::{AppMode, TuiOptions};
+    use crate::tui::app::TuiOptions;
     use crate::tui::history::HistoryCell;
+    use codewhale_config::AppMode;
 
     #[test]
     fn status_keeps_current_session_snapshot_remedy_after_notice_delivery() {

crates/tui/src/commands/groups/core/core.rs

@@ -10,8 +10,9 @@ use crate::config::{
 use crate::localization::{Locale, MessageId, tr};
 #[cfg(test)]
 use crate::reasoning_preference::ReasoningEffort;
-use crate::tui::app::{App, AppAction, AppMode};
+use crate::tui::app::{App, AppAction};
 use crate::tui::views::{HelpView, ModalKind, SubAgentsView, subagent_view_agents};
+use codewhale_config::AppMode;
 
 use super::CommandResult;
 
@@ -754,8 +755,9 @@ mod tests {
     use crate::config::Config;
     use crate::models::Message;
     use crate::models::Role;
-    use crate::tui::app::{App, AppMode, TuiOptions, TurnCacheRecord};
+    use crate::tui::app::{App, TuiOptions, TurnCacheRecord};
     use crate::tui::history::HistoryCell;
+    use codewhale_config::AppMode;
     use std::ffi::OsString;
     use std::path::PathBuf;
     use std::time::Instant;

crates/tui/src/commands/groups/core/workflow.rs

@@ -13,7 +13,8 @@ use crate::commands::traits::{CommandInfo, RegisterCommand};
 use crate::localization::MessageId;
 use crate::models::ContentBlock;
 use crate::tui::app::WORKFLOW_DRAFT_INSTRUCTION_PREFIX;
-use crate::tui::app::{App, AppAction, AppMode};
+use crate::tui::app::{App, AppAction};
+use codewhale_config::AppMode;
 #[cfg(test)]
 use codewhale_execpolicy::ApprovalMode;
 

crates/tui/src/commands/session_control_regression_tests.rs

@@ -17,7 +17,8 @@ use crate::localization::{Locale, MessageId, tr};
 use crate::models::{ContentBlock, Message, Role, SystemPrompt};
 use crate::session_manager::{SessionManager, create_saved_session_with_mode};
 use crate::test_support::{EnvVarGuard, TestEnvLock};
-use crate::tui::app::{App, AppAction, AppMode, TuiOptions};
+use crate::tui::app::{App, AppAction, TuiOptions};
+use codewhale_config::AppMode;
 
 /// Owns the global environment lock for as long as its CODEWHALE_HOME guard.
 /// Fields are ordered so the guard restores the environment before the lock

crates/tui/src/commands/session_lifecycle_regression_tests.rs

@@ -14,8 +14,9 @@ use crate::models::Role;
 use crate::reasoning_preference::ReasoningEffort;
 use crate::session_manager::create_saved_session_with_id_and_mode;
 use crate::test_support::EnvVarGuard;
-use crate::tui::app::{App, AppAction, AppMode, TuiOptions, TurnCacheRecord};
+use crate::tui::app::{App, AppAction, TuiOptions, TurnCacheRecord};
 use crate::tui::history::HistoryCell;
+use codewhale_config::AppMode;
 
 fn dispatch_lifecycle(app: &mut App, name: &str, arg: Option<&str>) -> CommandResult {
     let command = match arg {
@@ -548,9 +549,9 @@ fn test_load_valid_session_defers_state_restore_to_event_loop() {
     app2.session_context_references
         .push(crate::session_manager::SessionContextReference {
             message_index: 0,
-            reference: crate::tui::file_mention::ContextReference {
-                kind: crate::tui::file_mention::ContextReferenceKind::File,
-                source: crate::tui::file_mention::ContextReferenceSource::AtMention,
+            reference: codewhale_core::ContextReference {
+                kind: codewhale_core::ContextReferenceKind::File,
+                source: codewhale_core::ContextReferenceSource::AtMention,
                 badge: "file".to_string(),
                 label: "stale.rs".to_string(),
                 target: tmpdir.path().join("stale.rs").display().to_string(),

crates/tui/src/tui/agent_roster.rs

@@ -5,10 +5,8 @@
 
 use std::collections::BTreeMap;
 
-#[allow(unused_imports)]
-pub use crate::agent_roster::{
-    AgentRosterRow, RosterState, all_rows_have_usage, build_agent_roster, display_name,
-    format_duration, format_tokens, one_line, roster_totals, wall_millis,
+use crate::agent_roster::{
+    AgentRosterRow, all_rows_have_usage, format_duration, format_tokens, roster_totals,
 };
 
 /// Absent receipts render as `—`. See the truth rule in the module docs.

crates/tui/src/tui/agent_roster/tests.rs

@@ -1,5 +1,6 @@
 use super::*;
 
+use crate::agent_roster::{RosterState, build_agent_roster};
 use crate::tools::subagent::{
     AgentRunUsage, AgentWorkerEvent, AgentWorkerRecord, AgentWorkerSpec, AgentWorkerStatus,
     AgentWorkerToolProfile, FleetRole,