@gkorepanov/ccodex 0.5.0-rc.2 → 0.5.0-rc.21

package/dist/claude/session.js

@@ -6,15 +6,15 @@ import { query, startup, } from "@anthropic-ai/claude-agent-sdk";
 import { invalidRequest } from "../protocol/codex.js";
 import { startedTurn } from "../protocol/turnPagination.js";
 import { CODEX_MCP_TOOLS, codexMcpItem, tailCodexRollout, } from "./codexRollout.js";
-import { claudeContent, normalizeUserInput, userMessage } from "./inputMapper.js";
+import { claudeContent, inputText, normalizeUserInput, userMessage } from "./inputMapper.js";
 import { completedToolItem } from "./native/projector.js";
 import { ANSWER_CHARS, assistantBlockItemId, continuationTurnId } from "./native/ids.js";
 import { readTranscriptRecords } from "./native/records.js";
 import { userText } from "./native/summary.js";
-import { normalizeClaudeModelIdentifier } from "./modelSelection.js";
-import { peerKey, peerMessageItem, peerOrigin, sentMessageItem } from "./peers.js";
-import { baseOptions } from "./sdk.js";
-import { proposedChanges, startTool, updateToolInput } from "./toolMapper.js";
+import { claudeEffort, DELEGATION_OFF, DELEGATION_ON, ULTRA } from "./delegation.js";
+import { foreignOwner, peerKey, peerMessageItem, peerOrigin, sentMessageItem, subagentFiles } from "./peers.js";
+import { baseOptions, claudeMode } from "./sdk.js";
+import { endedBackground, killedCommand, proposedChanges, startTool, stoppedCommand, updateToolInput } from "./toolMapper.js";
 /** The complete records Claude wrote from byte `start` on (at most the last 256 KB), and the byte they end at. */
 function recordsFrom(path, start) {
     const fd = openSync(path, "r");
@@ -44,6 +44,7 @@ function lastPrompt(path) {
         && !(Array.isArray(record.message?.content) && record.message.content.some((block) => block.type === "tool_result")));
 }
 /** How long a process started ahead of a first prompt waits for it. */
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
 const WARM_MS = 10 * 60_000;
 class Inbox {
     items = [];
@@ -73,7 +74,6 @@ const EMPTY_USAGE = {
 };
 const YIELD_BUDGET_MS = 20;
 export const INJECTED_PREFIX = "[Injected model-visible history]";
-const CONTINUATION_GRACE_MS = 3_000;
 function breakdown(usage) {
     const input = Number(usage?.input_tokens ?? 0);
     const cached = Number(usage?.cache_read_input_tokens ?? 0);
@@ -99,6 +99,7 @@ function addUsage(left, right) {
     };
 }
 const FILE_TOOLS = new Set(["Edit", "Write", "NotebookEdit", "MultiEdit"]);
+const PLAN_PROPOSED = "The plan is shown to the user, who answers in their next message (approving it ends plan mode). End your turn now, with no further text.";
 /**
  * One live Claude session: a single streaming `query()` and one sequential loop that turns SDK messages
  * into Codex notifications. Claude persists everything; this object only holds the running turn.
@@ -108,15 +109,21 @@ export class ClaudeSession {
     threadId;
     settings;
     turn;
+    /** A turn was started here: before that the chat is Desktop's new-chat draft, which stock lists nowhere. */
+    started = false;
     state = "idle";
     tasks = new Map();
+    /** Background commands running on past their turn (stock's background terminals), by task id. */
+    background = new Map();
+    /** Output files of commands Stop killed while Claude waited on them, by their call. */
+    killed = new Map();
+    /** TaskStop calls: shown on the command they stop, as stock shows a Ctrl-C (by tool use id). */
+    stops = new Map();
     /** Claude's sub-agents running (in the background they keep no turn open: each has a chat of its own). */
     agents = new Set();
     queued = [];
     totalUsage = EMPTY_USAGE;
     lastUsage = EMPTY_USAGE;
-    contextWindow = null;
-    costUsd = 0;
     liveModel = null;
     sdk;
     /** Last sign of life: a message from Claude, a prompt, a command. */
@@ -135,7 +142,6 @@ export class ClaudeSession {
     /** Injected context (`shouldQuery: false`) runs a silent query of its own: no turn is shown for it. */
     injections = new Map();
     turnWaiters = new Map();
-    continuationTimer;
     runningTimer;
     exists;
     compactSummary;
@@ -144,8 +150,14 @@ export class ClaudeSession {
     plan = new Map();
     /** Messages from other agents shown (peerKey), whichever of transcript and result told them first. */
     peerMessages = new Set();
+    /** The goal last sent to Claude with `/goal` (null: cleared); undefined until this session sends one. */
+    goalObjective;
     /** The running turn's result came: Claude answering again means it took another prompt by itself. */
     afterResult = false;
+    /** Proactive delegation (the `ultra` effort) as last told to Claude (its transcript's, for a chat loaded again). */
+    delegating;
+    /** A task's end came with no turn running: the command Claude runs for it goes on after the last answer. */
+    notified = false;
     /** Claude's last block since a turn began (its item id; the text item while it streams text). */
     lastBlock;
     transcript;
@@ -157,21 +169,35 @@ export class ClaudeSession {
         this.settings = settings;
         this.exists = options.exists;
         this.resumeAt = options.resumeAt;
+        this.delegating = host.summary(threadId)?.delegating ?? false;
+        this.keepPlan();
+    }
+    /** Claude's transcript records only its plan mode and the model it plans on: from plan mode on, the chat's own settings
+     *  wait in meta.json until a turn out of plan mode records them (turning plan mode off records nothing). */
+    keepPlan() {
+        const { meta } = this.host.gateway;
+        if (this.settings.plan || meta.plan(this.threadId)) {
+            meta.setPlan(this.threadId, { permissionMode: this.settings.permissionMode, model: this.settings.model, effort: this.settings.effort, plan: this.settings.plan });
+        }
     }
     resumeAt;
     get loaded() { return this.sdk !== undefined; }
     get busy() { return this.turn !== undefined; }
     /** Nothing to do for `idleMs` (closing its process loses nothing: the next turn resumes from disk). */
     quiet(now, idleMs) {
-        return !this.turn && !this.queued.length && !this.injections.size && !this.crons && now - this.activeAt >= idleMs;
+        return !this.turn && !this.tasks.size && !this.queued.length && !this.injections.size && !this.crons && now - this.activeAt >= idleMs;
     }
-    /** The turn has its answer and only waits for background tasks to end. */
+    /** No turn runs, only background tasks. */
     get waitingOnTasks() {
-        return this.turn?.resultSeen === true && this.state === "idle" && this.tasks.size > 0;
+        return !this.turn && this.tasks.size > 0;
+    }
+    /** The item ids of the background commands running (history shows them ended unless they run here). */
+    get runningCommands() {
+        return new Set([...this.background.values()].map(({ item }) => item.id));
     }
     /** Stops the background tasks as Claude's own stop control does: Claude learns they were stopped, not that they failed. */
     async stopTasks() {
-        await Promise.all([...this.tasks.keys()].map((taskId) => this.sdk.stopTask(taskId)));
+        await Promise.all([...this.tasks.keys()].map((taskId) => this.stopTask(taskId)));
     }
     // ---- lifecycle ----
     /** The process started ahead of the first prompt (prewarm), and what it was started with. */
@@ -220,13 +246,16 @@ export class ClaudeSession {
     }
     options() {
         const settings = this.settings;
+        const effort = claudeEffort(this.host.effort(settings));
         return {
             ...baseOptions(this.host.config),
             cwd: settings.cwd,
             ...(settings.model ? { model: settings.model } : {}),
-            ...(settings.effort ? { effort: settings.effort } : {}),
+            ...(effort ? { effort: effort } : {}),
             ...(settings.fast ? { settings: { fastMode: true } } : {}),
-            permissionMode: settings.permissionMode,
+            permissionMode: claudeMode(settings),
+            // Claude enters plan mode only as the user sets it (stock's collaboration mode).
+            disallowedTools: ["EnterPlanMode"],
             // Claude 5 omits its thinking by default: summarized, it shows as the turn's reasoning summary like stock's.
             extraArgs: { "thinking-display": "summarized" },
             allowDangerouslySkipPermissions: true,
@@ -271,6 +300,9 @@ export class ClaudeSession {
         }
         if (this.sdk !== sdk)
             return;
+        // Claude stopped before it wrote anything (its first turn failed): the next turn starts the session anew.
+        if (failure && !this.transcriptPath())
+            this.exists = false;
         // Context Claude never took (it stopped, or never started) fails whoever waits on it.
         for (const { reject } of this.injections.values())
             reject(new Error(`Claude stopped${failure}`));
@@ -297,15 +329,22 @@ export class ClaudeSession {
     }
     // ---- inputs ----
     async startTurn(params) {
+        // Two processes writing one transcript fork it: whatever the other one writes next is lost to the chat.
+        const owner = this.turn ? undefined : foreignOwner(this.host.config.claudeHome, this.threadId);
+        if (owner)
+            throw invalidRequest(`This chat is open in another Claude process (pid ${owner}): close it there or wait until it ends.`);
         const input = normalizeUserInput(params.input ?? []);
+        const goal = /^\/goal\s+(\S[\s\S]*)/u.exec(inputText(input))?.[1].trim();
+        if (goal)
+            this.goalObjective = goal === "clear" ? null : goal;
         const uuid = params.turnId ?? randomUUID();
         await this.applyTurnSettings(params);
+        // Its message records the chat's own mode in the transcript.
+        if (!this.settings.plan)
+            this.host.gateway.meta.setPlan(this.threadId, null);
         const content = await claudeContent(input, this.settings.cwd);
         // Desktop shows `/goal` messages itself.
         const hidden = typeof content === "string" && /^\/(?:compact|goal)(?:\s|$)/u.test(content);
-        // Claude only waits on background tasks: it takes the message as a prompt of its own.
-        if (this.waitingOnTasks)
-            this.completeTurn();
         if (this.turn) {
             // Claude folds a message sent mid-turn into the running turn, like a steer.
             this.pendingInputs.set(uuid, { input, clientId: params.clientUserMessageId ?? null, hidden });
@@ -313,6 +352,11 @@ export class ClaudeSession {
             this.inbox.push(userMessage(content, uuid));
             return startedTurn(this.liveTurn());
         }
+        // Like stock's multi-agent mode message: in the thread once the mode changes.
+        if ((this.settings.effort === ULTRA) !== this.delegating) {
+            this.delegating = !this.delegating;
+            await this.inject(this.delegating ? DELEGATION_ON : DELEGATION_OFF);
+        }
         const turn = this.openTurn(uuid, input, params.clientUserMessageId ?? null, hidden, params.turnId !== undefined);
         this.ensureQuery();
         this.inbox.push(userMessage(content, uuid));
@@ -325,10 +369,9 @@ export class ClaudeSession {
     async steer(params) {
         if (!this.turn)
             throw invalidRequest("no active turn to steer");
-        if (this.waitingOnTasks)
-            return (await this.startTurn(params)).id;
         const input = normalizeUserInput(params.input ?? []);
-        const uuid = randomUUID();
+        // The client's id is the message's in the transcript: history gives it back as the message's client id.
+        const uuid = UUID.test(params.clientUserMessageId ?? "") ? params.clientUserMessageId : randomUUID();
         this.pendingInputs.set(uuid, { input, clientId: params.clientUserMessageId ?? null, hidden: false });
         this.ensureQuery();
         this.inbox.push(userMessage(await claudeContent(input, this.settings.cwd), uuid));
@@ -336,11 +379,36 @@ export class ClaudeSession {
     }
     /** Model-visible context without a model reply (provider switch summary, injected items). */
     inject(text) {
+        return this.quietly(`${INJECTED_PREFIX}\n${text}`, { shouldQuery: false, origin: undefined });
+    }
+    /**
+     * Claude's `/goal` (its only goal API). Claude pursues a goal in one turn until it is met and runs a command sent
+     * meanwhile only after that: with a goal active, a running turn stops first. Clearing is no turn: Codex clients show
+     * goals themselves.
+     */
+    async goal(args, active) {
+        // Desktop's goal mode sends the goal's message as a turn, then sets the goal: Claude has it already (a second
+        // `/goal` would wait behind that turn and set the old goal again once an edit or pause stops it).
+        if (args === this.goalObjective && this.turn)
+            return;
+        this.goalObjective = args === "clear" ? null : args;
+        if (active && this.turn) {
+            const done = this.turnDone(this.turn.id);
+            await this.interrupt();
+            await done;
+        }
+        if (args === "clear")
+            await this.quietly("/goal clear");
+        else
+            await this.command(`/goal ${args}`);
+    }
+    /** A message that opens no turn; resolves once Claude has taken it. */
+    quietly(content, extra) {
         const uuid = randomUUID();
         this.ensureQuery();
         return new Promise((resolve, reject) => {
             this.injections.set(uuid, { resolve, reject });
-            this.inbox.push(userMessage(`${INJECTED_PREFIX}\n${text}`, uuid, { shouldQuery: false, origin: undefined }));
+            this.inbox.push(userMessage(content, uuid, extra));
         });
     }
     /** Resolves with the final status once the turn completes. */
@@ -358,7 +426,16 @@ export class ClaudeSession {
         this.host.gateway.cancelServerRequests(this.threadId);
         // Stop stops all Claude runs: its background tasks and sub-agents too (a message sent meanwhile leaves them running).
         const sdk = this.sdk;
-        await Promise.all([sdk.interrupt(), ...[...this.tasks.keys(), ...this.agents].map((id) => sdk.stopTask(id))].map((done) => done.catch(() => undefined)));
+        // A command Claude waits on goes to the background first: only there Claude keeps a killed command's output.
+        await Promise.all([...this.tasks.values()].filter((task) => task.taskType === "local_bash" && task.toolUseId && !this.background.has(task.taskId))
+            .map((task) => sdk.backgroundTasks(task.toolUseId).catch(() => false)));
+        // As stock and Claude Code's own Stop: messages steered in but not yet read are dropped, not run after it.
+        const interrupt = sdk.interrupt({ cancelQueued: true })
+            .then((receipt) => { for (const uuid of receipt?.cancelled ?? [])
+            this.pendingInputs.delete(uuid); });
+        await Promise.all([interrupt, ...[...this.tasks.keys(), ...this.agents].map((id) => sdk.stopTask(id))].map((done) => done.catch(() => undefined)));
+        for (const taskId of this.tasks.keys())
+            this.endBackground(taskId, { status: "stopped", summary: "", atMs: Date.now() });
         this.tasks.clear();
         this.agents.clear();
         if (this.state === "idle" && this.turn) {
@@ -368,6 +445,20 @@ export class ClaudeSession {
     }
     async stopTask(taskId) {
         await this.sdk?.stopTask(taskId);
+        this.endBackground(taskId, { status: "stopped", summary: "", atMs: Date.now() });
+    }
+    /** A background command ended: its item completes in the turn it started in, as stock's background terminal does. */
+    endBackground(taskId, end) {
+        const running = this.background.get(taskId);
+        if (!running)
+            return;
+        this.background.delete(taskId);
+        const { item, turnId } = running;
+        const ended = endedBackground(item, end, running.startedAtMs);
+        const index = this.turn?.id === turnId ? this.turn.items.findIndex((candidate) => candidate.id === item.id) : -1;
+        if (index >= 0)
+            this.turn.items[index] = ended;
+        this.emit("item/completed", { item: ended, threadId: this.threadId, turnId, completedAtMs: end.atMs });
     }
     async askSideQuestion(question) {
         const sdk = this.ensureQuery();
@@ -390,20 +481,23 @@ export class ClaudeSession {
         const next = this.host.settingsFrom(params, this.settings);
         const changed = JSON.stringify(next) !== JSON.stringify(this.settings);
         if (!changed)
-            return false;
+            return;
         const previous = this.settings;
         this.settings = next;
+        this.keepPlan();
+        // Like stock, every client with the chat open learns the change (Desktop's composer follows it).
+        this.emit("thread/settings/updated", { threadId: this.threadId, threadSettings: this.host.threadSettings(next) });
         if (this.sdk) {
             if (next.model !== previous.model)
                 await this.sdk.setModel(next.model ?? undefined);
             // The CLI settles the mode per model (no auto mode on Haiku falls back to default): a new model re-applies it.
-            if (next.permissionMode !== previous.permissionMode || next.model !== previous.model)
-                await this.sdk.setPermissionMode(next.permissionMode);
-            if (next.effort !== previous.effort || next.fast !== previous.fast) {
-                await this.sdk.applyFlagSettings({ effortLevel: next.effort, fastMode: next.fast });
+            if (claudeMode(next) !== claudeMode(previous) || next.model !== previous.model)
+                await this.sdk.setPermissionMode(claudeMode(next));
+            const effort = this.host.effort(next);
+            if (effort !== this.host.effort(previous) || next.fast !== previous.fast) {
+                await this.sdk.applyFlagSettings({ effortLevel: claudeEffort(effort), fastMode: next.fast });
             }
         }
-        return true;
     }
     // ---- turn bookkeeping ----
     newTurnObject(id) {
@@ -416,8 +510,10 @@ export class ClaudeSession {
     openTurn(id, input, clientId, hidden, announced = false) {
         const turn = this.newTurnObject(id);
         this.turn = { id, startedAt: Date.now(), items: turn.items, resultSeen: false, interrupted: false, error: null };
+        this.started = true;
         this.activeAt = Date.now();
         this.afterResult = false;
+        this.notified = false;
         this.lastBlock = undefined;
         try {
             this.transcriptRead = statSync(this.transcriptPath() ?? "").size;
@@ -446,16 +542,11 @@ export class ClaudeSession {
         };
     }
     maybeComplete() {
-        if (!this.turn || !this.turn.resultSeen || this.state !== "idle" || this.continuationTimer)
+        // Background commands run on past the turn (stock's background terminals); a task's end that wakes Claude up starts
+        // a turn of its own.
+        if (!this.turn || !this.turn.resultSeen || this.state !== "idle")
             return;
-        if (!this.tasks.size || this.queued.length)
-            return this.completeTurn();
-        // Background tasks run on after the answer: it ends its turn, and a new one keeps the chat working until they end
-        // or wake Claude up.
-        if (!this.lastBlock)
-            return;
-        this.continueTurn();
-        this.turn.resultSeen = true;
+        this.completeTurn();
     }
     /** Claude goes on after an answer with no prompt: the answer ends its turn, the work goes on in a new one (history's). */
     continueTurn() {
@@ -533,6 +624,9 @@ export class ClaudeSession {
             this.host.subagentMessage(this, m);
             return;
         }
+        // Claude's own word on `/goal` ("Goal set: …"), streamed as a reply: Codex clients show goals themselves.
+        if (m.local_command_run?.command === "goal")
+            return;
         if (this.afterResult && (m.type === "stream_event" || m.type === "assistant"))
             this.continued();
         switch (m.type) {
@@ -565,6 +659,8 @@ export class ClaudeSession {
         // A command Claude started by itself (a message another agent sent): its turn has the id history gives it.
         if (m.state === "started" && uuid && !pending && !this.injections.has(uuid)) {
             clearTimeout(this.runningTimer);
+            if (!this.turn && this.notified)
+                return this.ensureTurn();
             if (!this.turn)
                 this.ensureTurn(uuid);
             void this.showPeerMessage(uuid);
@@ -584,13 +680,8 @@ export class ClaudeSession {
         this.itemStarted(item);
         this.itemCompleted(item);
     }
-    /** The session's sub-agents are its transcripts under `<session>/subagents` (a resumed session's earlier ones too). */
     get peers() {
-        const session = this.transcriptPath()?.replace(/\.jsonl$/u, "");
-        return {
-            directory: this.host.catalog,
-            children: { has: (agentId) => session !== undefined && /^[\w-]+$/u.test(agentId) && existsSync(join(session, "subagents", `agent-${agentId}.jsonl`)) },
-        };
+        return { directory: this.host.catalog, children: subagentFiles(this.transcriptPath()) };
     }
     /**
      * Claude answers again right after a result, without going idle: the transcript tells what it took. A message another
@@ -695,8 +786,6 @@ export class ClaudeSession {
             case "session_state_changed":
                 this.state = m.state;
                 if (m.state === "running") {
-                    clearTimeout(this.continuationTimer);
-                    this.continuationTimer = undefined;
                     // Claude started it by itself: the command it runs (announced right after) gives the turn its id.
                     if (!this.injections.size && !this.turn) {
                         clearTimeout(this.runningTimer);
@@ -722,19 +811,18 @@ export class ClaudeSession {
                 this.tasks.set(m.task_id, { taskId: m.task_id, toolUseId: m.tool_use_id, description: m.description ?? "", taskType: m.task_type });
                 return;
             case "task_notification":
+                if (m.status === "stopped" && m.tool_use_id && m.output_file && !this.background.has(m.task_id))
+                    this.killed.set(m.tool_use_id, m.output_file);
                 this.tasks.delete(m.task_id);
                 this.agents.delete(m.task_id);
                 this.host.subagentFinished(`agent-${m.task_id}`);
-                this.awaitWakeup();
+                this.notified ||= !this.turn;
+                this.endBackground(m.task_id, { status: String(m.status), summary: String(m.summary ?? ""), ...(m.output_file ? { outputFile: m.output_file } : {}), atMs: Date.now() });
                 return;
             case "background_tasks_changed": {
-                // Claude tells the change before the task's notification: it may wake Claude up still.
                 const live = new Set((m.tasks ?? []).map((task) => task.task_id));
-                const ended = [...this.tasks.keys()].filter((id) => !live.has(id));
-                for (const id of ended)
+                for (const id of [...this.tasks.keys()].filter((id) => !live.has(id)))
                     this.tasks.delete(id);
-                if (ended.length)
-                    this.awaitWakeup();
                 return;
             }
             case "api_retry":
@@ -755,15 +843,6 @@ export class ClaudeSession {
         }
     }
     /** A task ended while Claude was idle: its notification may wake Claude up, so the turn waits a moment for that. */
-    awaitWakeup() {
-        if (this.state !== "idle" || !this.turn)
-            return;
-        clearTimeout(this.continuationTimer);
-        this.continuationTimer = setTimeout(() => {
-            this.continuationTimer = undefined;
-            this.maybeComplete();
-        }, CONTINUATION_GRACE_MS);
-    }
     /** Visible CCodex/Claude notice inside the running turn (e.g. `/goal` output). */
     systemText(text) {
         if (!text.trim() || !this.turn)
@@ -896,6 +975,14 @@ export class ClaudeSession {
             }
             : startTool(index, block, this.settings.cwd, this.threadId);
         started.item = sentMessageItem(started.item, started.state.input, undefined, this.peers);
+        // Stopping a background command shows on the command, as stock's Ctrl-C; what else it stops shows with its result.
+        if (block.name === "TaskStop") {
+            const taskId = String(block.input?.task_id);
+            const running = this.background.get(taskId);
+            if (running)
+                this.emit("item/commandExecution/terminalInteraction", { threadId: this.threadId, turnId: running.turnId, itemId: running.item.id, processId: taskId, stdin: "\u0003" });
+            return void this.stops.set(block.id, started);
+        }
         this.tools.set(block.id, started);
         this.itemStarted(started.item);
     }
@@ -947,13 +1034,39 @@ export class ClaudeSession {
                 continue;
             this.codexTails.get(block.tool_use_id)?.();
             this.codexTails.delete(block.tool_use_id);
+            const result = typeof m.tool_use_result === "object" && m.tool_use_result !== null ? m.tool_use_result : undefined;
+            const stop = this.stops.get(block.tool_use_id);
+            if (stop) {
+                this.stops.delete(block.tool_use_id);
+                const stopped = stoppedCommand(result);
+                if (stopped) {
+                    this.endBackground(stopped, { status: "stopped", summary: "", atMs: Date.now() });
+                    continue;
+                }
+                this.tools.set(block.tool_use_id, stop);
+                this.itemStarted(stop.item);
+            }
             const tool = this.tools.get(block.tool_use_id);
             if (!tool)
                 continue;
             this.tools.delete(block.tool_use_id);
-            const result = typeof m.tool_use_result === "object" && m.tool_use_result !== null ? m.tool_use_result : undefined;
+            // A command in the background runs on past its turn: its item completes when it ends (stock's background terminal).
+            const taskId = tool.state.name === "Bash" && typeof result?.backgroundTaskId === "string" ? result.backgroundTaskId : undefined;
+            if (taskId && this.turn) {
+                const item = { ...tool.item, processId: taskId };
+                this.background.set(taskId, { item, turnId: this.turn.id, startedAtMs: tool.state.startedAtMs });
+                // Desktop shows a background terminal only for a command with its process (stock's has it from the start).
+                const index = this.turn.items.findIndex((candidate) => candidate.id === item.id);
+                if (index >= 0)
+                    this.turn.items[index] = item;
+                this.emit("item/started", { item, threadId: this.threadId, turnId: this.turn.id, startedAtMs: tool.state.startedAtMs });
+                continue;
+            }
             // The result tells where a message went (its msg_id) when the call alone did not.
-            const item = completedToolItem({ ...tool, item: sentMessageItem(tool.item, tool.state.input, result, this.peers) }, { record: { toolUseResult: result }, block }, this.settings.cwd);
+            const completed = completedToolItem({ ...tool, item: sentMessageItem(tool.item, tool.state.input, result, this.peers) }, { record: { toolUseResult: result }, block }, this.settings.cwd);
+            const killed = this.killed.get(block.tool_use_id);
+            this.killed.delete(block.tool_use_id);
+            const item = killed ? killedCommand(completed, killed) : completed;
             if (item.type === "collabAgentToolCall" && item.tool === "spawnAgent" && item.receiverThreadIds.length) {
                 this.host.subagentSpawned(this, item, result?.status === "async_launched");
             }
@@ -978,19 +1091,14 @@ export class ClaudeSession {
         if (!this.turn)
             return;
         this.turn.resultSeen = true;
+        // Fast Claude can't serve (the account's usage credits, the model): Claude answers at standard speed, and the chat shows so.
+        if (this.settings.fast && m.fast_mode_state === "off")
+            void this.updateSettings({ serviceTier: null });
         this.afterResult = true;
         // A turn a message from another agent started, unless showPeerMessage read it back already.
         const origin = peerOrigin(m.origin);
         if (origin)
             this.showPeer(this.turn.id, origin, "");
-        this.costUsd += Number(m.total_cost_usd ?? 0);
-        for (const [model, usage] of Object.entries(m.modelUsage ?? {})) {
-            if (usage?.contextWindow)
-                this.host.contextWindows.set(normalizeClaudeModelIdentifier(model), Number(usage.contextWindow));
-        }
-        const windows = Object.values(m.modelUsage ?? {}).map((usage) => Number(usage?.contextWindow ?? 0)).filter(Boolean);
-        if (windows.length)
-            this.contextWindow = Math.max(...windows);
         if (m.subtype !== "success" && !this.turn.interrupted) {
             const errors = Array.isArray(m.errors) ? m.errors.join("\n") : "";
             if (m.subtype === "error_during_execution" && !errors)
@@ -1010,11 +1118,15 @@ export class ClaudeSession {
         this.emit("thread/tokenUsage/updated", {
             threadId: this.threadId,
             turnId: this.turn.id,
-            tokenUsage: { total: this.totalUsage, last: this.lastUsage, modelContextWindow: this.contextWindow },
+            tokenUsage: { total: this.totalUsage, last: this.lastUsage, modelContextWindow: this.host.contextWindow(this.liveModel ?? this.settings.model) },
         });
     }
     // ---- approvals and questions ----
     canUseTool = async (toolName, input, options) => {
+        // Stock plan mode: the turn ends with the proposed plan (its item) and Desktop asks to implement it; accepting
+        // switches the collaboration mode back, which gives the chat the mode it had before plan mode.
+        if (toolName === "ExitPlanMode" && this.settings.plan)
+            return { behavior: "deny", message: PLAN_PROPOSED };
         const turnId = this.turn?.id ?? "";
         const itemId = options.toolUseID ?? randomUUID();
         const base = { threadId: this.threadId, turnId, itemId, startedAtMs: Date.now() };