@adecore/agents 0.21.1 → 0.22.0

package/dist/async.js

@@ -1,8 +1,6 @@
-/* The two waits the host does: a pause it can be woken from, and a deadline on somebody else's promise. */
 /*
- * Resolves after `ms`, or at once when the signal is raised. An abort ends the wait rather than
- * failing it: every caller here is a loop that checks the signal itself on the next turn, and a
- * rejection would only be caught and thrown away.
+ * Resolves after `ms`, or at once when the signal is raised. An abort resolves instead of rejecting:
+ * every caller is a loop that checks the signal itself on its next turn.
  */
 export function wait(ms, signal) {
     return new Promise((resolve) => {
@@ -13,10 +11,7 @@ export function wait(ms, signal) {
         }, { once: true });
     });
 }
-/*
- * The promise, or `message` when it takes longer than `ms`. The timer is cleared either way, so a
- * call that answers at once does not hold the process for the rest of its deadline.
- */
+/* The timer is cleared either way, so a call that answers at once does not hold the process until its deadline. */
 export function withTimeout(promise, ms, message) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(message)), ms);

package/dist/chat/backend.d.ts

@@ -176,6 +176,10 @@ export type BackendEvent = {
     type: 'note';
     level: 'info' | 'warning' | 'error';
     text: string;
+} | {
+    type: 'stop.refused';
+    taskId: string;
+    message: string;
 } | {
     type: 'turn.done';
     promptId?: string;

package/dist/chat/chat-core.d.ts

@@ -1,5 +1,4 @@
 import { type AgentKind, type ChatAttachment, type ChatAttachResult, type ChatAttachmentUpload, type ChatBookmark, type ChatCheckpointDiff, type ChatConfigurePayload, type ChatCreatePayload, type ChatEvent, type ChatHistoryResult, type ChatInfo, type ChatItem, type ChatQueuedMessage, type ChatUiChoicePayload, type ChatUiQueryPayload, type ChatUiLinkPayload, type ChatSkill, type ChatSubagentPayload, type ChatSubagentResult, type ChatTurnItem, type ChatVisual, type ModelSelection, type RuntimeMode } from '@adecore/agent-contracts';
-import { type ChatUiHost } from './ui-queries.ts';
 import { ClientSinks } from '../client-sinks.ts';
 import type { AgentEvent, AgentSink } from '../events.ts';
 import type { OutboxOutcome } from '../outbox/outbox-worker.ts';
@@ -8,6 +7,7 @@ import type { ProviderRegistry } from '../providers/registry.ts';
 import { SkillIndex } from '../skills.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
 import type { AttachmentStore } from './attachment-store.ts';
+import { type BackgroundWork } from './background-work.ts';
 import type { BookmarkStore } from './bookmark-store.ts';
 import type { SpawnChatProcess } from './chat-process.ts';
 import { ChatSession, type ChatReferences, type ChatSendExtras, type PromptNotes, type ResumeWords, type TurnCheckpoints } from './chat-session.ts';
@@ -17,8 +17,8 @@ import type { CodexProcessSpec } from './codex-thread.ts';
 import type { CodexClientInfo } from './codex-transport.ts';
 import { ComposerPreferences } from './composer-preferences.ts';
 import { DeltaCoalescer } from './delta-coalescer.ts';
-import { type BackgroundWork } from './background-work.ts';
 import { SubagentReader, type SubagentReaderOptions } from './subagent-reader.ts';
+import { type ChatUiHost } from './ui-queries.ts';
 import type { VisualInput, VisualStore } from './visual-store.ts';
 export interface InterruptedRun {
     chatId: string;
@@ -113,6 +113,9 @@ export declare class ChatCore {
                 values?: Record<string, unknown> | undefined;
                 at: number;
             } | undefined;
+            quoteSource?: {
+                itemId: string;
+            } | undefined;
         }[] | undefined;
         queuePaused?: boolean | undefined;
         background?: {

package/dist/chat/chat-core.js

@@ -1,25 +1,25 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ChatAttachmentUploadsSchema, generatedImageAttachment } from '@adecore/agent-contracts';
-import { ChatUiQueries } from './ui-queries.js';
 import { ClientSinks } from '../client-sinks.js';
 import { errorText } from '../error-text.js';
 import { AccountError, definedEnv, isDefaultAccountOf, launchEnv, storedAccount } from '../providers/accounts/launch.js';
 import { SkillIndex } from '../skills.js';
 import { usageRoots } from '../usage/roots.js';
+import { commandLabel, isBackgroundWork, runsInBackground } from './background-work.js';
 import { ChatLog, COMPACT_ABOVE_BYTES } from './chat-log.js';
 import { ChatSession } from './chat-session.js';
 import { ComposerPreferences } from './composer-preferences.js';
 import { DeltaCoalescer } from './delta-coalescer.js';
-import { readableAssistantText } from './readable-text.js';
 import { ChatError } from './errors.js';
-import { commandLabel, isBackgroundWork, runsInBackground } from './background-work.js';
+import { readableAssistantText } from './readable-text.js';
 import { SubagentReader } from './subagent-reader.js';
-/* A message a person or the agent wrote in the chat's own thread; a subagent's words belong to its row. */
+import { ChatUiQueries } from './ui-queries.js';
 function withoutHidden(info) {
     const { hidden: _hidden, ...rest } = info;
     return rest;
 }
+/* A message a person or the agent wrote in the chat's own thread; a subagent's words belong to its row. */
 function isBookmarkable(item) {
     return item.kind === 'user' || (item.kind === 'assistant' && (item.parentToolUseId ?? null) === null);
 }
@@ -486,8 +486,9 @@ export class ChatCore {
         return result;
     }
     /*
-     * 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, toolUseId) {
         await this.loaded(chatId);
@@ -502,7 +503,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. */
     async stopTask(chatId, taskId) {

package/dist/chat/chat-log.js

@@ -31,8 +31,8 @@ export function parseLog(raw) {
     return lines;
 }
 /*
- * Number and synchronously append each broadcast event so disk, memory and snapshot boundaries keep
- * one order. Recent lines stay in memory for immediate `since` attachment.
+ * Numbers every broadcast event and appends it synchronously, so disk, memory and snapshot boundaries
+ * keep one order. Recent lines stay in memory to answer an attach with `since` at once.
  */
 export class ChatLog {
     path;

package/dist/chat/chat-session.d.ts

@@ -1,4 +1,4 @@
-import type { ChatAttachment, ChatAssistantItem, ChatCheckpointDiff, ChatEvent, ChatInfo, ChatItem, ChatQueuedMessage, ChatSkill, ChatUiChoiceOrigin, ChatUiChoicePayload, ChatUiQueryState, ModelSelection, RuntimeMode } from '@adecore/agent-contracts';
+import type { ChatAttachment, ChatAssistantItem, ChatCheckpointDiff, ChatEvent, ChatInfo, ChatItem, ChatQueuedMessage, ChatQuoteSource, ChatSkill, ChatUiChoiceOrigin, ChatUiChoicePayload, ChatUiQueryState, ModelSelection, RuntimeMode } from '@adecore/agent-contracts';
 import type { UiCompileOptions } from '@adecore/intelligent-ui/compiler';
 import type { ChatProvider } from '../providers/provider.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
@@ -15,6 +15,7 @@ export interface TurnCheckpoints {
         diff: ChatCheckpointDiff;
         after: string;
     } | null>;
+    head?(cwd: string): Promise<string | null>;
 }
 export interface PromptNotes {
     next(): {
@@ -72,6 +73,7 @@ export interface ChatSendExtras {
     mentions?: string[];
     skills?: string[];
     chats?: string[];
+    quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachment[];
 }
 export interface ResumeWords {
@@ -101,6 +103,8 @@ export declare class ChatSession {
     private titleTimer;
     private naming;
     private frozen;
+    private readonly subagentOwners;
+    private readonly stopping;
     private readonly orphans;
     private pendingPreambles;
     private submission;
@@ -127,7 +131,7 @@ export declare class ChatSession {
         resumeAtReset?: boolean;
     }): ChatInfo;
     setAccount(account: string | undefined): ChatInfo;
-    send(text: string, extras?: ChatSendExtras): {
+    send(text: string, sent?: ChatSendExtras): {
         queued: boolean;
         turnId: string;
     };
@@ -140,6 +144,7 @@ export declare class ChatSession {
         turnId: string;
     };
     private recordUiAnswer;
+    private vetted;
     sendInput(text: string, extras?: ChatSendExtras): Promise<{
         queued: boolean;
         turnId: string;
@@ -199,6 +204,10 @@ export declare class ChatSession {
     }): Promise<unknown> | null;
     settleOrphanedSubagents(): Promise<void>;
     private recordLostBackground;
+    stopSubagent(toolUseId: string): 'stopping' | 'marked';
+    private trackSubagentOwner;
+    private refuseStop;
+    private noteStopped;
     markSubagentStopped(toolUseId: string): void;
     markSubagentsStopped(): void;
     private markStopped;

package/dist/chat/chat-session.js

@@ -70,6 +70,10 @@ export class ChatSession {
     naming = false;
     // Set while the host goes down: a CLI dying with it must not end the turn a restart takes up again.
     frozen = false;
+    // Which CLI process (generation) announced each subagent of its own, by call id; only that one can stop it.
+    subagentOwners = new Map();
+    // Subagents a stop_task went out for, as task id to call id, until their notification settles them.
+    stopping = new Map();
     // Background subagents a load found running whose transcript did not show an end yet; no CLI here will report them.
     orphans = new Set();
     pendingPreambles;
@@ -167,7 +171,8 @@ export class ChatSession {
     /*
      * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
      */
-    send(text, extras = {}) {
+    send(text, sent = {}) {
+        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()) {
@@ -183,6 +188,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]);
@@ -278,10 +284,20 @@ export class ChatSession {
         this.options.emit(this.thread.upsert({ ...item, uiAnswers: { ...item.uiAnswers, [answer.blockId]: answer } }));
         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. */
+    vetted(extras) {
+        if (extras.quoteSource === undefined || this.thread.get(extras.quoteSource.itemId)?.kind === 'assistant') {
+            return extras;
+        }
+        const plain = { ...extras };
+        delete plain.quoteSource;
+        return plain;
+    }
     sendInput(text, extras = {}) {
         return this.submitInput(text, extras);
     }
-    async submitInput(text, extras) {
+    async submitInput(text, sent) {
+        const extras = this.vetted(sent);
         const backend = this.backend;
         const turnId = this.info.activeTurnId;
         if (extras.delivery !== 'steer' ||
@@ -323,7 +339,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) })
             ]);
@@ -406,7 +423,14 @@ export class ChatSession {
         this.sendAfterReplacement = false;
         this.pauseQueue(false);
         this.setQueue(rest);
-        this.dispatch(next.text, { mentions: next.mentions, skills: next.skills, chats: next.chats, attachments: next.attachments, uiChoice: next.uiChoice }, next.turnId);
+        this.dispatch(next.text, {
+            mentions: next.mentions,
+            skills: next.skills,
+            chats: next.chats,
+            attachments: next.attachments,
+            uiChoice: next.uiChoice,
+            quoteSource: next.quoteSource
+        }, next.turnId);
     }
     dispatch(text, extras, requestedTurnId) {
         this.pauseQueue(false);
@@ -1016,6 +1040,96 @@ export class ChatSession {
         const text = `The machine restarted before background work "${label}" completed. It will not send a result. Do not wait for it.`;
         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) {
+        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';
+    }
+    trackSubagentOwner(generation, event) {
+        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. */
+    refuseStop(agentId, message) {
+        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. */
+    noteStopped(event) {
+        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', 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.
@@ -1121,7 +1235,8 @@ export class ChatSession {
                 skills,
                 chats,
                 attachments,
-                ...(extras.uiChoice ? { uiChoice: extras.uiChoice } : {})
+                ...(extras.uiChoice ? { uiChoice: extras.uiChoice } : {}),
+                ...(extras.quoteSource ? { quoteSource: extras.quoteSource } : {})
             }));
         }
         events.push(this.thread.patchInfo({ status: this.thread.statusFor(turnId), activeTurnId: turnId }));
@@ -1155,14 +1270,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);
     }
@@ -1172,14 +1287,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);
@@ -1409,6 +1532,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.
@@ -1466,6 +1593,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/dist/chat/chat-store.js

@@ -4,12 +4,12 @@ import { join } from 'node:path';
 import { ChatInfoSchema, ChatItemSchema } from '@adecore/agent-contracts';
 import { z } from 'zod';
 import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.js';
-import { isBookmarkFileName } from './bookmark-store.js';
+import { recordFileName } from '../record-directory.js';
 import { migrateInlineAttachments } from './attachment-store.js';
+import { isBookmarkFileName } from './bookmark-store.js';
 import { parseLog } from './chat-log.js';
 import { ChatThread } from './thread.js';
 import { isVisualFileName } from './visual-store.js';
-import { recordFileName } from '../record-directory.js';
 // zod strips what it does not know inside the info and the items, so a file written by an older build
 // (with `interactionMode`, say) still parses and loses only the dropped field. A record without `seq`
 // predates the log. Keys beside these are the host's own, and come back to it as they were written.
@@ -24,7 +24,7 @@ const RecordSchema = z.looseObject({
     uiAccess: z.record(z.string(), z.unknown()).optional()
 });
 const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles', 'uiAccess']);
-function extrasOf(record) {
+function withoutOwnKeys(record) {
     return Object.fromEntries(Object.entries(record).filter(([key]) => !OWN_KEYS.has(key)));
 }
 function logName(chatId) {
@@ -54,9 +54,6 @@ function liftUiAccess(record) {
     }
     return Object.keys(uiAccess).length === 0 ? record : { ...record, uiAccess };
 }
-function withoutOwnKeys(extras) {
-    return Object.fromEntries(Object.entries(extras).filter(([key]) => !OWN_KEYS.has(key)));
-}
 /*
  * One JSON file per chat under `<home>/chats`, written while a turn runs and on shutdown, with
  * the log of what happened since beside it (`ChatLog` appends to it; reading plays it back).
@@ -146,7 +143,7 @@ export class ChatStore {
             resetSeq,
             preambles: snapshot.preambles ?? [],
             uiAccess: snapshot.uiAccess ?? {},
-            extras: extrasOf(snapshot),
+            extras: withoutOwnKeys(snapshot),
             lines
         };
     }

package/dist/chat/chat-title.js

@@ -1,5 +1,5 @@
-import { cleanTitle } from '../title-file.js';
 import { runProcess } from '../run-process.js';
+import { cleanTitle } from '../title-file.js';
 // Enough of a conversation to name it; the rest of a long prompt or answer says nothing a title needs.
 const MAX_PROMPT_CHARS = 2000;
 const MAX_ANSWER_CHARS = 1500;
@@ -8,10 +8,7 @@ const TIMEOUT_MS = 45_000;
 function cap(text, limit) {
     return text.length <= limit ? text : `${text.slice(0, limit)}...`;
 }
-/*
- * What the CLI is asked. JSON again, as for a commit message: a model left to write freely opens
- * with a sentence, and that sentence would become the name of the node.
- */
+/* JSON, since a model left to write freely opens with a sentence, and that sentence would become the name. */
 export function buildTitlePrompt(prompt, answer) {
     return [
         'Write a short title for the conversation below, as a person would name it in a list of chats.',
@@ -30,9 +27,8 @@ export function buildTitlePrompt(prompt, answer) {
     ].join('\n');
 }
 /*
- * The title out of what the CLI printed, or null. Strict on purpose, unlike a commit message: a run
- * that holds no `{"title": "..."}` object printed something other than a title, and a derived name
- * is better than a stray line of it.
+ * Strict on purpose: a run that holds no `{"title": "..."}` object printed something other than a
+ * title, and a derived name is better than a stray line of it.
  */
 export function parseTitle(output) {
     const start = [...output.matchAll(/\{\s*"title"/g)].at(-1)?.index;

package/dist/chat/claude-backend.d.ts

@@ -27,6 +27,7 @@ export declare class ClaudeBackend implements ChatBackend {
     declineRequest(requestId: string, message: string): boolean;
     stop(): void;
     dispose(): Promise<void>;
+    private userMessage;
     private readLines;
     private handleLine;
     private readLine;

package/dist/chat/claude-backend.js

@@ -1,5 +1,5 @@
-import { errorText } from '../error-text.js';
 import { randomUUID } from 'node:crypto';
+import { errorText } from '../error-text.js';
 import { claudeArgs, claudeEnv, promptPrefix } from '../providers/claude.js';
 import { ChatChild } from './chat-process.js';
 import { ClaudeProtocol } from './claude-protocol.js';
@@ -59,12 +59,10 @@ export class ClaudeBackend {
         return Promise.resolve();
     }
     sendTurn(input) {
-        // The prefix is what the CLI must see first (ultrathink), then the note about the links, then what was typed.
-        const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
         const promptId = input.promptId ?? randomUUID();
         this.active = true;
         this.protocol.beginPrompt(promptId);
-        this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+        this.write(this.userMessage(input, promptId));
     }
     steerTurn(input) {
         if (!this.child || !this.active || this.stdinClosed) {
@@ -75,8 +73,7 @@ export class ClaudeBackend {
             this.steers.set(promptId, { resolve, reject });
             this.protocol.beginSteer(promptId);
             try {
-                const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
-                this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+                this.write(this.userMessage(input, promptId));
             }
             catch (error) {
                 this.steers.delete(promptId);
@@ -126,6 +123,11 @@ export class ClaudeBackend {
         this.child = null;
         return child?.end() ?? Promise.resolve();
     }
+    userMessage(input, promptId) {
+        // What the CLI must see first (ultrathink), then the preamble, then what was typed.
+        const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
+        return buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId });
+    }
     async readLines(child) {
         const reader = child.process.stdout.getReader();
         const decoder = new TextDecoder();

package/dist/chat/claude-protocol.d.ts

@@ -15,6 +15,7 @@ export declare class ClaudeProtocol {
     private readonly subagentModels;
     private apiError;
     private readonly refusedWindows;
+    private readonly stopRequests;
     private readonly steerIds;
     beginSteer(promptId: string): void;
     beginPrompt(promptId: string): void;
@@ -30,6 +31,7 @@ export declare class ClaudeProtocol {
     private endBackground;
     private endWorkflow;
     stopTaskRequest(taskId: string): unknown;
+    private handleControlResponse;
     private handleStreamEvent;
     private handleAssistant;
     private handleToolProgress;

package/dist/chat/claude-protocol.js

@@ -117,6 +117,8 @@ export class ClaudeProtocol {
     // Only main-chain errors classify the turn; each plan window can refuse it independently.
     apiError = null;
     refusedWindows = new Map();
+    // The task each `stop_task` request named, so an error answer finds it again.
+    stopRequests = new Map();
     steerIds = new Set();
     beginSteer(promptId) {
         this.steerIds.add(promptId);
@@ -152,6 +154,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) {
@@ -408,7 +413,22 @@ export class ClaudeProtocol {
     }
     /* The control request that ends one task the CLI runs beside its turns. */
     stopTaskRequest(taskId) {
-        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. */
+    handleControlResponse(frame, events) {
+        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' });
+        }
     }
     handleStreamEvent(frame, events) {
         const event = frame.event;

package/dist/chat/claude-title.js

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { usageRoots } from '../usage/roots.js';
 import { cleanTitle, readLines } from '../title-file.js';
+import { usageRoots } from '../usage/roots.js';
 // The two records carry these words; a line without them is never parsed.
 const MARKERS = ['"ai-title"', '"custom-title"'];
 /*

package/dist/chat/claude-transcript.d.ts

@@ -1,4 +1,5 @@
 import type { ChatHistoryResult, ChatItem } from '@adecore/agent-contracts';
+export declare function spokenText(content: unknown): string | null;
 export interface SubagentMeta {
     agentId: string;
     toolUseId: string | null;

package/dist/chat/claude-transcript.js

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