@xingjisoft/neutrino 0.5.2 → 0.6.2

package/dist/web/session.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 /**
  * Headless conversation runner for the web UI.
  *
@@ -11,15 +12,18 @@
  * (snapshot, stream, pause, resume, message) work unchanged.
  */
 import { randomUUID } from "node:crypto";
-import { findModel, contextCompressionThreshold, intensityForModel, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
+import { findModel, contextCompressionThreshold, modelContextWindow, sessionDir, intensityForModel, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadAgentPrompt, normalizeAgentMode, saveSession, } from "../config.js";
 import { COMPACT_KEEP, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
+import { TaskRuntime, TaskControlError, currentTask, linkSignals, taskLimits, taskBudgetScope, resumeTaskSnapshot } from "../llm/runtime.js";
+import { prepareContext, outputAllowance, finalTaskReport } from "../llm/context.js";
+import { FINISH_STEP_TOOL, FINISH_STEP_DEFINITION, finishPlanStep, preparePlan, settlePlan } from "../llm/plan.js";
 import { LLMClient, describeError } from "../llm/client.js";
 import { defaultProPreset, loadProModels, loadProPrompt, proMaxRecursionDepth, requireProPreset } from "../pro/config.js";
 import { resolveProTeam, ProPreflightError } from "../pro/preflight.js";
 import { ProAgentTeam, getProToolDefinitions } from "../pro/agents.js";
 import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planMessage, 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 } from "../llm/approval.js";
 import { SessionCheckpoint } from "../persistence.js";
@@ -45,7 +49,7 @@ export function newSessionId(now = new Date()) {
  * written to disk until the first message, so an abandoned new-chat dialog
  * cannot litter the history with empty transcripts.
  */
-export function createWebSession(cwd, selection, approvalMode, mode = "standard", proPreset) {
+export function createWebSession(cwd, selection, approvalMode, mode = "standard", proPreset, agentMode = "standard") {
     const now = new Date();
     const source = {
         id: newSessionId(now),
@@ -59,6 +63,7 @@ export function createWebSession(cwd, selection, approvalMode, mode = "standard"
         messages: [],
         tokens: { prompt: 0, completion: 0 },
         approval_mode: normalizeApprovalMode(approvalMode ?? loadConfig(mode).approval_mode),
+        agent_mode: mode === "pro" ? "standard" : agentMode,
         ...(mode === "pro" ? { pro_preset: requireProPreset(proPreset ?? defaultProPreset()) } : {}),
     };
     return new WebSession(source, selection.model, mode);
@@ -161,7 +166,13 @@ export class WebSession {
         this.publishLive();
         return saved;
     });
+    taskRuntime = null;
+    lastTask;
+    taskOutcome = "completed";
     turnToken = 0;
+    agentMode = "standard";
+    activeAgentMode = "standard";
+    turnAbort = null;
     lastPromptTokens = 0;
     disposed = false;
     idleTimer = null;
@@ -171,6 +182,7 @@ export class WebSession {
     reviewing = null;
     constructor(source, model, mode = "standard") {
         this.mode = mode;
+        this.agentMode = mode === "pro" ? "standard" : normalizeAgentMode(source.agent_mode);
         if (mode === "pro")
             this.proPreset = requireProPreset(source.pro_preset ?? defaultProPreset());
         this.model = model;
@@ -184,6 +196,7 @@ export class WebSession {
         this.messages = source.messages.slice();
         this.context = normalizeContext(source.context, this.messages.filter((m) => m.role !== "system").length);
         this.plan = resumePlan(source.plan ?? null);
+        this.lastTask = resumeTaskSnapshot(source.task_run);
         this.tokens = {
             prompt: source.tokens?.prompt ?? 0,
             completion: source.tokens?.completion ?? 0,
@@ -204,6 +217,7 @@ export class WebSession {
             return;
         this.disposed = true;
         this.proAbort?.abort();
+        this.turnAbort?.abort();
         this.turnToken++;
         this.busy = false;
         if (this.pendingApproval) {
@@ -267,6 +281,9 @@ export class WebSession {
             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,
@@ -316,6 +333,7 @@ export class WebSession {
             return;
         this.paused = true;
         this.proAbort?.abort();
+        this.turnAbort?.abort();
         this.turnToken++;
         // A queued decision would otherwise keep the promise (and the gate) alive.
         if (this.pendingApproval) {
@@ -328,11 +346,9 @@ export class WebSession {
         this.subagent = null;
         if (this.proState)
             this.proState.checking = false;
-        if (this.mode === "pro") {
-            this.reviewing = null;
-            this.retrying = null;
-            this.planning = false;
-        }
+        this.reviewing = null;
+        this.retrying = null;
+        this.planning = false;
         stopPlan(this.plan);
         this.save();
         this.publishLive();
@@ -356,6 +372,14 @@ export class WebSession {
         this.publishLive();
         return true;
     }
+    liveSetAgentMode(mode) {
+        if (this.mode === "pro" || this.disposed)
+            return { ok: false, error: "this session cannot change agent mode" };
+        this.agentMode = mode;
+        this.save();
+        this.publishLive();
+        return { ok: true };
+    }
     liveSetApprovalMode(mode) {
         if (this.approvalMode === mode)
             return;
@@ -382,7 +406,10 @@ export class WebSession {
         this.proAbort?.abort();
         this.proTeam = null;
         this.proState = undefined;
+        this.turnAbort?.abort();
         this.turnToken++;
+        this.taskRuntime = null;
+        this.lastTask = undefined;
         if (this.pendingApproval) {
             const pending = this.pendingApproval;
             this.pendingApproval = null;
@@ -430,9 +457,24 @@ export class WebSession {
         this.startTurn();
     }
     startTurn() {
+        if (this.taskRuntime?.settling) {
+            const previous = this.taskRuntime;
+            this.queued = lastRequestText(this.messages);
+            void previous.drain().then(() => {
+                if (this.taskRuntime === previous && this.queued && !this.paused) {
+                    this.queued = null;
+                    this.startTurn();
+                }
+            });
+            this.publishLive();
+            return;
+        }
         const turnMessages = this.messages.slice();
         const approvalContext = captureApprovalContext(turnMessages);
         this.busy = true;
+        this.activeAgentMode = this.agentMode;
+        this.turnAbort?.abort();
+        this.turnAbort = new AbortController();
         const token = ++this.turnToken;
         this.streamingContent = "";
         this.publishLive();
@@ -449,16 +491,59 @@ export class WebSession {
      * pass, exactly as it did before planning existed.
      */
     async runTurn(token, turnMessages, approvalContext) {
+        const runtime = new TaskRuntime({
+            request: approvalContext.prompt, priorUserRequests: approvalContext.priorUserRequests,
+            cwd: this.dir, signal: this.turnAbort?.signal, limits: taskLimits(loadConfig(this.mode)),
+            budgetScope: taskBudgetScope(loadConfig(this.mode)),
+            journalDir: path.join(sessionDir(this.mode), "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 && !this.disposed) {
+                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();
+                }
+                if (this.taskRuntime === runtime) {
+                    this.lastTask = runtime.snapshot();
+                    this.save();
+                    this.publishLive();
+                }
+            }
+        }
+    }
+    async runTaskTurn(token, turnMessages, approvalContext) {
         if (this.mode === "pro")
             return this.runProTurn(token, turnMessages, approvalContext);
         await this.autoCompress(token);
         if (token !== this.turnToken || this.paused)
             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 || this.paused)
             return;
         if (plan) {
             this.plan = plan;
+            if (currentTask())
+                currentTask().runtime.plan = plan;
             this.messages.push({ role: "assistant", content: planMessage(plan) });
             this.save();
             this.publishLive();
@@ -470,7 +555,7 @@ export class WebSession {
                 const finished = await this.agentLoop(this.buildApiMessages(this.turnView(turnMessages), renderStepDirective(template, plan, i)), token, approvalContext);
                 if (token !== this.turnToken || this.paused)
                     return;
-                this.setStep(i, finished ? "done" : "failed");
+                this.setStep(i, currentTask()?.signal.aborted ? "cancelled" : finished ? "done" : "failed");
                 if (!finished)
                     break;
             }
@@ -484,7 +569,8 @@ export class WebSession {
     }
     /** Freeze one resolved team per task, plan first, then give the whole brief to main. */
     async runProTurn(token, turnMessages, approvalContext) {
-        const cancelled = () => token !== this.turnToken || this.paused || this.disposed;
+        const taskSignal = currentTask()?.signal;
+        const cancelled = () => token !== this.turnToken || this.paused || this.disposed || taskSignal?.aborted === true;
         const controller = new AbortController();
         this.proAbort = controller;
         this.proTeam = null;
@@ -509,6 +595,7 @@ export class WebSession {
             this.proState.fallbacks = resolved.fallbacks;
             this.proState.checking = false;
             const team = new ProAgentTeam({
+                runtime: currentTask()?.runtime, request: approvalContext.prompt,
                 models: resolved.models, maxDepth: proMaxRecursionDepth(), cwd: this.dir, cancelled,
                 approve: (name, args) => this.requestApproval(name, args, {
                     ...approvalContext, context: captureApprovalContext(this.turnView(turnMessages)).context,
@@ -537,48 +624,44 @@ export class WebSession {
             this.publishLive();
             this.planning = true;
             this.publishLive();
-            const planning = await team.call("plan_model", buildPlannerInput({
+            const planningResult = await team.callResult("plan_model", buildPlannerInput({
                 request: approvalContext.prompt, cwd: this.dir, transcript: planTranscript(turnMessages),
             }), "Plan the task before execution. Do not modify files or execute commands.", 0, true);
+            const planning = planningResult.report;
             if (cancelled())
                 return;
             this.planning = false;
             this.subagent = null;
             this.retrying = null;
-            if (!planning.trim() || /\[Error:|\[Sub-agent .*without.*report/.test(planning)) {
-                throw new Error(`Pro planning failed: ${planning}`);
-            }
-            this.plan = parsePlan(planning);
-            if (!this.plan) {
-                // Standard planning skips single actions; Pro plans every task.
-                try {
-                    const single = JSON.parse(planning.trim().replace(/^```(?:json)?\s*|\s*```$/g, ""));
-                    if (single.steps?.length === 1 && typeof single.steps[0].title === "string" && single.steps[0].title.trim()) {
-                        this.plan = { goal: String(single.goal ?? "").slice(0, 240), steps: [{
-                                    title: single.steps[0].title.slice(0, 160), detail: String(single.steps[0].detail ?? "").slice(0, 400), status: "pending",
-                                }] };
-                    }
-                }
-                catch { /* A useful prose plan can still guide the main agent. */ }
+            if (planningResult.status !== "completed" || !planning.trim()) {
+                throw new Error(`Pro planning failed: ${planningResult.error?.message ?? planning}`);
             }
+            this.plan = parsePlan(planning, 1);
+            if (!this.plan)
+                throw new Error("Pro planning failed: no usable plan steps were returned");
             await this.autoCompress(token);
             if (cancelled())
                 return;
+            if (this.plan) {
+                preparePlan(this.plan);
+                if (currentTask())
+                    currentTask().runtime.plan = this.plan;
+            }
             this.messages.push({ role: "assistant", content: this.plan ? planMessage(this.plan) : planning });
             this.save();
             this.publishLive();
-            const directive = `The planning agent produced this plan for the current user request:\n${planning}\n\n` +
-                "Execute the complete task, using the appropriate professional agents for reasoning, frontend, backend and modeling work. Verify the result and report the outcome.";
+            const directive = `The planning agent produced this plan for the current user request:\n${JSON.stringify(this.plan ?? planning)}\n\n` +
+                "Execute the complete task using the appropriate professional agents. Own integration and verification. " +
+                "Call finish_step for each accepted step using its step_id and actual evidence IDs, existing artifact paths, or the final text deliverable. " +
+                "Record blocked or failed steps explicitly. Ending a reply never completes plan steps.";
             if (this.plan?.steps.length)
                 this.setStep(0, "active");
             const finished = await this.agentLoop(this.buildApiMessages(this.turnView(turnMessages), directive), token, approvalContext);
             if (cancelled())
                 return;
             if (this.plan) {
-                if (finished)
-                    for (let i = 0; i < this.plan.steps.length; i++)
-                        this.setStep(i, "done");
-                else
+                settlePlan(this.plan, currentTask()?.signal.aborted === true);
+                if (!finished && this.taskOutcome !== "partial" && this.plan.steps[0]?.status === "blocked")
                     this.setStep(0, "failed");
             }
         }
@@ -660,10 +743,11 @@ export class WebSession {
             return null;
         }
         finally {
-            this.planning = false;
-            this.retrying = null;
-            if (token === this.turnToken)
+            if (token === this.turnToken) {
+                this.planning = false;
+                this.retrying = null;
                 this.publishLive();
+            }
         }
     }
     /** Ends a turn whose floating promise rejected, instead of crashing the app. */
@@ -686,9 +770,10 @@ export class WebSession {
     buildApiMessages(messages = this.messages, directive = "") {
         // A step directive extends the system prompt: the plan is an instruction, not
         // something the user just said.
-        const prompt = this.mode === "pro" ? loadProPrompt("main_model") : loadPrompt();
+        const prompt = this.mode === "pro" ? loadProPrompt("main_model") : loadAgentPrompt(this.activeAgentMode);
         const api = [
-            { role: "system", content: directive ? `${prompt}\n\n${directive}` : prompt },
+            { role: "system", content: (directive ? `${prompt}\n\n${directive}` : prompt) +
+                    (currentTask() ? `\n\n${currentTask().runtime.instructions()}` : "") },
         ];
         for (const m of modelHistory(messages, this.context)) {
             if (m.role === "user" || m.role === "assistant") {
@@ -706,8 +791,12 @@ export class WebSession {
      * the caller owns the turn's end because a planned turn runs this per step.
      */
     async agentLoop(apiMessages, token, approvalContext) {
-        const tools = this.mode === "pro" ? getProToolDefinitions() : getToolDefinitions();
+        const tools = this.mode === "pro" ? [...getProToolDefinitions(), FINISH_STEP_DEFINITION] : [
+            ...getToolDefinitions(),
+            ...(this.activeAgentMode === "ptc" ? [(await import("../llm/codemode.js")).getCodeToolDefinition()] : []),
+        ];
         const team = this.proTeam;
+        let emptyReplies = 0;
         try {
             while (true) {
                 if (token !== this.turnToken || this.paused)
@@ -715,11 +804,19 @@ export class WebSession {
                 // Match the terminal: long tasks can keep using tools until the model
                 // finishes, while older tool results are trimmed near the context limit.
                 apiMessages = this.trimApiMessages(apiMessages);
+                if (currentTask())
+                    await prepareContext({
+                        messages: apiMessages, tools, capacity: team?.contextWindow("main_model") ?? modelContextWindow(this.provider, this.model, this.mode),
+                        createClient: () => team?.client("main_model") ?? new LLMClient(this.model, this.provider, 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 = team ? team.client("main_model") : new LLMClient(this.model, this.provider, this.intensity);
                 let text = "";
                 this.streamingContent = "";
                 this.publishLive();
                 for await (const chunk of client.streamTurn(apiMessages, tools, {
+                    maxOutputTokens: outputAllowance(team?.contextWindow("main_model") ?? modelContextWindow(this.provider, this.model, this.mode)),
                     onRetry: (notice) => {
                         this.retrying = notice;
                         this.publishLive();
@@ -742,6 +839,30 @@ export class WebSession {
                     this.tokens.completion += client.usage.completion;
                     this.lastPromptTokens = client.usage.prompt;
                 }
+                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, () => team?.client("main_model") ?? new LLMClient(this.model, this.provider, 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: text +
+                            (text.includes(message) ? "" : `\n[Error: ${message}]`) + (recorded ? `\n\n${recorded}` : "") });
+                    return false;
+                }
                 const toolCalls = client.toolCalls;
                 if (text.trim()) {
                     this.messages.push({ role: "assistant", content: text });
@@ -770,11 +891,17 @@ export class WebSession {
                 this.save();
                 this.publishLive();
                 if (toolCalls.length === 0) {
-                    if (this.mode === "pro" && !text.trim()) {
+                    if (!text.trim() && emptyReplies++ === 0)
+                        continue;
+                    if (!text.trim()) {
+                        this.taskOutcome = "failed";
                         this.messages.push({ role: "assistant", content: "[Error: Pro main model returned an empty completion.]" });
                         return false;
                     }
-                    return !/\[Error:/.test(text);
+                    const success = client.outcome ? client.outcome.status === "completed" : !/\[Error:/.test(text);
+                    if (!success)
+                        this.taskOutcome = "failed";
+                    return success;
                 }
                 for (const call of toolCalls) {
                     if (token !== this.turnToken || this.paused)
@@ -804,6 +931,7 @@ export class WebSession {
                                 describeApprovalIntent(approvalContext) +
                                 "Do not retry this call unchanged; ask the user how to proceed.";
                         toolMsg.result = denied;
+                        currentTask()?.runtime.recordTool(call.name, args, denied, "denied");
                         apiMessages.push({ role: "tool", content: denied, tool_call_id: call.id });
                         this.save();
                         this.publishLive();
@@ -814,6 +942,13 @@ export class WebSession {
                         result = await this.runTool(call.name, args, toolMsg, token, apiMessages, approvalContext);
                     }
                     catch (err) {
+                        if (err instanceof TaskControlError && err.code.endsWith("_budget")) {
+                            toolMsg.result = `[Not executed: ${describeError(err)}]`;
+                            this.save();
+                            throw err;
+                        }
+                        if (token === this.turnToken)
+                            this.taskOutcome = "failed";
                         result = `Error: ${err instanceof Error ? err.message : String(err)}`;
                     }
                     if (this.disposed)
@@ -822,7 +957,8 @@ export class WebSession {
                     this.save();
                     if (token !== this.turnToken || this.paused)
                         return false;
-                    apiMessages.push({ role: "tool", content: result, tool_call_id: call.id });
+                    apiMessages.push({ role: "tool", content: toolMsg.evidenceId
+                            ? `${result}\n[Task evidence: ${toolMsg.evidenceId}; status=${toolMsg.executionStatus}]` : result, tool_call_id: call.id });
                     this.publishLive();
                 }
                 this.save();
@@ -831,6 +967,15 @@ export class WebSession {
         catch (err) {
             if (token !== this.turnToken)
                 return false;
+            if (err instanceof TaskControlError && err.code.endsWith("_budget") && currentTask()) {
+                const report = await finalTaskReport(currentTask().runtime, () => team?.client("main_model") ?? new LLMClient(this.model, this.provider, 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 (this.streamingContent) {
                 this.messages.push({ role: "assistant", content: this.streamingContent });
             }
@@ -856,15 +1001,26 @@ export class WebSession {
     }
     // ---- approval gate ---------------------------------------------------
     /** Classify a tool call and, when it is risky, wait for a decision. */
-    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.dir);
-        if (!risk)
+        if (!risk) {
+            linked.dispose();
             return { approved: true, source: "prompt", reason: "routine call" };
+        }
         const approvalToken = this.turnToken;
         const team = this.proTeam;
         const gate = new ApprovalGate({
             askHuman: () => new Promise((resolve) => {
-                if (this.mode === "pro" && (approvalToken !== this.turnToken || this.paused || this.disposed)) {
+                if (approvalToken !== this.turnToken || this.paused || this.disposed || signal?.aborted === true) {
                     resolve(false);
                     return;
                 }
@@ -875,12 +1031,12 @@ export class WebSession {
             ...(this.mode === "pro" && team ? {
                 createReviewerClient: () => team.client("confirm_model"),
                 reviewerSystemPrompt: () => loadProPrompt("confirm_model"),
-                cancelled: () => approvalToken !== this.turnToken || this.paused || this.disposed,
             } : {}),
+            cancelled: () => approvalToken !== this.turnToken || this.paused || this.disposed || signal?.aborted === true,
             autoApprovalEnabled: () => this.approvalMode === "auto",
             extremeAutoApprovalEnabled: () => loadConfig(this.mode).auto_approve_extreme_risk === true,
             onReview: (info) => {
-                if (this.mode === "pro" && (approvalToken !== this.turnToken || this.paused || this.disposed))
+                if (approvalToken !== this.turnToken || this.paused || this.disposed || signal?.aborted === true)
                     return;
                 this.reviewing = info
                     ? {
@@ -891,7 +1047,22 @@ export class WebSession {
                 this.publishLive();
             },
         });
-        return gate.decide({ tool, args, cwd: this.dir, ...context, risk });
+        const abortApproval = () => {
+            const pending = this.pendingApproval;
+            if (pending?.args !== args)
+                return;
+            this.pendingApproval = null;
+            pending.resolve(false);
+            this.publishLive();
+        };
+        signal.addEventListener("abort", abortApproval, { once: true });
+        try {
+            return await gate.decide({ tool, args, cwd: this.dir, ...context, risk });
+        }
+        finally {
+            signal.removeEventListener("abort", abortApproval);
+            linked.dispose();
+        }
     }
     /** Reviewer model: `approval_model` when set, otherwise the chat model. */
     reviewerModel() {
@@ -905,63 +1076,172 @@ export class WebSession {
         }
         return { model: this.model, provider: this.provider, intensity: this.intensity };
     }
+    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();
+            },
+            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();
+                const stopApproval = () => {
+                    if (this.pendingApproval?.args !== callArgs)
+                        return;
+                    const pending = this.pendingApproval;
+                    this.pendingApproval = null;
+                    pending.resolve(false);
+                    this.publishLive();
+                };
+                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();
+                    }
+                }
+            },
+        });
+        if (!cancelled()) {
+            this.save();
+            this.publishLive();
+        }
+        return result;
+    }
     // ---- sub-agents ------------------------------------------------------
     /**
      * Run one approved tool call. `delegate` runs a child agent instead of
      * touching the filesystem, so it is handled here, where the session's model,
      * approval gate and abort signal live.
      */
-    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);
+        const evidence = runtime.evidence.at(-1);
+        if (evidence && this.mode === "pro") {
+            toolMsg.evidenceId = evidence.id;
+            toolMsg.executionStatus = evidence.status;
+        }
+        return result;
+    }
+    async dispatchTool(name, args, toolMsg, token, apiMessages, approvalContext, signal = currentTask()?.runtime.signal ?? this.turnAbort?.signal) {
+        if (name === FINISH_STEP_TOOL && currentTask()) {
+            const result = finishPlanStep(this.plan, args, currentTask().runtime);
+            this.save();
+            this.publishLive();
+            return result;
+        }
         if (this.mode === "pro" && (name === "call_pro_agent" || name === DELEGATE_TOOL)) {
             const team = this.proTeam;
             if (!team)
                 return "[Error: Pro models have not passed preflight]";
             return team.call(String(args.role ?? "backend_output_model"), String(args.task ?? ""), `${typeof args.context === "string" ? args.context : ""}\n\nCurrent user request: ${approvalContext.prompt}\n` +
-                captureApprovalContext(apiMessages).context, 1);
+                captureApprovalContext(apiMessages).context, 1, args.read_only === true, Array.isArray(args.write_paths) ? args.write_paths.filter((p) => typeof p === "string") : undefined);
         }
+        if (name === "execute_ts")
+            return this.runProgram(args, token, apiMessages, approvalContext);
         if (name !== DELEGATE_TOOL)
-            return executeTool(name, args, this.dir);
-        return this.delegate(args, toolMsg, token, apiMessages, approvalContext);
+            return executeTool(name, args, this.dir, signal);
+        return this.delegate(args, toolMsg, token, apiMessages, approvalContext, signal);
     }
     /**
      * Run a sub-agent for one `delegate` call and return its report. The child
      * works in its own transcript; only the report reaches this conversation, and
      * its risky calls go through the same approval gate as the parent turn.
      */
-    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(this.mode).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.provider, this.model, this.mode),
             createClient: () => new LLMClient(this.model, this.provider, this.intensity),
             system: loadSubAgentPrompt(),
-            task: buildSubAgentTask({ task, context, cwd: this.dir }),
+            task: buildSubAgentTask({ task, context, cwd: this.dir, 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.dir),
+                : executeTool(name, callArgs, this.dir, signal),
             onProgress: (label) => {
+                if (stopped())
+                    return;
                 this.subagent = label;
                 toolMsg.result = `… ${label}`;
                 this.publishLive();
             },
             onUsage: (usage) => {
+                if (stopped())
+                    return;
                 this.tokens.prompt += usage.prompt;
                 this.tokens.completion += usage.completion;
             },
             onRetry: (notice) => {
+                if (stopped())
+                    return;
                 this.retrying = notice;
                 this.publishLive();
             },
-            cancelled: () => token !== this.turnToken || this.paused || this.disposed,
+            cancelled: stopped,
         });
-        this.subagent = null;
-        this.retrying = null;
-        toolMsg.result = TOOL_PENDING;
-        this.publishLive();
+        if (!stopped()) {
+            this.subagent = null;
+            this.retrying = null;
+            toolMsg.result = TOOL_PENDING;
+            this.publishLive();
+        }
         return formatSubAgentResult(run);
     }
     // ---- compression -----------------------------------------------------
@@ -1067,7 +1347,7 @@ export class WebSession {
         if (chat.length === 0)
             return true;
         try {
-            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode, this.plan, this.mode, this.proPreset ?? undefined);
+            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode, this.plan, this.mode, this.proPreset ?? undefined, this.agentMode, this.taskRuntime?.snapshot() ?? this.lastTask);
             this.saveError = null;
             return true;
         }