@xingjisoft/neutrino 0.5.2 → 0.6.2

package/dist/screens/chat.js

@@ -1,16 +1,20 @@
+import path from "node:path";
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { findModel, findConfiguredModel, intensityForModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadPrompt, saveSession, } from "../config.js";
+import { findModel, findConfiguredModel, intensityForModel, contextCompressionThreshold, modelContextWindow, sessionDir, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadAgentPrompt, normalizeAgentMode, saveSession, } from "../config.js";
 import { drawHeader } from "../header.js";
 import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrapText, approvalToggle, drawApprovalToggle, inRect } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
 import { ellipsize, displayWidth } from "../width.js";
 import { sanitizeText } from "../sanitize.js";
+import { TaskRuntime, TaskControlError, currentTask, linkSignals, taskLimits, taskBudgetScope, resumeTaskSnapshot } from "../llm/runtime.js";
+import { prepareContext, outputAllowance, finalTaskReport } from "../llm/context.js";
+import { settlePlan } from "../llm/plan.js";
 import { LLMClient, describeError } from "../llm/client.js";
 import { formatDelay } from "../llm/retry.js";
 import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planCardRows, planMessage, planRowsWidth, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
 import { DELEGATE_TOOL, executeTool, getSubAgentToolDefinitions, getToolDefinitions } from "../llm/tools.js";
