feat(runtime): runtime-switch permission/decision/sandbox modes via TUI + ACP (#194)

Adds session-only runtime switching of PermissionMode, DecisionMode and
SandboxPolicy — previously fixed at startup — so users can adjust them
mid-session without restarting.

- protocol: new ControlCommand::{Permission,Decision,Sandbox}*Switch +
  AgentEventPayload::*Changed; ObservableAgentState carries the 3 values
- runtime: handle_control branches (emit-first), shared DecisionCell atomic
  so /decision flips without rebuilding the handler chain, Kernel sandbox
  RwLock + backend rebuild; plan-exit re-emits/keeps a mid-plan /permission
- TUI: /permission /decision /sandbox enum pickers + /status Config overlay
  showing live (session) values; ACP set_config_option maps the 3 configIds
- DecisionMode/SandboxPolicy follow startup config for sub-agent spawn
  inheritance (parent-local switches); PermissionMode gains Default (Bypass)

Covered by unit + e2e tests; all source files kept <=200 lines.

Author: yishuiliunian

crates/loopal-acp/src/adapter/control.rs

@@ -39,14 +39,19 @@ impl AcpAdapter {
         }
     }
 
-    /// Handle `session/set_config_option` → HubClient.send_control(ModelSwitch|ThinkingSwitch).
+    /// Handle `session/set_config_option` → forwards the value as the matching
+    /// runtime `ControlCommand` (model / thinking / permission / decision /
+    /// sandbox). Unknown `configId`s are rejected with INVALID_REQUEST.
     pub(crate) async fn handle_set_config_option(&self, id: i64, params: Value) {
         let config_id = params["configId"].as_str().unwrap_or("");
         let value = params["value"].as_str().unwrap_or("").to_string();
 
         let cmd = match config_id {
             "model" => ControlCommand::ModelSwitch(value),
             "thinking" => ControlCommand::ThinkingSwitch(value),
+            "permission" => ControlCommand::PermissionModeSwitch(value),
+            "decision" => ControlCommand::DecisionModeSwitch(value),
+            "sandbox" => ControlCommand::SandboxPolicySwitch(value),
             _ => {
                 self.acp_out
                     .respond_error(

crates/loopal-acp/src/translate/mod.rs

@@ -162,6 +162,9 @@ pub fn translate_event(payload: &AgentEventPayload, session_id: &str) -> Option<
         | AgentEventPayload::UserMessageQueued { .. }
         | AgentEventPayload::ModelChanged { .. }
         | AgentEventPayload::ThinkingChanged { .. }
+        | AgentEventPayload::PermissionModeChanged { .. }
+        | AgentEventPayload::DecisionModeChanged { .. }
+        | AgentEventPayload::SandboxPolicyChanged { .. }
         | AgentEventPayload::ThreadGoalUpdated { .. }
         | AgentEventPayload::ClassifierProgress { .. }
         | AgentEventPayload::ClassifierFailed { .. }

crates/loopal-acp/tests/suite/e2e_alignment_test.rs

@@ -78,6 +78,31 @@ async fn test_set_config_option_thinking() {
     assertions::assert_json_rpc_ok(&resp);
 }
 
+#[tokio::test]
+async fn test_set_config_option_runtime_switches() {
+    let mut harness = build_acp_harness(vec![]).await;
+    let _sid = setup_session(&mut harness).await;
+
+    for (config_id, value) in [
+        ("permission", "ask_any_write"),
+        ("decision", "classifier"),
+        ("sandbox", "read_only"),
+    ] {
+        let resp = harness
+            .request(
+                "session/set_config_option",
+                json!({"configId": config_id, "value": value}),
+            )
+            .await;
+        assertions::assert_json_rpc_ok(&resp);
+        assert_eq!(
+            resp["result"]["configOptions"],
+            json!([]),
+            "{config_id} switch should return the standard configOptions body"
+        );
+    }
+}
+
 #[tokio::test]
 async fn test_notification_uses_session_update_tag() {
     // Verify the wire format uses "sessionUpdate" (ACP standard) not "kind".

crates/loopal-agent-server/src/agent_loop_params_factory.rs

@@ -31,6 +31,7 @@ pub(crate) struct AgentLoopAssembly {
     pub fetch_refiner_policy: Option<Arc<dyn FetchRefinerPolicy>>,
     pub goal_session: Option<Arc<GoalRuntimeSession>>,
     pub scheduler: Arc<loopal_scheduler::CronScheduler>,
+    pub decision_cell: loopal_runtime::frontend::DecisionCell,
 }
 
 pub(crate) fn assemble_agent_loop_params(a: AgentLoopAssembly) -> AgentLoopParams {
@@ -51,7 +52,8 @@ pub(crate) fn assemble_agent_loop_params(a: AgentLoopAssembly) -> AgentLoopParam
     .message_snapshot(a.message_snapshot)
     .resume_hooks(a.resume_hooks)
     .memory_channel_opt(a.memory_channel)
-    .scheduler(a.scheduler);
+    .scheduler(a.scheduler)
+    .decision_cell(a.decision_cell);
     let builder = match a.one_shot_chat {
         Some(s) => builder.one_shot_chat(s),
         None => builder,

crates/loopal-agent-server/src/agent_setup.rs

@@ -22,6 +22,7 @@ pub async fn build_with_frontend(ctx: AgentSetupContext<'_>) -> anyhow::Result<A
         session_dir_override,
         hub,
         decision_context,
+        decision_cell,
         session_id,
     } = ctx;
     let router = build_model_router(&config.settings);
@@ -187,6 +188,7 @@ pub async fn build_with_frontend(ctx: AgentSetupContext<'_>) -> anyhow::Result<A
             fetch_refiner_policy: Some(fetch_refiner_policy),
             goal_session,
             scheduler: scheduler.clone(),
+            decision_cell,
         },
     );
     Ok(AgentSetupResult {

crates/loopal-agent-server/src/agent_setup_context.rs

@@ -37,6 +37,7 @@ pub struct AgentSetupContext<'a> {
     pub session_dir_override: Option<&'a std::path::Path>,
     pub hub: &'a crate::session_hub::SessionHub,
     pub decision_context: loopal_runtime::frontend::DecisionContext,
+    pub decision_cell: loopal_runtime::frontend::DecisionCell,
     pub session_id: &'a str,
 }
 
@@ -54,6 +55,7 @@ impl<'a> AgentSetupContext<'a> {
         session_dir_override: Option<&'a std::path::Path>,
         hub: &'a crate::session_hub::SessionHub,
         decision_context: loopal_runtime::frontend::DecisionContext,
+        decision_cell: loopal_runtime::frontend::DecisionCell,
         session_id: &'a str,
     ) -> Self {
         Self {
@@ -68,6 +70,7 @@ impl<'a> AgentSetupContext<'a> {
             session_dir_override,
             hub,
             decision_context,
+            decision_cell,
             session_id,
         }
     }

crates/loopal-agent-server/src/session_handlers_factory.rs

@@ -8,7 +8,7 @@ use loopal_runtime::frontend::permission_handler::PermissionHandler;
 use loopal_runtime::frontend::question_handler::QuestionHandler;
 use loopal_runtime::frontend::traits::EventEmitter;
 use loopal_runtime::frontend::{
-    ClassifierPermissionHandler, ClassifierQuestionHandler, DecisionContext,
+    ClassifierPermissionHandler, ClassifierQuestionHandler, DecisionCell, DecisionContext,
 };
 
 use crate::hub_broadcaster::HubBroadcaster;
@@ -35,21 +35,21 @@ pub fn build_session_handlers(
     kernel: &Arc<Kernel>,
     session: SessionRef,
     context: DecisionContext,
-) -> (Box<dyn PermissionHandler>, Box<dyn QuestionHandler>) {
+) -> (
+    Box<dyn PermissionHandler>,
+    Box<dyn QuestionHandler>,
+    DecisionCell,
+) {
     let ipc_perm: Box<dyn PermissionHandler> = Box::new(IpcPermissionHandler::new(session.clone()));
     let ipc_q_arc: Arc<dyn QuestionHandler> = Arc::new(IpcQuestionHandler::new(session.clone()));
-    match config.settings.decision_mode {
-        DecisionMode::Manual => {
-            let ipc_q: Box<dyn QuestionHandler> = Box::new(IpcQuestionHandler::new(session));
-            return (ipc_perm, ipc_q);
-        }
-        DecisionMode::Classifier => {}
-        DecisionMode::Agent => {
-            tracing::warn!(
-                "DecisionMode::Agent is not yet implemented; falling back to Classifier"
-            );
-        }
+    if config.settings.decision_mode == DecisionMode::Agent {
+        tracing::warn!("DecisionMode::Agent is not yet implemented; falling back to Classifier");
     }
+    // Always build the classifier-wrapped chain; the DecisionCell decides at
+    // request time whether to run the classifier or delegate to the IPC
+    // fallback (Manual). This lets /decision flip modes mid-session without
+    // rebuilding the handler chain.
+    let decision = DecisionCell::new(config.settings.decision_mode);
     let classifier = Arc::new(
         loopal_classifier::ClassifierEngine::new_with_thresholds(
             config.instructions.clone(),
@@ -70,14 +70,18 @@ pub fn build_session_handlers(
         router,
     });
     let emitter: Arc<dyn EventEmitter> = Arc::new(HubBroadcaster::new(session, None));
-    let auto_perm: Box<dyn PermissionHandler> = Box::new(ClassifierPermissionHandler::new(
-        classifier.clone(),
-        ipc_perm,
-        resolver.clone(),
-        context.clone(),
-    ));
-    let auto_q: Box<dyn QuestionHandler> = Box::new(ClassifierQuestionHandler::new(
-        classifier, ipc_q_arc, resolver, context, emitter,
-    ));
-    (auto_perm, auto_q)
+    let auto_perm: Box<dyn PermissionHandler> = Box::new(
+        ClassifierPermissionHandler::new(
+            classifier.clone(),
+            ipc_perm,
+            resolver.clone(),
+            context.clone(),
+        )
+        .with_decision(decision.clone()),
+    );
+    let auto_q: Box<dyn QuestionHandler> = Box::new(
+        ClassifierQuestionHandler::new(classifier, ipc_q_arc, resolver, context, emitter)
+            .with_decision(decision.clone()),
+    );
+    (auto_perm, auto_q, decision)
 }

crates/loopal-agent-server/src/session_start.rs

@@ -94,7 +94,7 @@ pub(crate) async fn start_session(
         ));
         let decision_context =
             loopal_runtime::frontend::DecisionContext::with_cwd(cwd.to_string_lossy().into_owned());
-        let (perm_handler, q_handler) = build_session_handlers(
+        let (perm_handler, q_handler, decision_cell) = build_session_handlers(
             &config,
             &kernel,
             session_holder.clone(),
@@ -124,6 +124,7 @@ pub(crate) async fn start_session(
                 session_dir_override.as_deref(),
                 hub,
                 decision_context,
+                decision_cell,
                 &preset_session_id,
             ))
             .await?;

crates/loopal-agent-server/tests/suite/hub_harness.rs

@@ -155,6 +155,7 @@ pub async fn build_hub_harness_with(
             Some(fixture.path()),
             &hub,
             loopal_runtime::frontend::DecisionContext::with_cwd("/tmp/test"),
+            loopal_runtime::frontend::DecisionCell::new(loopal_decision_api::DecisionMode::Manual),
             "harness-session",
         ),
     )

crates/loopal-agent-server/tests/suite/session_handlers_factory_test.rs

@@ -39,7 +39,7 @@ async fn manual_decision_yields_ipc_only_no_primary_connection() {
     let config = empty_config(DecisionMode::Manual);
     let kernel = Arc::new(Kernel::new(Settings::default()).unwrap());
     let session = dummy_session();
-    let (perm, _q) = build_session_handlers(
+    let (perm, _q, _cell) = build_session_handlers(
         &config,
         &kernel,
         session,
@@ -63,7 +63,7 @@ async fn auto_decision_wraps_with_auto_handlers_and_falls_back() {
     let config = empty_config(DecisionMode::Classifier);
     let kernel = Arc::new(Kernel::new(Settings::default()).unwrap());
     let session = dummy_session();
-    let (perm, _q) = build_session_handlers(
+    let (perm, _q, _cell) = build_session_handlers(
         &config,
         &kernel,
         session,
@@ -92,7 +92,7 @@ async fn manual_question_path_cancels_without_connection() {
     let config = empty_config(DecisionMode::Manual);
     let kernel = Arc::new(Kernel::new(Settings::default()).unwrap());
     let session = dummy_session();
-    let (_perm, q) = build_session_handlers(
+    let (_perm, q, _cell) = build_session_handlers(
         &config,
         &kernel,
         session,
@@ -118,7 +118,7 @@ async fn auto_question_path_chains_fallback_when_provider_unresolvable() {
     let config = empty_config(DecisionMode::Classifier);
     let kernel = Arc::new(Kernel::new(Settings::default()).unwrap());
     let session = dummy_session();
-    let (_perm, q) = build_session_handlers(
+    let (_perm, q, _cell) = build_session_handlers(
         &config,
         &kernel,
         session,
@@ -139,14 +139,40 @@ async fn auto_question_path_chains_fallback_when_provider_unresolvable() {
     );
 }
 
+#[tokio::test]
+async fn decision_cell_switch_flips_manual_to_classifier_at_runtime() {
+    let config = empty_config(DecisionMode::Manual);
+    let kernel = Arc::new(Kernel::new(Settings::default()).unwrap());
+    let session = dummy_session();
+    let (perm, _q, cell) = build_session_handlers(
+        &config,
+        &kernel,
+        session,
+        DecisionContext::with_cwd("/tmp/test"),
+    );
+    let manual = perm.decide("id1", "Bash", &serde_json::json!({})).await;
+    assert!(
+        manual.reason.contains("no primary connection"),
+        "Manual cell must delegate to fallback, got: {}",
+        manual.reason
+    );
+    cell.set(DecisionMode::Classifier);
+    let classifier = perm.decide("id2", "Bash", &serde_json::json!({})).await;
+    assert!(
+        classifier.reason.contains("provider lookup failed"),
+        "Classifier cell must run the classifier path, got: {}",
+        classifier.reason
+    );
+}
+
 #[tokio::test]
 async fn agent_decision_falls_back_to_classifier_path_today() {
     // Agent mode is not yet implemented; factory must transparently fall
     // back to Classifier behaviour so existing setups keep working.
     let config = empty_config(DecisionMode::Agent);
     let kernel = Arc::new(Kernel::new(Settings::default()).unwrap());
     let session = dummy_session();
-    let (perm, q) = build_session_handlers(
+    let (perm, q, _cell) = build_session_handlers(
         &config,
         &kernel,
         session,