fix(agent): keep conversation on cancel; strip delegation tools from PTC

Interrupting a turn (cancel) dropped it entirely: the internal history only
updates on a COMPLETED stream, so the next turn forgot what was just asked.
Now a cancelled llm-turn returns Ok(state.finish_interrupted()) — the
accumulated conversation (the user's message above all) is committed, ending
on an assistant marker so the next user turn still alternates.

Also strip task/parallel_task from the PTC script_allowed_tools: child agents
can't fan out on the program tool's single-thread runtime, so force direct
calls. Bumps to 4.2.3.

Author: RoyLin

core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "a3s-code-core"
-version = "4.2.2"
+version = "4.2.3"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"

core/src/agent/execution_state.rs

@@ -1,5 +1,5 @@
 use super::AgentResult;
-use crate::llm::{Message, TokenUsage};
+use crate::llm::{ContentBlock, Message, TokenUsage};
 use crate::verification::VerificationReport;
 use serde_json::Value;
 use std::time::Instant;
@@ -211,6 +211,34 @@ impl ExecutionLoopState {
         }
     }
 
+    /// Build a result from a turn that was cancelled mid-generation. Keeps the
+    /// conversation accumulated so far (the user's message above all) so the next
+    /// turn remembers it. Appends a short assistant marker when the log would
+    /// otherwise end on a user message, so the next user turn still alternates.
+    pub(super) fn finish_interrupted(mut self) -> AgentResult {
+        let ends_on_user = self
+            .messages
+            .last()
+            .map(|m| m.role != "assistant")
+            .unwrap_or(false);
+        if ends_on_user {
+            self.messages.push(Message {
+                role: "assistant".to_string(),
+                content: vec![ContentBlock::Text {
+                    text: "(Response interrupted by the user.)".to_string(),
+                }],
+                reasoning_content: None,
+            });
+        }
+        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 +253,27 @@ mod tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn finish_interrupted_keeps_user_message_and_alternates() {
+        // A cancelled turn must keep the user's message (so the next turn
+        // remembers it) and end on an assistant message (so it still alternates).
+        let mut state = ExecutionLoopState::new(&[]);
+        state.messages.push(Message::user("what is the plan?"));
+        let result = state.finish_interrupted();
+        assert!(
+            result
+                .messages
+                .iter()
+                .any(|m| m.role == "user" && m.text().contains("what is the plan?")),
+            "user message must survive the interrupt"
+        );
+        assert_eq!(
+            result.messages.last().unwrap().role,
+            "assistant",
+            "history must end on an assistant message to alternate"
+        );
+    }
+
     #[test]
     fn duplicate_tool_call_uses_recent_success_and_error_signatures() {
         let mut state = ExecutionLoopState::new(&[]);

core/src/agent/loop_runtime.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,19 @@ impl AgentLoop {
                     &event_tx,
                     cancel_token,
                 )
-                .await?;
+                .await
+            {
+                Ok(turn) => turn,
+                // Interrupted mid-generation (Esc / cancel): keep the conversation
+                // accumulated so far — above all the user's message — and return it
+                // as the result so it is committed to history. Without this the
+                // whole turn is dropped and the agent "forgets" what was just asked
+                // when the user continues.
+                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;

core/src/tools/program_tool.rs

@@ -213,6 +213,12 @@ fn script_allowed_tools(args: &serde_json::Value, registry: &ToolRegistry) -> Ha
         .unwrap_or_else(|| registry.list().into_iter().collect());
 
     allowed.remove("program");
+    // Delegation tools can't run inside a PTC script: child agents need the
+    // multi-threaded session runtime, but the script executes on a nested
+    // single-thread runtime where they can't fan out. Force the model to call
+    // them directly instead of `ctx.tool("parallel_task", ...)`.
+    allowed.remove("task");
+    allowed.remove("parallel_task");
     allowed
 }