@adecore/agents 0.21.1 → 0.22.0

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/chat-store.ts

@@ -4,12 +4,12 @@ import { join } from 'node:path';
 import { ChatInfoSchema, ChatItemSchema, type ChatInfo, type ChatItem } from '@adecore/agent-contracts';
 import { z } from 'zod';
 import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.ts';
-import { isBookmarkFileName } from './bookmark-store.ts';
+import { recordFileName } from '../record-directory.ts';
 import { migrateInlineAttachments, type AttachmentStore } from './attachment-store.ts';
+import { isBookmarkFileName } from './bookmark-store.ts';
 import { parseLog, type ChatLogLine } from './chat-log.ts';
 import { ChatThread } from './thread.ts';
 import { isVisualFileName } from './visual-store.ts';
-import { recordFileName } from '../record-directory.ts';
 
 // 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`
@@ -30,7 +30,7 @@ const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles', 'uiAc
 /* What a host keeps in a chat's record beside the thread; it never reaches the wire. */
 export type ChatRecordExtras = Record<string, unknown>;
 
-function extrasOf(record: Record<string, unknown>): ChatRecordExtras {
+function withoutOwnKeys(record: Record<string, unknown>): ChatRecordExtras {
     return Object.fromEntries(Object.entries(record).filter(([key]) => !OWN_KEYS.has(key)));
 }
 
@@ -90,10 +90,6 @@ function liftUiAccess(record: unknown): unknown {
     return Object.keys(uiAccess).length === 0 ? record : { ...record, uiAccess };
 }
 
-function withoutOwnKeys(extras: ChatRecordExtras): ChatRecordExtras {
-    return Object.fromEntries(Object.entries(extras).filter(([key]) => !OWN_KEYS.has(key)));
-}
-
 export interface ChatStoreOptions {
     attachments?: AttachmentStore | null;
     // Files a host keeps beside a record under names that also end in .json (a chat's plans), which are no chats.
@@ -214,7 +210,7 @@ export class ChatStore {
             resetSeq,
             preambles: snapshot.preambles ?? [],
             uiAccess: snapshot.uiAccess ?? {},
-            extras: extrasOf(snapshot),
+            extras: withoutOwnKeys(snapshot),
             lines
         };
     }

package/src/chat/chat-title.ts

@@ -1,7 +1,7 @@
 import type { AgentKind } from '@adecore/agent-contracts';
-import { cleanTitle } from '../title-file.ts';
 import type { ProviderRegistry } from '../providers/registry.ts';
 import { runProcess } from '../run-process.ts';
+import { cleanTitle } from '../title-file.ts';
 
 // 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;
@@ -19,10 +19,7 @@ function cap(text: string, limit: number): string {
     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: string, answer: string): string {
     return [
         'Write a short title for the conversation below, as a person would name it in a list of chats.',
@@ -42,9 +39,8 @@ export function buildTitlePrompt(prompt: string, answer: string): string {
 }
 
 /*
- * 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: string): string | null {
     const start = [...output.matchAll(/\{\s*"title"/g)].at(-1)?.index;

package/src/chat/claude-backend.ts

@@ -1,5 +1,5 @@
-import { errorText } from '../error-text.ts';
 import { randomUUID } from 'node:crypto';
+import { errorText } from '../error-text.ts';
 import { claudeArgs, claudeEnv, promptPrefix } from '../providers/claude.ts';
 import type { ApprovalDecision, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 import { ChatChild } from './chat-process.ts';
@@ -71,12 +71,10 @@ export class ClaudeBackend implements ChatBackend {
     }
 
     sendTurn(input: TurnInput): void {
-        // 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: TurnInput): Promise<boolean> {
@@ -88,8 +86,7 @@ export class ClaudeBackend implements ChatBackend {
             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);
                 reject(error instanceof Error ? error : new Error(errorText(error)));
@@ -147,6 +144,12 @@ export class ClaudeBackend implements ChatBackend {
         return child?.end() ?? Promise.resolve();
     }
 
+    private userMessage(input: TurnInput, promptId: string): Record<string, unknown> {
+        // 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 });
+    }
+
     private async readLines(child: ChatChild): Promise<void> {
         const reader = child.process.stdout.getReader();
         const decoder = new TextDecoder();

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-title.ts

@@ -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.ts';
 import { cleanTitle, readLines } from '../title-file.ts';
+import { usageRoots } from '../usage/roots.ts';
 
 interface Progress {
     offset: number;

package/src/chat/claude-transcript.ts

@@ -5,8 +5,8 @@ import type { ChatHistoryResult, ChatItem } from '@adecore/agent-contracts';
 import { readLines } from '../title-file.ts';
 import { ClaudeProtocol } from './claude-protocol.ts';
 import { readingThread, settledReading } from './subagent-projection.ts';
-import type { ChatThread } from './thread.ts';
 import type { ThreadProjector } from './projector.ts';
+import type { ChatThread } from './thread.ts';
 
 const CHUNK_BYTES = 4 * 1024 * 1024;
 
@@ -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/codex-backend.ts

@@ -1,11 +1,11 @@
 import { accessSync, constants } from 'node:fs';
 import { attachmentImageMime, type ChatSkill } from '@adecore/agent-contracts';
+import { errorText } from '../error-text.ts';
 import { codexServiceTier, codexThreadOptions } from '../providers/codex.ts';
 import type { ApprovalDecision, BackendEvent, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 import { CodexProtocol } from './codex-protocol.ts';
-import { attachmentNote } from './input.ts';
 import { CodexTransport, DEFAULT_CODEX_CLIENT, type CodexClientInfo, type CodexFrame } from './codex-transport.ts';
-import { errorText } from '../error-text.ts';
+import { attachmentNote } from './input.ts';
 
 function textInput(text: string) {
     return [{ type: 'text', text, text_elements: [] }];
@@ -46,18 +46,15 @@ export interface CodexBackendOptions {
  */
 export class CodexBackend implements ChatBackend {
     readonly acknowledgesTurns = true;
-    private promptId: string | null = null;
     private readonly launch: BackendLaunch;
-    private imageWrites: Promise<void> | null = null;
     private readonly host: BackendHost;
     private readonly protocol: CodexProtocol;
     private readonly client: CodexClientInfo;
+    private promptId: string | null = null;
+    private imageWrites: Promise<void> | null = null;
     private transport: CodexTransport | null = null;
     private threadId = '';
-    /*
-     * Codex 0.154 ignores developer instructions on `thread/resume` (measured), so a thread started
-     * before anything was linked would never hear of its links; the first prompt of a resumed process says so instead.
-     */
+    // Codex 0.154 ignores developer instructions on `thread/resume` (measured), so the first prompt of a resumed process carries them.
     private contextPending: string | null = null;
     private imageInputSupported: boolean | null = null;
     /* A turn asked for that Codex has not named yet; `turn/interrupt` needs that name. */

package/src/chat/codex-protocol.ts

@@ -172,7 +172,7 @@ function elicitationInput(meta: Frame): Frame {
     return input;
 }
 
-// Every spent window must reset; one unknown reset keeps resuming a person's choice.
+// The latest reset of every spent window; one without a known reset leaves resuming to a person.
 function spentUntil(windows: readonly UsageWindow[]): number | null {
     const spent = windows.filter((window) => window.used >= 1);
     if (spent.length === 0 || spent.some((window) => window.resetsAt === null)) {

package/src/chat/codex-thread.ts

@@ -1,10 +1,10 @@
 import type { ChatItem } from '@adecore/agent-contracts';
+import { errorText } from '../error-text.ts';
 import type { SpawnChatProcess } from './chat-process.ts';
 import { CodexProtocol } from './codex-protocol.ts';
 import { CodexTransport, DEFAULT_CODEX_CLIENT, type CodexClientInfo } from './codex-transport.ts';
 import { ChatError } from './errors.ts';
 import { readingThread, settledReading } from './subagent-projection.ts';
-import { errorText } from '../error-text.ts';
 
 function isRecord(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -116,14 +116,15 @@ async function nthTurnId(transport: CodexTransport, threadId: string, turns: num
     let seen = 0;
     let cursor: string | null = null;
     do {
-        const page = await transport.request('thread/turns/list', { threadId, limit: 100, sortDirection: 'asc', ...(cursor === null ? {} : { cursor }) });
-        const data = isRecord(page) && Array.isArray(page.data) ? page.data.filter(isRecord) : [];
-        for (const turn of data) {
+        const page = parseThreadItemsPage(
+            await transport.request('thread/turns/list', { threadId, limit: 100, sortDirection: 'asc', ...(cursor === null ? {} : { cursor }) })
+        );
+        for (const turn of page.entries) {
             if (++seen === turns) {
                 return typeof turn.id === 'string' ? turn.id : null;
             }
         }
-        cursor = isRecord(page) && typeof page.nextCursor === 'string' && page.nextCursor !== '' ? page.nextCursor : null;
+        cursor = page.nextCursor;
     } while (cursor !== null);
     return null;
 }

package/src/chat/composer-preferences.ts

@@ -15,9 +15,8 @@ interface Held {
 
 /*
  * What each connected client says a new chat starts with, for the chats the host starts with no
- * client mounting them. Held per socket like the approval switch: a machine never remembers a
- * person's pick after that person's client is gone, so with nobody connected a chat gets the
- * host's own defaults.
+ * client mounting them. Held per client only, so with nobody connected a chat gets the host's own
+ * defaults rather than the pick of a person who left.
  */
 export class ComposerPreferences {
     private readonly byClient = new Map<string, Held>();

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'