-import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, } from "../llm/subagent.js";
+import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, subAgentRounds, } from "../llm/subagent.js";
 import { assessToolCall } from "../llm/risk.js";
 import { ApprovalGate, captureApprovalContext, describeApprovalIntent, statedReason } from "../llm/approval.js";
 import { COMPACT_KEEP, COMPACT_MAX_CHARS_PER_MESSAGE, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
@@ -21,8 +25,8 @@ const TOOLS = getToolDefinitions();
 /** A sub-agent gets the same tools minus delegation: one level, never a tree. */
 const SUB_AGENT_TOOLS = getSubAgentToolDefinitions();
 /**
- * A finished turn folds its *work* away — the prompt body, the thinking and the
- * tool calls — and never its final reply, which always stays on screen. Doing
+ * A finished turn folds its *work* away — the thinking and the tool calls —
+ * while the full user prompt and final reply always stay on screen. Doing
  * that is only worth a click when the work is substantial: four or more blocks,
  * or roughly six wrapped lines of text. Short exchanges stay readable without a
  * click. `web/turns.js` applies the same rule in the browser, so both UIs fold
@@ -79,6 +83,8 @@ export class ChatScreen extends Screen {
     loadedContext = null;
     loadedApprovalMode = null;
     loadedPlan = null;
+    loadedTask;
+    loadedAgentMode = null;
     approvalMode = "request";
     modelProvider = "DeepSeek";
     model = { name: "deepseek-chat", url: "https://api.deepseek.com/v1", api_key: "", supports_streaming: true };
@@ -105,7 +111,13 @@ export class ChatScreen extends Screen {
     busy = false;
     paused = false;
     queued = null;
+    taskRuntime = null;
+    lastTask;
+    taskOutcome = "completed";
     turnToken = 0;
+    agentMode = "standard";
+    activeAgentMode = "standard";
+    turnAbort = null;
     inputValue = "";
     cursor = 0;
     scrollTop = 0;
@@ -164,6 +176,7 @@ export class ChatScreen extends Screen {
         if (this.initialized)
             return;
         this.initialized = true;
+        this.agentMode = normalizeAgentMode(this.loadedAgentMode);
         this.approvalMode = normalizeApprovalMode(this.loadedApprovalMode ?? loadConfig().approval_mode);
         const st = this.app.state;
         this.modelProvider = this.loadedProvider ?? st.selectedProvider;
@@ -201,6 +214,7 @@ export class ChatScreen extends Screen {
         for (const start of this.userMessageIndexes())
             this.finishedTurns.add(start);
         this.plan = resumePlan(this.loadedPlan);
+        this.lastTask = resumeTaskSnapshot(this.loadedTask);
         this.context = normalizeContext(this.loadedContext, this.messages.filter((m) => m.role !== "system").length);
         this.liveDir = this.loadedCwd ?? process.cwd();
         this.checkpoint.register();
@@ -258,6 +272,9 @@ export class ChatScreen extends Screen {
             model: this.model.name,
             intensity: this.intensity,
             approvalMode: this.approvalMode,
+            agentMode: this.agentMode,
+            activeAgentMode: this.busy ? this.activeAgentMode : this.agentMode,
+            task: this.taskRuntime?.snapshot() ?? this.lastTask,
             busy: this.busy,
             paused: this.paused,
             queued: this.queued,
@@ -300,6 +317,11 @@ export class ChatScreen extends Screen {
         if (this.paused || (!this.busy && !this.queued))
             return;
         this.paused = true;
+        this.subagent = null;
+        this.retryNotice = null;
+        this.reviewing = null;
+        this.planning = false;
+        this.turnAbort?.abort();
         this.turnToken++;
         // A queued decision would otherwise keep the agent awaiting forever.
         if (this.pendingApproval)
@@ -323,6 +345,12 @@ export class ChatScreen extends Screen {
         this.settleApproval(approved);
         return true;
     }
+    liveSetAgentMode(mode) {
+        this.agentMode = mode;
+        this.save();
+        this.publishLive();
+        return { ok: true };
+    }
     liveSetApprovalMode(mode) {
         if (this.approvalMode === mode)
             return;
@@ -344,7 +372,10 @@ export class ChatScreen extends Screen {
             this.app.render();
             return;
         }
+        this.turnAbort?.abort();
         this.turnToken++;
+        this.taskRuntime = null;
+        this.lastTask = undefined;
         if (this.pendingApproval)
             this.settleApproval(false);
         this.busy = false;
@@ -658,6 +689,11 @@ export class ChatScreen extends Screen {
             return;
         this.paused = !this.paused;
         if (this.paused) {
+            this.reviewing = null;
+            this.planning = false;
+            this.subagent = null;
+            this.retryNotice = null;
+            this.turnAbort?.abort();
             this.turnToken++;
             this.busy = false;
             this.app.state.isThinking = false;
@@ -723,9 +759,9 @@ export class ChatScreen extends Screen {
             return null;
         }
         finally {
-            this.planning = false;
-            this.retryNotice = null;
             if (token === this.turnToken) {
+                this.planning = false;
+                this.retryNotice = null;
                 this.app.render();
                 this.publishLive();
             }
@@ -754,16 +790,59 @@ export class ChatScreen extends Screen {
      * own. Without a plan the turn runs in one pass, as before.
      */
     async runTurn(token, turnMessages, approvalContext) {
+        const runtime = new TaskRuntime({
+            request: approvalContext.prompt, priorUserRequests: approvalContext.priorUserRequests,
+            cwd: this.liveDir, signal: this.turnAbort?.signal, limits: taskLimits(loadConfig("standard")),
+            budgetScope: taskBudgetScope(loadConfig("standard")),
+            journalDir: path.join(sessionDir("standard"), "tasks", path.basename(this.sessionId || "unsaved")),
+        });
+        this.taskRuntime = runtime;
+        this.taskOutcome = "completed";
+        let failed = false;
+        try {
+            await runtime.run(() => this.runTaskTurn(token, turnMessages, approvalContext));
+        }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
+        finally {
+            await runtime.drain();
+            if (runtime.signal.aborted)
+                settlePlan(runtime.plan ?? null, true);
+            runtime.finish(runtime.signal.aborted ? "cancelled" : failed ? "failed" :
+                runtime.plan?.steps.some(step => step.status === "failed") ? "failed" :
+                    runtime.plan?.steps.some(step => !["done", "skipped"].includes(step.status)) ? "partial" : this.taskOutcome);
+            if (this.taskRuntime === runtime) {
+                if (runtime.signal.aborted && token === this.turnToken && this.busy && !this.paused) {
+                    if (this.taskOutcome !== "cancelled")
+                        this.messages.push({ role: "assistant", content: `[Task stopped: ${String(runtime.signal.reason)}]\n${runtime.partialReport()}` });
+                    this.streamingContent = null;
+                    this.onTurnFinished(false);
+                }
+                if (this.taskRuntime === runtime) {
+                    this.lastTask = runtime.snapshot();
+                    this.save();
+                    this.publishLive();
+                }
+            }
+        }
+    }
+    async runTaskTurn(token, turnMessages, approvalContext) {
         // Shrink the history before building the request when it has outgrown the
         // configured budget.
         await this.autoCompress(token);
         if (token !== this.turnToken)
             return;
-        const plan = await this.makePlan(token);
+        if (this.activeAgentMode !== "standard")
+            this.plan = null;
+        const plan = this.activeAgentMode === "standard" ? await this.makePlan(token) : null;
         if (token !== this.turnToken)
             return;
         if (plan) {
             this.plan = plan;
+            if (currentTask())
+                currentTask().runtime.plan = plan;
             // The plan is an ordinary assistant message: it is saved, folded, replayed
             // and sent back to the model exactly like any other answer, so later turns
             // (and the user) still know what was agreed.
@@ -783,7 +862,7 @@ export class ChatScreen extends Screen {
                 const finished = await this.agentLoop(this.buildApiMessages(this.turnView(turnMessages), directive), token, approvalContext);
                 if (token !== this.turnToken)
                     return;
-                this.setStep(i, finished ? "done" : "failed");
+                this.setStep(i, currentTask()?.signal.aborted ? "cancelled" : finished ? "done" : "failed");
                 // A step that failed stops the plan: the remaining steps assumed this one
                 // succeeded, and the user has to see the failure before anything runs on
                 // top of it.
@@ -833,6 +912,19 @@ export class ChatScreen extends Screen {
         this.startTurn();
     }
     startTurn() {
+        if (this.taskRuntime?.settling) {
+            const previous = this.taskRuntime;
+            this.queued = lastRequestText(this.messages);
+            this.paused = false;
+            void previous.drain().then(() => {
+                if (this.taskRuntime === previous && this.queued && !this.paused) {
+                    this.queued = null;
+                    this.startTurn();
+                }
+            });
+            this.publishLive();
+            return;
+        }
         // Sending closes every earlier turn, including one left unfinished by
         // ESC ESC: it is folded from here on, but never while it is still paused.
         const starts = this.userMessageIndexes();
@@ -846,6 +938,9 @@ export class ChatScreen extends Screen {
         this.busy = true;
         this.paused = false;
         this.app.state.isThinking = true;
+        this.activeAgentMode = this.agentMode;
+        this.turnAbort?.abort();
+        this.turnAbort = new AbortController();
         const token = ++this.turnToken;
         this.streamingContent = "";
         this.app.render();
@@ -890,7 +985,9 @@ export class ChatScreen extends Screen {
     buildApiMessages(messages = this.messages, directive = "") {
         // A step directive extends the system prompt rather than adding a user
         // message: the plan is an instruction, not something the user just said.
-        const system = directive ? `${loadPrompt()}\n\n${directive}` : loadPrompt();
+        const prompt = loadAgentPrompt(this.activeAgentMode);
+        const system = (directive ? `${prompt}\n\n${directive}` : prompt) +
+            (currentTask() ? `\n\n${currentTask().runtime.instructions()}` : "");
         const api = [{ role: "system", content: system }];
         for (const m of modelHistory(messages, this.context)) {
             if (m.role === "user" || m.role === "assistant") {
@@ -912,6 +1009,9 @@ export class ChatScreen extends Screen {
      * because a planned turn runs this once per step.
      */
     async agentLoop(apiMessages, token, approvalContext) {
+        const tools = this.activeAgentMode === "ptc"
+            ? [...TOOLS, (await import("../llm/codemode.js")).getCodeToolDefinition()] : TOOLS;
+        let emptyReplies = 0;
         try {
             while (true) {
                 if (token !== this.turnToken)
@@ -919,11 +1019,19 @@ export class ChatScreen extends Screen {
                 // Keep the payload inside budget during a long single turn: once the
                 // context is too large, drop the body of older tool results.
                 apiMessages = this.trimApiMessages(apiMessages);
+                if (currentTask())
+                    await prepareContext({
+                        messages: apiMessages, tools, capacity: modelContextWindow(this.modelProvider, this.model, "standard"),
+                        createClient: () => new LLMClient(this.model, this.modelProvider, this.intensity),
+                        stream: { signal: currentTask().runtime.signal, cancelled: () => token !== this.turnToken || this.paused },
+                        onUsage: usage => { this.tokens.prompt += usage.prompt; this.tokens.completion += usage.completion; },
+                    });
                 const client = new LLMClient(this.model, this.modelProvider, this.intensity);
                 let content = "";
                 let hasContent = false;
                 let aborted = false;
-                for await (const chunk of client.streamTurn(apiMessages, TOOLS, {
+                for await (const chunk of client.streamTurn(apiMessages, tools, {
+                    maxOutputTokens: outputAllowance(modelContextWindow(this.modelProvider, this.model)),
                     // A retried request can go quiet for up to 160s, so the status line
                     // says why instead of looking hung. The moment the user pauses or a
                     // newer turn takes over, the backoff is dropped instead of waited out.
@@ -968,8 +1076,42 @@ export class ChatScreen extends Screen {
                     this.app.render();
                     return false;
                 }
+                if (currentTask()?.signal.aborted || client.outcome?.status === "cancelled") {
+                    this.taskOutcome = "cancelled";
+                    this.streamingContent = null;
+                    this.messages.push({ role: "assistant", content: `[Task stopped: ${String(currentTask()?.signal.reason ?? "Task cancelled")}]\n${currentTask()?.runtime.partialReport() ?? ""}` });
+                    return false;
+                }
+                if (client.outcome?.error?.code.endsWith("_budget") && currentTask()) {
+                    const report = await finalTaskReport(currentTask().runtime, () => new LLMClient(this.model, this.modelProvider, this.intensity), usage => { this.tokens.prompt += usage.prompt; this.tokens.completion += usage.completion; }, apiMessages);
+                    if (token !== this.turnToken || this.paused)
+                        return false;
+                    this.taskOutcome = "partial";
+                    this.streamingContent = null;
+                    this.messages.push({ role: "assistant", content: report });
+                    return false;
+                }
+                if (client.outcome?.status === "failed") {
+                    const recorded = currentTask()?.runtime.evidence.length ? currentTask().runtime.partialReport() : "";
+                    const message = client.outcome.error?.message ?? "Model request failed";
+                    this.taskOutcome = recorded ? "partial" : "failed";
+                    this.streamingContent = null;
+                    this.messages.push({ role: "assistant", content: content +
+                            (content.includes(message) ? "" : `\n[Error: ${message}]`) + (recorded ? `\n\n${recorded}` : "") });
+                    return false;
+                }
                 const toolCalls = client.toolCalls;
                 if (toolCalls.length === 0) {
+                    if (!content.trim() && emptyReplies++ === 0)
+                        continue;
+                    if (!content.trim()) {
+                        this.taskOutcome = "failed";
+                        if (!content.trim())
+                            this.messages.push({ role: "assistant", content: "[Error: model returned an empty completion.]" });
+                        else
+                            this.messages.push({ role: "assistant", content });
+                        return false;
+                    }
                     if (hasContent)
                         this.messages.push({ role: "assistant", content });
                     this.streamingContent = null;
@@ -1026,7 +1168,15 @@ export class ChatScreen extends Screen {
                         this.app.render();
                         continue;
                     }
-                    const result = await this.runTool(tc.name, args, toolMsg, token, apiMessages, approvalContext);
+                    let result;
+                    try {
+                        result = await this.runTool(tc.name, args, toolMsg, token, apiMessages, approvalContext);
+                    }
+                    catch (error) {
+                        toolMsg.result = `[Not executed: ${describeError(error)}]`;
+                        this.save();
+                        throw error;
+                    }
                     // A clear starts a different transcript while an old tool may finish.
                     if (!this.messages.includes(toolMsg))
                         return false;
@@ -1044,6 +1194,16 @@ export class ChatScreen extends Screen {
         catch (e) {
             if (token !== this.turnToken)
                 return false;
+            if (e instanceof TaskControlError && e.code.endsWith("_budget") && currentTask()) {
+                const report = await finalTaskReport(currentTask().runtime, () => new LLMClient(this.model, this.modelProvider, this.intensity), usage => { this.tokens.prompt += usage.prompt; this.tokens.completion += usage.completion; }, apiMessages);
+                if (token !== this.turnToken || this.paused)
+                    return false;
+                this.taskOutcome = "partial";
+                this.streamingContent = null;
+                this.messages.push({ role: "assistant", content: report });
+                return false;
+            }
+            this.taskOutcome = "failed";
             const err = describeError(e);
             this.messages.push({ role: "assistant", content: (this.streamingContent ?? "") + `\n[Error: ${err}]` });
             this.streamingContent = null;
@@ -1075,18 +1235,34 @@ export class ChatScreen extends Screen {
     }
     // ---- approval gate ---------------------------------------------------
     /** Classify a tool call and, when it is risky, run it past the gate. */
-    async requestApproval(tool, args, context = captureApprovalContext(this.messages)) {
+    async requestApproval(tool, args, context = captureApprovalContext(this.messages), signal = currentTask()?.runtime.signal ?? this.turnAbort?.signal) {
+        const linked = linkSignals(signal, currentTask()?.signal);
+        signal = linked.signal;
+        try {
+            currentTask()?.runtime.assertTool(tool, args);
+        }
+        catch (error) {
+            linked.dispose();
+            return { approved: false, source: "input", reason: error instanceof Error ? error.message : String(error) };
+        }
         const risk = assessToolCall(tool, args, this.liveDir);
-        if (!risk)
+        if (!risk) {
+            linked.dispose();
             return { approved: true, source: "prompt", reason: "routine call" };
+        }
+        const approvalToken = this.turnToken;
+        const cancelled = () => approvalToken !== this.turnToken || this.paused || signal?.aborted === true;
         const gate = new ApprovalGate({
-            askHuman: () => this.askHuman(tool, args, risk),
+            cancelled,
+            askHuman: () => cancelled() ? Promise.resolve(false) : this.askHuman(tool, args, risk),
             reviewer: () => this.reviewerModel(),
             autoApprovalEnabled: () => this.approvalMode === "auto",
             extremeAutoApprovalEnabled: () => loadConfig().auto_approve_extreme_risk === true,
             // Reviews happen before any card is shown, so without this the app looks
             // frozen while the independent assessments run.
             onReview: (info) => {
+                if (cancelled())
+                    return;
                 this.reviewing = info ? {
                     total: info.total, round: info.round ?? 1, rounds: info.rounds ?? 1,
                     request: liveApprovalDetails(tool, args, risk, this.liveDir),
@@ -1103,7 +1279,18 @@ export class ChatScreen extends Screen {
                 this.app.showToast(`independent review running (${which}${info.total} reviewer${info.total > 1 ? "s" : ""})...`);
             },
         });
-        return gate.decide({ tool, args, cwd: this.liveDir, ...context, risk });
+        const abortApproval = () => {
+            if (this.pendingApproval?.args === args)
+                this.settleApproval(false);
+        };
+        signal.addEventListener("abort", abortApproval, { once: true });
+        try {
+            return await gate.decide({ tool, args, cwd: this.liveDir, ...context, risk });
+        }
+        finally {
+            signal.removeEventListener("abort", abortApproval);
+            linked.dispose();
+        }
     }
     /** Park the turn until the user answers; the header turns orange meanwhile. */
     askHuman(tool, args, risk) {
@@ -1193,15 +1380,97 @@ export class ChatScreen extends Screen {
         };
     }
     // ---- sub-agents ------------------------------------------------------
+    async runProgram(args, token, apiMessages, approvalContext) {
+        if (this.activeAgentMode !== "ptc")
+            return "[Error: execute_ts requires PTC mode]";
+        const { executeCodeProgram, ProgramToolDenied } = await import("../llm/codemode.js");
+        const signal = currentTask()?.runtime.signal ?? this.turnAbort?.signal;
+        const cancelled = () => token !== this.turnToken || this.paused || signal?.aborted;
+        const result = await executeCodeProgram(args, {
+            signal,
+            onPlan: plan => {
+                if (cancelled())
+                    return;
+                this.plan = plan;
+                if (currentTask())
+                    currentTask().runtime.plan = plan;
+                this.save();
+                this.publishLive();
+                this.app.render();
+            },
+            onStep: (index, status) => { if (!cancelled())
+                this.setStep(index, status); },
+            call: async (name, callArgs, programSignal) => {
+                if (cancelled() || programSignal?.aborted)
+                    throw new Error("Execution cancelled");
+                const message = { role: "tool", name, arguments: callArgs, result: "…" };
+                this.messages.push(message);
+                this.save();
+                this.publishLive();
+                this.app.render();
+                const stopApproval = () => {
+                    if (this.pendingApproval?.args !== callArgs)
+                        return;
+                    this.settleApproval(false);
+                };
+                programSignal?.addEventListener("abort", stopApproval, { once: true });
+                try {
+                    const decision = await this.requestApproval(name, callArgs, {
+                        ...approvalContext, context: captureApprovalContext(apiMessages).context,
+                    }, programSignal);
+                    if (cancelled() || programSignal?.aborted)
+                        throw new Error("Execution cancelled");
+                    if (!decision.approved) {
+                        message.result = `[Not executed: ${decision.reason}]`;
+                        throw new ProgramToolDenied(`Approval denied: ${decision.reason}. Do not retry or work around this denial.`);
+                    }
+                    const value = await this.runTool(name, callArgs, message, token, apiMessages, approvalContext, programSignal);
+                    message.result = value;
+                    if (cancelled() || programSignal?.aborted)
+                        throw new Error("Execution cancelled");
+                    return value;
+                }
+                catch (error) {
+                    if (message.result === "…")
+                        message.result = `[Error: ${error instanceof Error ? error.message : String(error)}]`;
+                    throw error;
+                }
+                finally {
+                    programSignal?.removeEventListener("abort", stopApproval);
+                    if (this.messages.includes(message)) {
+                        this.save();
+                        this.publishLive();
+                        this.app.render();
+                    }
+                }
+            },
+        });
+        if (!cancelled()) {
+            this.save();
+            this.publishLive();
+            this.app.render();
+        }
+        return result;
+    }
     /**
      * Run one approved tool call. `delegate` is handled here rather than inside
      * tools.ts: a sub-agent has to share this turn's model, approval gate, working
      * directory and abort signal, and only the session knows about those.
      */
-    async runTool(name, args, toolMsg, token, apiMessages, approvalContext) {
+    async runTool(name, args, toolMsg, token, apiMessages, approvalContext, executionSignal) {
+        const runtime = currentTask()?.runtime;
+        const execute = () => this.dispatchTool(name, args, toolMsg, token, apiMessages, approvalContext, executionSignal);
+        if (!runtime)
+            return execute();
+        const result = await runtime.tool(name, args, execute);
+        return result;
+    }
+    async dispatchTool(name, args, toolMsg, token, apiMessages, approvalContext, signal = currentTask()?.runtime.signal ?? this.turnAbort?.signal) {
+        if (name === "execute_ts")
+            return this.runProgram(args, token, apiMessages, approvalContext);
         if (name !== DELEGATE_TOOL)
-            return executeTool(name, args, this.liveDir);
-        return this.delegate(args, toolMsg, token, apiMessages, approvalContext);
+            return executeTool(name, args, this.liveDir, signal);
+        return this.delegate(args, toolMsg, token, apiMessages, approvalContext, signal);
     }
     /**
      * Run a sub-agent for one `delegate` call and return its report.
@@ -1211,22 +1480,33 @@ export class ChatScreen extends Screen {
      * part of this transcript. While it runs, its current phase is shown in the
      * status line and in the tool block, so a quiet log still has an explanation.
      */
-    async delegate(args, toolMsg, token, apiMessages, approvalContext) {
+    async delegate(args, toolMsg, token, apiMessages, approvalContext, executionSignal) {
         const task = String(args.task ?? "").trim();
         if (!task)
             return "[Error: delegate needs a task: what should the sub-agent do?]";
         const context = typeof args.context === "string" ? args.context.trim() : "";
         const approval = { ...approvalContext, context: captureApprovalContext(apiMessages).context };
+        const maxRounds = subAgentRounds(loadConfig().subagent_max_rounds);
+        const runtime = currentTask()?.runtime;
+        const signal = executionSignal ?? runtime?.signal ?? this.turnAbort?.signal;
+        const stopped = () => token !== this.turnToken || this.paused || signal?.aborted === true;
         const run = await runSubAgentTask({
+            runtime, signal,
+            readOnly: args.read_only === true,
+            writePaths: Array.isArray(args.write_paths) ? args.write_paths.filter((p) => typeof p === "string") : undefined,
+            contextWindow: modelContextWindow(this.modelProvider, this.model, "standard"),
             createClient: () => new LLMClient(this.model, this.modelProvider, this.intensity),
             system: loadSubAgentPrompt(),
-            task: buildSubAgentTask({ task, context, cwd: this.liveDir }),
+            task: buildSubAgentTask({ task, context, cwd: this.liveDir, rounds: maxRounds }),
             tools: SUB_AGENT_TOOLS,
-            approve: (name, callArgs) => this.requestApproval(name, callArgs, approval),
+            maxRounds,
+            approve: (name, callArgs) => this.requestApproval(name, callArgs, approval, signal),
             execute: (name, callArgs) => name === DELEGATE_TOOL
                 ? Promise.resolve("[Error: sub-agents cannot delegate further]")
-                : executeTool(name, callArgs, this.liveDir),
+                : executeTool(name, callArgs, this.liveDir, signal),
             onProgress: (label) => {
+                if (stopped())
+                    return;
                 this.subagent = label;
                 // The tool block is what a reader of the transcript sees while the child
                 // works; the status line says the same thing at the top of the screen.
@@ -1235,24 +1515,30 @@ export class ChatScreen extends Screen {
                 this.publishLive();
             },
             onUsage: (usage) => {
+                if (stopped())
+                    return;
                 this.tokens.prompt += usage.prompt;
                 this.tokens.completion += usage.completion;
             },
             onRetry: (notice) => {
+                if (stopped())
+                    return;
                 this.retryNotice =
                     `Sub-agent — network hiccup, retrying in ${formatDelay(notice.delayMs)} ` +
                         `(attempt ${notice.attempt}/${notice.attempts})`;
                 this.app.render();
             },
-            cancelled: () => token !== this.turnToken || this.paused,
+            cancelled: () => token !== this.turnToken || this.paused || signal?.aborted === true,
         });
         // The final report replaces the live marker, and the status line goes back
         // to the parent's own state.
-        this.subagent = null;
-        this.retryNotice = null;
-        toolMsg.result = "";
-        this.app.render();
-        this.publishLive();
+        if (!stopped()) {
+            this.subagent = null;
+            this.retryNotice = null;
+            toolMsg.result = "";
+            this.app.render();
+            this.publishLive();
+        }
         return formatSubAgentResult(run);
     }
     // ---- turn folding ----------------------------------------------------
@@ -1276,7 +1562,7 @@ export class ChatScreen extends Screen {
     /**
      * A finished turn is only worth folding when the work it hides is substantial.
      * Whether it is folded right now is a separate question (`expandedTurns`), and
-     * its reply is never part of what it hides.
+     * its user input and reply are never part of what it hides.
      */
     turnHides(start, end) {
         if (!this.finishedTurns.has(start))
@@ -1285,12 +1571,12 @@ export class ChatScreen extends Screen {
         let blocks = 0;
         let chars = 0;
         for (let i = start; i < end; i++) {
-            // The reply stays on screen, so it is neither hidden content nor a reason
-            // to fold: a long answer alone must never collapse its own turn.
+            // User input and the reply stay on screen, so neither counts toward the
+            // folding threshold, however long either one is.
             if (i === answer)
                 continue;
             const m = this.messages[i];
-            if (m.role === "user" || m.role === "assistant") {
+            if (m.role === "assistant") {
                 blocks++;
                 chars += m.content.length;
             }
@@ -1345,23 +1631,6 @@ export class ChatScreen extends Screen {
         }
         return map;
     }
-    /**
-     * The first line of the first message in `role`. Only one line: the header is
-     * a signpost, and the full text is one click away.
-     */
-    turnPreview(start, end, role) {
-        for (const m of this.messages.slice(start, end)) {
-            if (m.role !== role)
-                continue;
-            const line = sanitizeText(m.content)
-                .split("\n")
-                .map((part) => part.trim())
-                .find((part) => part.length > 0);
-            if (line)
-                return line;
-        }
-        return "";
-    }
     /** The header standing in for a folded turn, or the way back into one. */
     pushTurnHeader(start, end, width, add) {
         const count = end - start;
@@ -1378,13 +1647,10 @@ export class ChatScreen extends Screen {
             }, -1, start);
             return;
         }
-        const you = `You: ${this.turnPreview(start, end, "user") || "(no text)"}`;
-        add({ spans: [{ text: ellipsize(`▸ ${you}`, width), style: { fg: C.amber, bold: true } }] }, -1, start);
-        // The prompt and the reply sit either side of the work this fold hides, so
-        // the control line goes between them and the answer stays on screen below.
-        const hidden = this.turnAnswer(start, end) < 0 ? count : count - 1;
+        const answer = this.turnAnswer(start, end);
+        const hidden = this.messages.slice(start, end).filter((message, offset) => message.role !== "user" && message.role !== "system" && start + offset !== answer).length;
         const meta = `${hidden} of ${count} message${count === 1 ? "" : "s"} folded`;
-        add({ spans: [{ text: ellipsize(`  ${meta} — click to expand`, width), style: { fg: C.dim } }] }, -1, start);
+        add({ spans: [{ text: ellipsize(`▸ ${meta} — click to expand`, width), style: { fg: C.dim } }] }, -1, start);
     }
     /** Fold or unfold one turn. */
     toggleTurn(start) {
@@ -1525,7 +1791,7 @@ export class ChatScreen extends Screen {
         if (chatMessages.length === 0)
             return true;
         try {
-            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, this.liveDir, this.sessionId ?? undefined, this.tokens, this.context, this.approvalMode, this.plan);
+            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, this.liveDir, this.sessionId ?? undefined, this.tokens, this.context, this.approvalMode, this.plan, "standard", undefined, this.agentMode, this.taskRuntime?.snapshot() ?? this.lastTask);
             this.saveError = null;
             return true;
         }
@@ -1577,26 +1843,24 @@ export class ChatScreen extends Screen {
                 archived = context !== null && recordIndex < context.end;
                 recordIndex++;
             }
-            // A foldable turn always shows its control lines first; its work then
-            // renders when the reader has opened it, and its reply always does.
-            if (m.role !== "system" && turn === mi && !(archived && !this.expandedContext)) {
-                this.pushTurnHeader(mi, this.turnEnd(mi), width, add);
-            }
             const folded = turn >= 0 && !this.expandedTurns.has(turn);
             const reply = folded && answers[mi] === mi;
             if (m.role === "system") {
                 pushText(sanitizeText(m.content), { fg: C.dim });
             }
-            else if ((archived && !this.expandedContext) || (folded && !reply)) {
-                // Hidden: by the collapsed "Earlier conversation" fold, or by the turn's
-                // own fold, which hides the prompt body and the work but never the
-                // reply. Either way the message stays in the transcript, on disk and in
-                // the request; the header above says how to get it back on screen.
-            }
             else if (m.role === "user") {
                 add({ spans: [{ text: "You:", style: { fg: C.accent, bold: true } }] });
                 pushMarkdown(sanitizeText(m.content), { fg: C.user });
                 add({ spans: [] });
+                // The fold control follows the complete prompt, which stays visible
+                // even when the turn or the earlier conversation is collapsed.
+                if (turn === mi && !(archived && !this.expandedContext)) {
+                    this.pushTurnHeader(mi, this.turnEnd(mi), width, add);
+                }
+            }
+            else if ((archived && !this.expandedContext) || (folded && !reply)) {
+                // Only AI output is hidden. Every message remains in the transcript,
+                // on disk and in the request; the controls reveal it again.
             }
             else if (m.role === "assistant") {
                 add({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
@@ -1621,7 +1885,7 @@ export class ChatScreen extends Screen {
                 add({ spans: [{ text: `⚙ ${m.name}`, style: { fg: C.toolHeader, bold: true } }] }, mi);
                 // The line under the tool name is the call's own material: a command, a
                 // path, or — for `delegate` — the task handed to the sub-agent.
-                const argText = sanitizeText(m.arguments.command ?? m.arguments.path ?? m.arguments.task ?? "", { singleLine: true });
+                const argText = sanitizeText(m.arguments.command ?? m.arguments.path ?? m.arguments.query ?? m.arguments.task ?? "", { singleLine: true });
                 if (argText)
                     add({ spans: [{ text: "  " + argText, style: { fg: C.dim } }] }, mi);
                 const decision = this.approvals.get(m);
@@ -1650,7 +1914,7 @@ export class ChatScreen extends Screen {
                 }
                 add({ spans: [] });
             }
-            if (context && archived && recordIndex === context.end) {
+            if (context && archived && recordIndex === context.end && this.expandedContext) {
                 this.contextLines.add(lines.length);
                 add({ spans: [{ text: "▾ Collapse earlier conversation", style: { fg: C.amber } }] });
                 add({ spans: [] });
@@ -1674,6 +1938,10 @@ export class ChatScreen extends Screen {
             status = `History save failed: ${sanitizeText(this.saveError, { singleLine: true })}`;
             statusStyle = { fg: C.orange, bold: true };
         }
+        else if (this.taskRuntime?.snapshot().state === "cancelling") {
+            status = "Stopping tasks…";
+            statusStyle = { fg: C.amber, bold: true };
+        }
         else if (this.compressing) {
             status = "Compressing context…";
             statusStyle = { fg: C.amber, bold: true };