@adecore/agents 0.21.2 → 0.22.1

package/dist/chat/fake-claude.js

@@ -137,6 +137,39 @@ export function fakeClaude(io) {
     // What a background agent asked; its answer comes in after the turn that launched it, whenever a person gives one.
     let backgroundAsk = null;
     let slow = false;
+    // The two foreground subagents of `two subagents` that have not settled; the turn stays open until both have.
+    const openTwo = new Set();
+    const settleTwo = (name, stopped) => {
+        const toolUseId = name === 'a-one' ? 'toolu_two_a' : 'toolu_two_b';
+        if (!openTwo.delete(name)) {
+            return;
+        }
+        if (stopped) {
+            out({ type: 'system', subtype: 'task_updated', task_id: name, patch: { status: 'killed', end_time: 0 }, session_id: sessionId });
+            out({
+                type: 'system',
+                subtype: 'task_notification',
+                task_id: name,
+                tool_use_id: toolUseId,
+                status: 'stopped',
+                output_file: '',
+                summary: 'Stopped',
+                session_id: sessionId
+            });
+        }
+        out({
+            type: 'user',
+            message: {
+                role: 'user',
+                content: [{ type: 'tool_result', tool_use_id: toolUseId, content: stopped ? 'Stopped' : `${name} done`, is_error: stopped }]
+            },
+            session_id: sessionId
+        });
+        if (openTwo.size === 0) {
+            assistantText('summarized B');
+            result();
+        }
+    };
     // The rest of a background agent once its request was answered: its call's result, its report, and the turn the CLI opens about it.
     const finishBackgroundAgent = (command, allowed, message) => {
         const toolUseId = 'toolu_bgask';
@@ -182,6 +215,43 @@ export function fakeClaude(io) {
             io.exit(1);
             return;
         }
+        // Two foreground subagents beside each other; the turn ends once both settled: a-two when the test runs what is put off, a-one by a `stop_task`.
+        if (text === 'two subagents') {
+            openTwo.add('a-one').add('a-two');
+            for (const [name, toolUseId] of [
+                ['a-one', 'toolu_two_a'],
+                ['a-two', 'toolu_two_b']
+            ]) {
+                out({
+                    type: 'assistant',
+                    message: {
+                        id: `msg_${nonce}_${++messageCounter}`,
+                        model,
+                        role: 'assistant',
+                        content: [
+                            { type: 'tool_use', id: toolUseId, name: 'Agent', input: { description: name, subagent_type: 'general-purpose', prompt: name } }
+                        ],
+                        usage
+                    },
+                    session_id: sessionId
+                });
+                out({
+                    type: 'system',
+                    subtype: 'task_started',
+                    task_id: name,
+                    tool_use_id: toolUseId,
+                    description: name,
+                    subagent_type: 'general-purpose',
+                    is_backgrounded: false,
+                    spawn_depth: 1,
+                    task_type: 'local_agent',
+                    prompt: name,
+                    session_id: sessionId
+                });
+            }
+            io.later(() => settleTwo('a-two', false));
+            return;
+        }
         if (text === 'crash loudly') {
             io.err(`${'warming up\n'.repeat(2000)}Error: the fake lost its key\n    at handleUser (fake-claude.ts)\n`);
             io.exit(1);
@@ -932,6 +1002,9 @@ export function fakeClaude(io) {
             else if (frame.type === 'control_request') {
                 const request = frame.request;
                 out({ type: 'control_response', response: { subtype: 'success', request_id: frame.request_id, response: {} } });
+                if (request.subtype === 'stop_task' && (request.task_id === 'a-one' || request.task_id === 'a-two')) {
+                    settleTwo(request.task_id, true);
+                }
                 if (request.subtype === 'interrupt' && slow) {
                     slow = false;
                     assistantText('[interrupted]');

package/dist/chat/thread-search.d.ts

@@ -0,0 +1,14 @@
+import type { ChatItem } from '@adecore/agent-contracts';
+export interface ThreadHit {
+    itemId: string;
+    author: 'person' | 'agent';
+    snippet: string;
+    matchStart: number;
+    matchLength: number;
+    createdAt: number;
+    turnId: string | null;
+}
+export interface ThreadSearchOptions {
+    limit: number;
+}
+export declare function searchThreadItems(items: readonly ChatItem[], query: string, { limit }: ThreadSearchOptions): ThreadHit[];

package/dist/chat/thread-search.js

@@ -0,0 +1,64 @@
+// Characters kept on each side of the match.
+const CONTEXT = 60;
+// Emphasis and code markers carry no meaning in a one-line snippet, where they only read as noise.
+function plain(text) {
+    return text.replace(/\*{1,3}|_{2,}|`+/g, '').replace(/\s+/g, ' ');
+}
+// Moves a cut forward to the start of the next word, never past `limit`, so a snippet does not open on half a word.
+function wordStart(text, from, limit) {
+    if (from === 0 || /\s/.test(text[from - 1]) || /\s/.test(text[from])) {
+        return from;
+    }
+    const space = text.slice(from, limit).search(/\s/);
+    return space === -1 ? from : from + space + 1;
+}
+// Moves a cut back to the end of the previous word, never before `limit`.
+function wordEnd(text, to, limit) {
+    if (to === text.length || /\s/.test(text[to - 1]) || /\s/.test(text[to])) {
+        return to;
+    }
+    const space = text.slice(limit, to).search(/\s\S*$/);
+    return space === -1 ? to : limit + space;
+}
+function snippetOf(text, index, length) {
+    const from = wordStart(text, Math.max(0, index - CONTEXT), index);
+    const to = wordEnd(text, Math.min(text.length, index + length + CONTEXT), index + length);
+    const before = `${from > 0 ? '…' : ''}${plain(text.slice(from, index))}`;
+    const match = plain(text.slice(index, index + length));
+    const after = `${plain(text.slice(index + length, to))}${to < text.length ? '…' : ''}`;
+    return { snippet: `${before}${match}${after}`, matchStart: before.length, matchLength: match.length };
+}
+/*
+ * The messages of a thread that hold `query`, oldest first, one hit per message. Only what a person
+ * and the agent said counts: what a subagent said (`parentToolUseId`) is not part of the conversation.
+ */
+export function searchThreadItems(items, query, { limit }) {
+    if (query === '' || limit <= 0) {
+        return [];
+    }
+    const pattern = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+    const hits = [];
+    for (const item of items) {
+        if (item.kind !== 'user' && item.kind !== 'assistant') {
+            continue;
+        }
+        if (item.kind === 'assistant' && item.parentToolUseId) {
+            continue;
+        }
+        const found = pattern.exec(item.text);
+        if (found === null) {
+            continue;
+        }
+        hits.push({
+            itemId: item.id,
+            author: item.kind === 'user' ? 'person' : 'agent',
+            ...snippetOf(item.text, found.index, found[0].length),
+            createdAt: item.createdAt,
+            turnId: item.turnId
+        });
+        if (hits.length >= limit) {
+            break;
+        }
+    }
+    return hits;
+}

package/dist/host/handlers.js

@@ -31,7 +31,7 @@ export function chatHandlers(chats, providers) {
             chats.detach(payload.chatId, clientId);
             return {};
         },
-        'chat.send': (payload) => chats.send(payload.chatId, payload.text, { delivery: payload.delivery, mentions: payload.mentions, skills: payload.skills, chats: payload.chats }, payload.attachments),
+        'chat.send': (payload) => chats.send(payload.chatId, payload.text, { delivery: payload.delivery, mentions: payload.mentions, skills: payload.skills, chats: payload.chats, quoteSource: payload.quoteSource }, payload.attachments),
         'chat.uiChoice': (payload, clientId) => chats.choose(payload, clientId),
         'ui.link': (payload, clientId) => chats.linkUi(payload, clientId),
         'ui.query': (payload, clientId) => chats.queryUi(payload, clientId),

package/dist/providers/catalog.js

@@ -33,7 +33,8 @@ export class ModelCatalog {
             badge: model.badge,
             legacy: model.legacy === true,
             isDefault: model.slug === this.data.defaultModel,
-            options: this.profileOf(model.slug)?.options ?? []
+            options: this.profileOf(model.slug)?.options ?? [],
+            ...(model.minCliVersion === undefined ? {} : { minCliVersion: model.minCliVersion })
         }));
     }
     /* What a person reads for a model, so an error in a thread names it the way the picker does. */

package/dist/tasks/waiting-child.d.ts

@@ -44,6 +44,7 @@ export interface DeliverWaitingDeps {
     deliver(chatId: string, delivery: {
         noteId: string;
         note: string;
+        from?: string;
         preamble: string;
     }): Promise<boolean>;
     words: WaitingWords;

package/dist/tasks/waiting-child.js

@@ -1,4 +1,4 @@
-import { clipText } from '@adecore/agent-contracts';
+import { clipText, WAITING_NOTE_PREFIX } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.js';
 export function isPendingRequest(item) {
     return (item?.kind === 'question' && item.state === 'pending') || (item?.kind === 'approval' && item.decision === 'pending');
@@ -26,7 +26,7 @@ export function chatRequests(chats) {
 }
 /* The id of the note one request of one child leaves in its parent, so delivering it twice leaves one. */
 export function waitingNoteId(childId, requestId) {
-    return `waiting-${childId}-${requestId}`;
+    return `${WAITING_NOTE_PREFIX}${childId}-${requestId}`;
 }
 /*
  * How long a request may wait before its parent hears of it. A person watching the child settles one
@@ -140,6 +140,6 @@ export function deliverWaitingHandler(deps) {
             return;
         }
         const texts = waitingTexts({ id: childId, title: deps.titleFor(childId) ?? childId }, item, deps.words);
-        await deps.deliver(entry.target, { noteId: waitingNoteId(childId, requestId), ...texts });
+        await deps.deliver(entry.target, { noteId: waitingNoteId(childId, requestId), from: childId, ...texts });
     };
 }

package/dist/usage/readers/codex.d.ts

@@ -19,5 +19,6 @@ export interface CodexParserState {
 }
 export declare function createCodexState(): CodexParserState;
 export declare function cloneCodexState(state: CodexParserState): CodexParserState;
+export declare function isForkOrSubagent(payload: Record<string, unknown>): boolean;
 export declare function parseCodexLine(line: string, state: CodexParserState): UsageRecord | null;
 export {};

package/dist/usage/readers/codex.js

@@ -45,7 +45,7 @@ function deltaOf(total, previous) {
     return delta.input < 0 || delta.cached < 0 || delta.cacheWrite < 0 || delta.output < 0 || delta.reasoning < 0 ? null : delta;
 }
 /* A thread that was forked or spawned repeats its parent's events before its own work starts. */
-function isForkOrSubagent(payload) {
+export function isForkOrSubagent(payload) {
     if (typeof payload.forked_from_id === 'string' || typeof payload.parent_thread_id === 'string') {
         return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.21.2",
+  "version": "0.22.1",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -20,8 +20,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.21.2",
-    "@adecore/intelligent-ui": "0.21.2",
+    "@adecore/agent-contracts": "0.22.1",
+    "@adecore/intelligent-ui": "0.22.1",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/backend.ts

@@ -160,6 +160,8 @@ export type BackendEvent =
     | { type: 'compaction'; preTokens: number | null }
     | { type: 'model'; model: string }
     | { type: 'note'; level: 'info' | 'warning' | 'error'; text: string }
+    // The CLI answered a `stopTask` with an error, so the task still runs.
+    | { type: 'stop.refused'; taskId: string; message: string }
     // `native` is the CLI's own name for where the turn ended, which a fork of the chat is cut at.
     | {
           type: 'turn.done';

package/src/chat/chat-core.ts

@@ -640,8 +640,9 @@ export class ChatCore {
     }
 
     /*
-     * Stops one running sub-agent of the CLI's own. It cannot be stopped apart from its CLI, so its row
-     * is only marked, and only while no turn runs: stopping that turn is the composer's Stop.
+     * Stops one running sub-agent of the CLI's own. The process that started it ends it with `stop_task`
+     * and the parent keeps working. Without such a process the row is only marked, and only while no
+     * turn runs: stopping that turn is the composer's Stop.
      */
     async stopSubagent(chatId: string, toolUseId: string): Promise<void> {
         await this.loaded(chatId);
@@ -656,7 +657,7 @@ export class ChatCore {
         if (row.origin === 'ruimte') {
             throw new ChatError('chat-unsupported', 'This row stands for work the host runs; stop it there');
         }
-        session.markSubagentStopped(toolUseId);
+        session.stopSubagent(toolUseId);
     }
 
     /* Ends a command or a monitor a chat's CLI runs in the background, for a person who pressed Stop on it. */

package/src/chat/chat-session.ts

@@ -7,6 +7,7 @@ import type {
     ChatInfo,
     ChatItem,
     ChatQueuedMessage,
+    ChatQuoteSource,
     ChatSkill,
     ChatSubagentItem,
     ChatTurnItem,
@@ -42,6 +43,8 @@ export interface TurnCheckpoints {
     diff(cwd: string, tree: string): Promise<ChatCheckpointDiff | null>;
     /* The diff of a turn that ended, with the tree of the folder it was taken against: where that turn left the files. */
     settle(cwd: string, tree: string): Promise<{ diff: ChatCheckpointDiff; after: string } | null>;
+    /* The commit HEAD points at, or null when unborn or outside a repository. A host without it records no heads. */
+    head?(cwd: string): Promise<string | null>;
 }
 
 /* What a host says in front of the next real prompt, beside the preambles a chat keeps itself. */
@@ -123,6 +126,7 @@ export interface ChatSendExtras {
     mentions?: string[];
     skills?: string[];
     chats?: string[];
+    quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachment[];
 }
 
@@ -193,6 +197,10 @@ export class ChatSession {
     private naming = false;
     // Set while the host goes down: a CLI dying with it must not end the turn a restart takes up again.
     private frozen = false;
+    // Which CLI process (generation) announced each subagent of its own, by call id; only that one can stop it.
+    private readonly subagentOwners = new Map<string, number>();
+    // Subagents a stop_task went out for, as task id to call id, until their notification settles them.
+    private readonly stopping = new Map<string, string>();
     // Background subagents a load found running whose transcript did not show an end yet; no CLI here will report them.
     private readonly orphans = new Set<string>();
     private pendingPreambles: readonly string[];
@@ -302,7 +310,8 @@ export class ChatSession {
     /*
      * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
      */
-    send(text: string, extras: ChatSendExtras = {}): { queued: boolean; turnId: string } {
+    send(text: string, sent: ChatSendExtras = {}): { queued: boolean; turnId: string } {
+        const extras = this.vetted(sent);
         const turnId = newId('turn');
         // Behind whatever still waits (a CLI that crashed leaves its queue), so everything goes out in the order it was sent.
         if (this.busy || this.queue.length > 0 || this.replacementWaits()) {
@@ -318,6 +327,7 @@ export class ChatSession {
                 ...(extras.mentions?.length ? { mentions: extras.mentions } : {}),
                 ...(extras.skills?.length ? { skills: extras.skills } : {}),
                 ...(extras.chats?.length ? { chats: extras.chats } : {}),
+                ...(extras.quoteSource ? { quoteSource: extras.quoteSource } : {}),
                 ...(extras.attachments?.length ? { attachments: extras.attachments } : {})
             };
             this.setQueue([...this.queue, message]);
@@ -424,11 +434,22 @@ export class ChatSession {
         this.options.persist();
     }
 
+    /* A quote whose source is no reply of this thread is sent as the plain text it is; the message itself is never refused for it. */
+    private vetted(extras: ChatSendExtras): ChatSendExtras {
+        if (extras.quoteSource === undefined || this.thread.get(extras.quoteSource.itemId)?.kind === 'assistant') {
+            return extras;
+        }
+        const plain = { ...extras };
+        delete plain.quoteSource;
+        return plain;
+    }
+
     sendInput(text: string, extras: ChatSendExtras = {}): Promise<{ queued: boolean; turnId: string }> {
         return this.submitInput(text, extras);
     }
 
-    private async submitInput(text: string, extras: ChatSendExtras): Promise<{ queued: boolean; turnId: string }> {
+    private async submitInput(text: string, sent: ChatSendExtras): Promise<{ queued: boolean; turnId: string }> {
+        const extras = this.vetted(sent);
         const backend = this.backend;
         const turnId = this.info.activeTurnId;
         if (
@@ -472,7 +493,8 @@ export class ChatSession {
                     mentions: extras.mentions,
                     skills: extras.skills,
                     chats: references.ids,
-                    attachments: extras.attachments
+                    attachments: extras.attachments,
+                    ...(extras.quoteSource ? { quoteSource: extras.quoteSource } : {})
                 }),
                 this.thread.patchInfo({ queue: this.queue.filter((entry) => entry.id !== message.id) })
             ]);
@@ -562,7 +584,14 @@ export class ChatSession {
         this.setQueue(rest);
         this.dispatch(
             next.text,
-            { mentions: next.mentions, skills: next.skills, chats: next.chats, attachments: next.attachments, uiChoice: next.uiChoice },
+            {
+                mentions: next.mentions,
+                skills: next.skills,
+                chats: next.chats,
+                attachments: next.attachments,
+                uiChoice: next.uiChoice,
+                quoteSource: next.quoteSource
+            },
             next.turnId
         );
     }
@@ -1212,6 +1241,98 @@ export class ChatSession {
         this.deliverNote({ noteId: `lost-background-${item.id}`, note: text, preamble: text });
     }
 
+    /*
+     * Stops one subagent of the CLI's own. The process that announced it ends it with `stop_task` and the
+     * parent goes on; a process that did not start it has nothing to address, so while a turn runs that
+     * is refused, and otherwise the row is only marked.
+     */
+    stopSubagent(toolUseId: string): 'stopping' | 'marked' {
+        const row = this.thread.find('subagent', (item) => item.toolUseId === toolUseId);
+        const agentId = row?.native?.agentId;
+        const owned = this.subagentOwners.get(toolUseId) === this.generation;
+        if (agentId !== undefined && owned && this.backend?.stopTask) {
+            this.stopping.set(agentId, toolUseId);
+            this.backend.stopTask(agentId);
+            return 'stopping';
+        }
+        if (agentId !== undefined && !owned && this.thread.info.activeTurnId !== null) {
+            throw new ChatError('subagent-stale', 'This sub-agent belongs to a process that has ended');
+        }
+        this.markSubagentStopped(toolUseId);
+        return 'marked';
+    }
+
+    private trackSubagentOwner(generation: number, event: BackendEvent): void {
+        if (event.type === 'task.started' && event.taskId) {
+            this.subagentOwners.set(event.ref, generation);
+        } else if (event.type === 'task.done') {
+            this.noteStopped(event);
+            if (event.ref !== null) {
+                this.subagentOwners.delete(event.ref);
+            }
+        } else if (event.type === 'exit') {
+            this.stopping.clear();
+        }
+    }
+
+    /* The CLI would not stop it: with no turn running the row is only marked, and while one runs a note says it still goes on. */
+    private refuseStop(agentId: string, message: string): void {
+        const toolUseId = this.stopping.get(agentId);
+        if (toolUseId === undefined) {
+            return;
+        }
+        this.stopping.delete(agentId);
+        const row = this.thread.find('subagent', (item) => item.toolUseId === toolUseId);
+        if (row?.status !== 'running') {
+            return;
+        }
+        if (this.thread.info.activeTurnId === null) {
+            this.markSubagentStopped(toolUseId);
+            return;
+        }
+        this.emit([
+            this.thread.upsert({
+                id: `stop-refused-${toolUseId}-${Date.now()}`,
+                kind: 'note',
+                createdAt: Date.now(),
+                turnId: null,
+                level: 'warning',
+                text: `"${row.description || row.subagentType || 'Sub-agent'}" could not be stopped: ${message}`
+            })
+        ]);
+        this.options.persist();
+    }
+
+    /* The line under a subagent that `stop_task` ended, once the CLI reported it settled. */
+    private noteStopped(event: Extract<BackendEvent, { type: 'task.done' }>): void {
+        const stopped = [...this.stopping].find(([agentId, toolUseId]) => agentId === event.taskId || toolUseId === event.ref);
+        if (stopped === undefined) {
+            return;
+        }
+        this.stopping.delete(stopped[0]);
+        // It finished on its own just before the stop arrived; the row already says so.
+        if (event.ok) {
+            return;
+        }
+        const row = this.thread.find('subagent', (item) => item.toolUseId === stopped[1]);
+        if (!row) {
+            return;
+        }
+        const now = Date.now();
+        this.emit([
+            ...(row.status === 'running' ? [this.thread.upsert({ ...row, status: 'failed' as const, finishedAt: now })] : []),
+            this.thread.upsert({
+                id: `stopped-${row.toolUseId}`,
+                kind: 'note',
+                createdAt: now,
+                turnId: null,
+                level: 'info',
+                text: `"${row.description || row.subagentType || 'Sub-agent'}" was stopped.`
+            })
+        ]);
+        this.options.persist();
+    }
+
     /*
      * Marks a subagent of the CLI's own as stopped: `failed` with a note that says what it means, since
      * no CLI stops one subagent on its own. Refused while a turn runs, which may still be waiting on it.
@@ -1325,7 +1446,8 @@ export class ChatSession {
                     skills,
                     chats,
                     attachments,
-                    ...(extras.uiChoice ? { uiChoice: extras.uiChoice } : {})
+                    ...(extras.uiChoice ? { uiChoice: extras.uiChoice } : {}),
+                    ...(extras.quoteSource ? { quoteSource: extras.quoteSource } : {})
                 })
             );
         }
@@ -1362,14 +1484,14 @@ export class ChatSession {
         if (!checkpoints) {
             return Promise.resolve();
         }
-        return checkpoints
-            .take(this.thread.info.cwd)
-            .then((tree) => {
+        const cwd = this.thread.info.cwd;
+        return Promise.all([checkpoints.take(cwd), checkpoints.head?.(cwd) ?? null])
+            .then(([tree, head]) => {
                 const turn = this.thread.get(turnId);
                 if (tree === null || turn?.kind !== 'turn' || turn.state !== 'running' || this.info.activeTurnId !== turnId) {
                     return;
                 }
-                this.emit([this.thread.upsert({ ...turn, checkpoint: tree })]);
+                this.emit([this.thread.upsert({ ...turn, checkpoint: tree, ...(head === null ? {} : { checkpointHead: head }) })]);
             })
             .catch(() => undefined);
     }
@@ -1380,14 +1502,22 @@ export class ChatSession {
         if (turn?.kind !== 'turn' || turn.checkpoint === undefined || turn.checkpointDiff || !this.options.checkpoints) {
             return;
         }
-        void this.options.checkpoints
-            .settle(this.thread.info.cwd, turn.checkpoint)
-            .then((answer) => {
+        const { checkpoints } = this.options;
+        const cwd = this.thread.info.cwd;
+        void Promise.all([checkpoints.settle(cwd, turn.checkpoint), checkpoints.head?.(cwd) ?? null])
+            .then(([answer, head]) => {
                 const settled = this.thread.get(turnId);
                 if (answer === null || settled?.kind !== 'turn') {
                     return;
                 }
-                this.emit([this.thread.upsert({ ...settled, checkpointDiff: answer.diff, checkpointAfter: answer.after })]);
+                this.emit([
+                    this.thread.upsert({
+                        ...settled,
+                        checkpointDiff: answer.diff,
+                        checkpointAfter: answer.after,
+                        ...(head === null ? {} : { checkpointHeadAfter: head })
+                    })
+                ]);
                 this.options.persist();
             })
             .catch(() => undefined);
@@ -1631,6 +1761,10 @@ export class ChatSession {
             this.applyTitle(event.title);
             return;
         }
+        if (event.type === 'stop.refused') {
+            this.refuseStop(event.taskId, event.message);
+            return;
+        }
         /*
          * A CLI reports the window it was started on. A pick made since waits for the restart the next
          * send does, so its report may not put the old size back under a meter that already reads the new one.
@@ -1687,6 +1821,7 @@ export class ChatSession {
             this.awaitingBackgroundReport = true;
         }
         this.emit(projected);
+        this.trackSubagentOwner(generation, event);
         this.watchWorkflows(event);
         if (isMainAgentOutput(event)) {
             this.spokenTurnId = this.thread.info.activeTurnId;

package/src/chat/claude-protocol.ts

@@ -147,6 +147,9 @@ export class ClaudeProtocol {
     private apiError: string | null = null;
     private readonly refusedWindows = new Map<string, number | null>();
 
+    // The task each `stop_task` request named, so an error answer finds it again.
+    private readonly stopRequests = new Map<string, string>();
+
     private readonly steerIds = new Set<string>();
 
     beginSteer(promptId: string): void {
@@ -185,6 +188,9 @@ export class ClaudeProtocol {
             case 'control_request':
                 this.handleControlRequest(frame, events);
                 break;
+            case 'control_response':
+                this.handleControlResponse(frame, events);
+                break;
             case 'control_cancel_request': {
                 const requestId = str(frame.request_id);
                 if (requestId) {
@@ -445,7 +451,23 @@ export class ClaudeProtocol {
 
     /* The control request that ends one task the CLI runs beside its turns. */
     stopTaskRequest(taskId: string): unknown {
-        return { type: 'control_request', request_id: `stop-task-${taskId}-${Date.now()}`, request: { subtype: 'stop_task', task_id: taskId } };
+        const requestId = `stop-task-${taskId}-${Date.now()}`;
+        this.stopRequests.set(requestId, taskId);
+        return { type: 'control_request', request_id: requestId, request: { subtype: 'stop_task', task_id: taskId } };
+    }
+
+    /* Only a refused `stop_task` matters; every other answer is the CLI saying it took the request. */
+    private handleControlResponse(frame: Frame, events: BackendEvent[]): void {
+        const response = isRecord(frame.response) ? frame.response : null;
+        const requestId = str(response?.request_id);
+        const taskId = requestId === null ? undefined : this.stopRequests.get(requestId);
+        if (response === null || requestId === null || taskId === undefined) {
+            return;
+        }
+        this.stopRequests.delete(requestId);
+        if (response.subtype === 'error') {
+            events.push({ type: 'stop.refused', taskId, message: str(response.error) ?? 'The CLI refused to stop it' });
+        }
     }
 
     private handleStreamEvent(frame: Frame, events: BackendEvent[]): void {

package/src/chat/claude-transcript.ts

@@ -19,7 +19,7 @@ function str(value: unknown): string | null {
 }
 
 /* The words of a user line that somebody said, or null for a line that carries tool results. */
-function spokenText(content: unknown): string | null {
+export function spokenText(content: unknown): string | null {
     if (typeof content === 'string') {
         return content;
     }

package/src/chat/errors.ts

@@ -12,6 +12,8 @@ export type ChatErrorCode =
     | 'chat-unsupported'
     | 'invalid-attachments'
     | 'subagent-not-found'
+    // The sub-agent was started by a CLI process that has ended, so no process here can stop it.
+    | 'subagent-stale'
     | 'task-not-found'
     // What reading or forking a CLI's own conversation is refused with.
     | 'transcript-missing'