chore: core snapshot pinned by a3s-cli v0.5.12

Snapshot of the core that the a3s CLI v0.5.12 release pins via git rev. The
cli's features depend on APIs that live here but not in the crates.io 4.2.x
line: the workspace manifest backend + recent-workspace context provider
(file-index/search substrate), OsConfig / OS login, and interrupt-keeps-context
(finish_interrupted). Branch snapshot for the cli git-dependency — not for main.

Author: claude

Cargo.lock

@@ -13,10 +13,10 @@ path = "src/lib.rs"
 
 [dependencies]
 # Internal crates
-a3s-common = { version = "0.1.1", path = "../../common" }
-a3s-memory = { version = "0.1.1", path = "../../memory" }
-a3s-lane = { version = "0.4", path = "../../lane" }
-a3s-search = { version = "1.2.3", path = "../../search", default-features = false, features = ["lightpanda"] }
+a3s-common = "0.1.1"
+a3s-memory = "0.1.1"
+a3s-lane = "0.4"
+a3s-search = { version = "1.2.3", default-features = false, features = ["lightpanda"] }
 
 # Async runtime
 tokio = { version = "1.35", features = [
@@ -60,6 +60,7 @@ reqwest = { version = "0.11", default-features = false, features = ["json", "str
 # File operations
 glob = "0.3"
 ignore = "0.4"
+notify = "8"
 
 # Diff for edit tool
 similar = "2.4"
@@ -113,10 +114,10 @@ aws-smithy-types = { version = "1", optional = true }
 aws-smithy-runtime-api = { version = "1", optional = true }
 
 [target.'cfg(unix)'.dependencies]
-a3s-ahp = { version = "2.4", path = "../../ahp", optional = true, features = ["http", "websocket", "unix-socket"] }
+a3s-ahp = { version = "2.4", optional = true, features = ["http", "websocket", "unix-socket"] }
 
 [target.'cfg(not(unix))'.dependencies]
-a3s-ahp = { version = "2.4", path = "../../ahp", optional = true, features = ["http", "websocket"] }
+a3s-ahp = { version = "2.4", optional = true, features = ["http", "websocket"] }
 
 [features]
 default = []
@@ -145,7 +146,7 @@ serve = ["dep:cron"]
 
 [dev-dependencies]
 # AHP for integration tests
-a3s-ahp = { path = "../../ahp" }
+a3s-ahp = "2.4"
 # HTTP mocking for the RemoteGitBackend (and any future HTTP-backed workspace
 # provider). Production code does not depend on wiremock.
 wiremock = "0.6"

core/Cargo.toml

@@ -211,6 +211,26 @@ impl ExecutionLoopState {
         }
     }
 
+    /// Finish a host-cancelled (Esc) turn. Unlike an `Err` return — which the
+    /// run lifecycle never records, dropping the turn from history — this returns
+    /// a normal result so the partial exchange is committed and the next turn
+    /// remembers what was asked. The committed history must end on an assistant
+    /// message; if the turn was cancelled before any assistant reply, append a
+    /// short marker so user/assistant alternation stays valid.
+    pub(super) fn finish_interrupted(mut self) -> AgentResult {
+        if self.messages.last().map(|m| m.role.as_str()) == Some("user") {
+            self.messages
+                .push(Message::assistant("(Response interrupted)"));
+        }
+        AgentResult {
+            text: String::new(),
+            messages: self.messages,
+            usage: self.total_usage,
+            tool_calls_count: self.tool_calls_count,
+            verification_reports: self.verification_reports,
+        }
+    }
+
     fn tool_signature(tool_name: &str, args: &Value) -> String {
         format!(
             "{}:{}",
@@ -225,6 +245,30 @@ mod tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn finish_interrupted_appends_marker_when_history_ends_on_user() {
+        // Cancelled before any assistant reply: commit the user turn + a marker
+        // so the next turn remembers it and role alternation stays valid.
+        let state = ExecutionLoopState::new(&[Message::user("do X")]);
+        let result = state.finish_interrupted();
+        assert_eq!(result.messages.len(), 2);
+        assert_eq!(result.messages[0].role.as_str(), "user");
+        assert_eq!(result.messages[1].role.as_str(), "assistant");
+        assert!(result.messages[1].text().contains("interrupted"));
+        assert!(result.text.is_empty());
+    }
+
+    #[test]
+    fn finish_interrupted_keeps_history_when_it_ends_on_assistant() {
+        // A partial assistant reply was already recorded: don't append a marker.
+        let state =
+            ExecutionLoopState::new(&[Message::user("do X"), Message::assistant("partial answer")]);
+        let result = state.finish_interrupted();
+        assert_eq!(result.messages.len(), 2);
+        assert_eq!(result.messages[1].role.as_str(), "assistant");
+        assert_eq!(result.messages[1].text(), "partial answer");
+    }
+
     #[test]
     fn duplicate_tool_call_uses_recent_success_and_error_signatures() {
         let mut state = ExecutionLoopState::new(&[]);

core/src/agent/execution_state.rs

@@ -1197,6 +1197,80 @@ async fn test_execute_plan_delegates_parallel_task_wave_once() {
         .all(|task| task.status == TaskStatus::Completed));
 }
 
+#[tokio::test]
+async fn test_execute_plan_auto_delegates_unmarked_parallel_wave_when_enabled() {
+    use crate::planning::{Complexity, ExecutionPlan, Task};
+    use crate::subagent::AgentRegistry;
+    use crate::tools::register_task;
+
+    let child_client = Arc::new(MockLlmClient::new(vec![
+        MockLlmClient::text_response("auth exploration complete"),
+        MockLlmClient::text_response("docs exploration complete"),
+    ]));
+    let tool_executor = Arc::new(ToolExecutor::new("/tmp".to_string()));
+    let agent_registry = Arc::new(AgentRegistry::new());
+    register_task(
+        tool_executor.registry(),
+        child_client,
+        Arc::clone(&agent_registry),
+        "/tmp".to_string(),
+    );
+    let auto_delegation = crate::config::AutoDelegationConfig {
+        enabled: true,
+        auto_parallel: true,
+        ..Default::default()
+    };
+    let config = AgentConfig {
+        auto_delegation,
+        agent_registry: Some(agent_registry),
+        ..AgentConfig::default()
+    };
+    let agent = AgentLoop::new(
+        Arc::new(MockLlmClient::new(vec![])),
+        tool_executor,
+        test_tool_context(),
+        config,
+    );
+
+    let mut plan = ExecutionPlan::new("Explore independent areas", Complexity::Medium);
+    plan.add_step(Task::new("s1", "Find auth code"));
+    plan.add_step(Task::new("s2", "Find documentation"));
+
+    let (tx, mut rx) = mpsc::channel(100);
+    let result = agent
+        .execute_plan(&[], &plan, Some("auto-plan-parallel-session"), Some(tx))
+        .await
+        .unwrap();
+
+    assert_eq!(
+        result.tool_calls_count, 1,
+        "auto-parallel plan wave should collapse into one parallel_task call"
+    );
+    assert!(result.text.contains("auth exploration complete"));
+    assert!(result.text.contains("docs exploration complete"));
+
+    let mut parallel_task_starts = 0;
+    let mut completed_steps = Vec::new();
+    rx.close();
+    while let Some(event) = rx.recv().await {
+        match event {
+            AgentEvent::ToolStart { name, .. } if name == "parallel_task" => {
+                parallel_task_starts += 1;
+            }
+            AgentEvent::StepEnd {
+                step_id,
+                status: TaskStatus::Completed,
+                ..
+            } => completed_steps.push(step_id),
+            _ => {}
+        }
+    }
+
+    completed_steps.sort();
+    assert_eq!(parallel_task_starts, 1);
+    assert_eq!(completed_steps, vec!["s1".to_string(), "s2".to_string()]);
+}
+
 #[tokio::test]
 async fn test_execute_plan_delegated_parallel_wave_maps_child_failure() {
     use crate::planning::{Complexity, ExecutionPlan, Task};
@@ -1301,9 +1375,11 @@ async fn test_auto_delegation_runs_parallel_specialists_when_enabled() {
         agent_registry.clone(),
         "/tmp".to_string(),
     );
-    let mut auto_delegation = crate::config::AutoDelegationConfig::default();
-    auto_delegation.enabled = true;
-    auto_delegation.max_tasks = 2;
+    let auto_delegation = crate::config::AutoDelegationConfig {
+        enabled: true,
+        max_tasks: 2,
+        ..Default::default()
+    };
     let config = AgentConfig {
         planning_mode: PlanningMode::Disabled,
         auto_delegation,
@@ -1357,10 +1433,12 @@ async fn test_auto_delegation_global_parallel_switch_uses_single_task() {
         agent_registry.clone(),
         "/tmp".to_string(),
     );
-    let mut auto_delegation = crate::config::AutoDelegationConfig::default();
-    auto_delegation.enabled = true;
-    auto_delegation.auto_parallel = false;
-    auto_delegation.max_tasks = 2;
+    let auto_delegation = crate::config::AutoDelegationConfig {
+        enabled: true,
+        auto_parallel: false,
+        max_tasks: 2,
+        ..Default::default()
+    };
     let config = AgentConfig {
         planning_mode: PlanningMode::Disabled,
         auto_delegation,

core/src/agent/extra_agent_tests.rs

@@ -105,7 +105,7 @@ impl AgentLoop {
         }
 
         loop {
-            let llm_turn = self
+            let llm_turn = match self
                 .execute_llm_turn(
                     &mut state,
                     &augmented_system,
@@ -114,7 +114,17 @@ impl AgentLoop {
                     &event_tx,
                     cancel_token,
                 )
-                .await?;
+                .await
+            {
+                Ok(turn) => turn,
+                // Host cancelled (Esc) mid-turn: commit the partial exchange to
+                // history instead of dropping it, so the next turn remembers what
+                // was asked. Other errors propagate as before.
+                Err(_) if cancel_token.is_cancelled() => {
+                    return Ok(state.finish_interrupted());
+                }
+                Err(e) => return Err(e),
+            };
             let turn = llm_turn.turn;
             let response = llm_turn.response;
             let tool_calls = llm_turn.tool_calls;
@@ -137,14 +147,23 @@ impl AgentLoop {
                 }
             }
 
-            self.execute_tool_turn(
-                tool_calls,
-                &mut state,
-                &event_tx,
-                session_id,
-                effective_prompt,
-            )
-            .await?;
+            if let Err(e) = self
+                .execute_tool_turn(
+                    tool_calls,
+                    &mut state,
+                    &event_tx,
+                    session_id,
+                    effective_prompt,
+                )
+                .await
+            {
+                // Same as above: a cancelled tool round commits its partial
+                // history rather than being dropped.
+                if cancel_token.is_cancelled() {
+                    return Ok(state.finish_interrupted());
+                }
+                return Err(e);
+            }
 
             // Quiescent boundary: the tool round has fully resolved and
             // `state.messages` is consistent. Persist a checkpoint so a

core/src/agent/loop_runtime.rs

@@ -57,6 +57,25 @@ impl AgentLoop {
         )
     }
 
+    fn can_auto_delegate_plan_wave(&self, steps: &[(Task, usize)]) -> bool {
+        let config = &self.config.auto_delegation;
+        config.enabled
+            && config.auto_parallel
+            && config.max_tasks > 0
+            && self.config.agent_registry.is_some()
+            && self.tool_executor.registry().contains("parallel_task")
+            && steps.iter().all(|(step, _)| {
+                Self::normalized_plan_tool(step).is_none() || Self::should_delegate_plan_step(step)
+            })
+    }
+
+    fn should_delegate_plan_wave(&self, steps: &[(Task, usize)]) -> bool {
+        steps
+            .iter()
+            .all(|(step, _)| Self::should_delegate_plan_step(step))
+            || self.can_auto_delegate_plan_wave(steps)
+    }
+
     pub(super) fn delegated_agent_for_step(step: &Task) -> &'static str {
         let text = format!(
             "{}\n{}",
@@ -441,10 +460,7 @@ impl AgentLoop {
                 }
 
                 let mut parallel_results: Vec<ParallelStepResult> = Vec::new();
-                if ready_steps
-                    .iter()
-                    .all(|(step, _)| Self::should_delegate_plan_step(step))
-                {
+                if self.should_delegate_plan_wave(&ready_steps) {
                     let args = Self::parallel_delegated_task_args_with_goal(
                         Some(&plan.goal),
                         &ready_steps,

core/src/agent/plan_execution.rs

@@ -66,8 +66,13 @@ impl BlockingRunContext {
         let mut agent_loop = build_agent_loop(session);
         agent_loop.set_checkpoint_run(&run_id);
         let (runtime_tx, runtime_rx) = mpsc::channel(2048);
-        let runtime_collector =
-            RuntimeEventSink::from_session(session, &run_id).spawn_collector(runtime_rx);
+        let session_events = session
+            .tool_context
+            .agent_event_tx
+            .as_ref()
+            .map(|tx| tx.subscribe());
+        let runtime_collector = RuntimeEventSink::from_session(session, &run_id)
+            .spawn_collector(runtime_rx, session_events);
         let lifecycle = BlockingRunLifecycle::from_session(session, &run_id, persistence);
         let cancel_token = session.session_cancel.child_token();
         lifecycle.set_cancel_token(cancel_token.clone()).await;
@@ -174,8 +179,16 @@ impl StreamRunContext {
         let cancel_token = session.session_cancel.child_token();
         lifecycle.set_cancel_token(cancel_token.clone()).await;
         let worker_state = lifecycle.worker_state();
-        let forwarder =
-            RuntimeEventSink::from_session(session, &run_id).spawn_forwarder(runtime_rx, tx);
+        let session_events = session
+            .tool_context
+            .agent_event_tx
+            .as_ref()
+            .map(|tx| tx.subscribe());
+        let forwarder = RuntimeEventSink::from_session(session, &run_id).spawn_forwarder(
+            runtime_rx,
+            tx,
+            session_events,
+        );
 
         Self {
             agent_loop,