@adecore/agents 0.23.1 → 0.24.0

package/dist/chat/chat-session.js

@@ -1,19 +1,17 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { GeneratedImageInputSchema, notResumedNote } from '@adecore/agent-contracts';
-import { resolveUiChoice, UI_FENCE_LANGUAGE, UiFailure, uiHasFence, uiMayReferenceHost } from '@adecore/intelligent-ui';
-import { UiStream } from '@adecore/intelligent-ui/stream';
+import { randomUUID } from 'node:crypto';
+import { HOST_TASK_ORIGIN, notResumedNote } from '@adecore/agent-contracts';
+import { resolveUiChoice, UI_FENCE_LANGUAGE, UiFailure } from '@adecore/intelligent-ui';
 import { commandLabel, isBackgroundWork, reportsOnBackgroundWork, runningInBackground } from './background-work.js';
 import { ChatError } from './errors.js';
 import { limitedTurn, limitResumeAt, limitResumeWake } from './limit-resume.js';
 import { isMainAgentOutput, ThreadProjector } from './projector.js';
 import { readableAssistantText } from './readable-text.js';
 import { ChatThread } from './thread.js';
+import { UiReplies } from './ui-replies.js';
 import { errorText } from '../error-text.js';
 import { systemClock } from '../outbox/outbox-worker.js';
 // Claude Code names a session about six seconds after its first prompt, and a first turn can run for minutes.
 const TITLE_RECHECK_MS = 10_000;
-// Longer than any fence line or the name of a tag a scan looks for, so a match never falls between two deltas.
-const UI_SCAN_OVERLAP = 64;
 /* One per limited turn, so a second fork of the same turn writes no second note. */
 function continuedNoteId(turnId) {
     return `continued-${turnId}`;
@@ -79,37 +77,32 @@ export class ChatSession {
     pendingPreambles;
     submission = null;
     steering = new Set();
-    uiStreams = new Map();
-    uiCompiled = new Map();
     capturedUiAccess;
-    // How much of a streaming reply's text the fence and host scans already covered, so a delta scans only its tail.
-    uiScanned = new Map();
-    uiReferencing = new Set();
-    uiAttachments = new Map();
-    uiFenceLanguage;
+    uiReplies;
     constructor(options) {
         this.options = options;
-        this.uiFenceLanguage = options.uiFenceLanguage ?? UI_FENCE_LANGUAGE;
         this.pendingPreambles = options.preambles ?? [];
         this.capturedUiAccess = new Map(Object.entries(options.uiAccess ?? {}));
         this.thread = new ChatThread(options.info, options.items);
         this.projector = new ThreadProjector(this.thread, { providerName: options.provider.name });
+        this.uiReplies = new UiReplies({
+            thread: this.thread,
+            fenceLanguage: options.uiFenceLanguage ?? UI_FENCE_LANGUAGE,
+            clock: options.clock ?? systemClock,
+            ...(options.ui ? { host: options.ui } : {}),
+            emit: (event) => options.emit(event),
+            repair: (note) => {
+                if (!this.pendingPreambles.includes(note)) {
+                    this.pendingPreambles = [...this.pendingPreambles, note];
+                }
+            }
+        });
     }
     get uiPreviews() {
-        const events = [];
-        for (const [itemId, preview] of this.uiCompiled) {
-            const item = this.thread.get(itemId);
-            if (item?.kind === 'assistant' && item.streaming && item.text.length === preview.textLength) {
-                events.push({ type: 'delta', itemId, text: '', ui: preview.blocks, textLength: preview.textLength });
-            }
-        }
-        return events;
+        return this.uiReplies.previews();
     }
     previewItems(items) {
-        return items.map((item) => {
-            const preview = this.uiCompiled.get(item.id);
-            return item.kind === 'assistant' && preview?.textLength === item.text.length ? { ...item, ui: preview.blocks } : item;
-        });
+        return this.uiReplies.previewItems(items);
     }
     get id() {
         return this.thread.info.chatId;
@@ -131,7 +124,35 @@ export class ChatSession {
     get busy() {
         const turnId = this.thread.info.activeTurnId;
         const turn = turnId ? this.thread.get(turnId) : undefined;
-        return turnId !== null && (turn?.kind !== 'turn' || turn.origin !== 'agent');
+        // A turn the CLI opened toward a goal is the goal's own: a message waits for it like for any turn of the person's.
+        return turnId !== null && (turn?.kind !== 'turn' || turn.origin !== 'agent' || this.goalWorks());
+    }
+    /* Whether the CLI works toward a goal, which goes on in turns of its own until the goal is met, paused or cleared. */
+    goalWorks() {
+        return this.thread.info.goal?.status === 'active';
+    }
+    /*
+     * Pauses, resumes or clears the chat's goal. A CLI with calls for it takes them at once, even while a goal
+     * turn runs; resuming an idle goal and clearing a goal of a CLI without them go out as `/goal` in a turn of
+     * their own, which a goal turn still running is in the way of.
+     */
+    async goal(action) {
+        const supported = this.options.provider.capabilities.goals;
+        if (supported === undefined || (supported === 'command' && action !== 'clear')) {
+            throw new ChatError('chat-unsupported', `${this.options.provider.name} cannot ${action} a goal`);
+        }
+        if (this.thread.info.goal === undefined) {
+            throw new ChatError('goal-not-found', 'This chat has no goal');
+        }
+        const backend = this.backend;
+        if (supported === 'native' && backend?.goal && backend.running && (action !== 'resume' || this.busy)) {
+            await backend.goal(action);
+            return;
+        }
+        if (this.busy) {
+            throw new ChatError('chat-busy', 'Stop the turn that works toward the goal first');
+        }
+        this.send(`/goal ${action}`);
     }
     /* The next process uses these settings; live work keeps the process it started in. */
     configure(patch) {
@@ -303,6 +324,8 @@ export class ChatSession {
         if (extras.delivery !== 'steer' ||
             this.info.queuePaused ||
             text.startsWith('/') ||
+            // A goal runs as turns of its own; a message waits for the one running instead of joining it.
+            this.goalWorks() ||
             !this.busy ||
             !turnId ||
             !backend?.steerTurn ||
@@ -435,6 +458,10 @@ export class ChatSession {
     dispatch(text, extras, requestedTurnId) {
         this.pauseQueue(false);
         this.settleAgentTurn();
+        // A goal that was met has said what it had to; the next message of the person leaves it behind.
+        if (this.thread.info.goal?.status === 'complete') {
+            this.emit([this.thread.patchInfo({ goal: undefined })]);
+        }
         const { preamble, note } = this.contextNote(text);
         // A slash command must stay the first thing the CLI reads, as `contextNote` keeps it.
         const references = text.startsWith('/') || !this.options.references ? { ids: [], note: null } : this.options.references(extras.chats);
@@ -552,6 +579,20 @@ export class ChatSession {
         this.emit([this.thread.upsert({ ...item, state: 'dismissed' }), this.thread.setStatus(this.thread.statusFor(this.thread.info.activeTurnId))]);
         return true;
     }
+    /*
+     * Marks the chat as waiting on a person for something the host asks beside the CLI, such as a
+     * card a verb holds its call for. The chat reads `needs-you` until every key is released.
+     */
+    holdForPerson(key) {
+        if (this.thread.hold(key)) {
+            this.emit([this.thread.setStatus(this.thread.statusFor(this.thread.info.activeTurnId))]);
+        }
+    }
+    releaseHold(key) {
+        if (this.thread.release(key) && this.thread.info.status === 'needs-you') {
+            this.emit([this.thread.setStatus(this.thread.statusFor(this.thread.info.activeTurnId))]);
+        }
+    }
     /*
      * Starts the chat over: the CLI goes, and the next send starts one without a session to resume.
      * The thread resets at once; the returned promise lets the host wait for pending attachment
@@ -588,6 +629,7 @@ export class ChatSession {
                 queuePaused: false,
                 background: [],
                 delegating: undefined,
+                goal: undefined,
                 effectiveRuntimeMode: undefined,
                 permissionMode: undefined,
                 slashCommands: [],
@@ -957,7 +999,7 @@ export class ChatSession {
         for (const item of this.thread.list()) {
             const settled = item.kind === 'turn' && item.state === 'running'
                 ? { ...item, state: 'aborted', endedAt: now }
-                : item.kind === 'subagent' && item.origin !== 'ruimte' && item.status === 'running'
+                : item.kind === 'subagent' && item.origin !== HOST_TASK_ORIGIN && item.status === 'running'
                     ? { ...item, status: 'failed', finishedAt: now }
                     : settleStoredItem(item, null);
             if (settled !== item) {
@@ -979,9 +1021,29 @@ export class ChatSession {
         this.emit(events);
         this.options.persist();
     }
+    /*
+     * Ends the CLI and keeps the conversation: the next message starts a fresh process that resumes it,
+     * and with it the skills, plugins and servers the CLI reads at its start. Refused while a turn runs or
+     * the process still holds work, a request or a background command, since those would end with it.
+     */
+    restart() {
+        if (this.thread.info.activeTurnId !== null || this.processInUse()) {
+            throw new ChatError('chat-busy', `Chat ${this.id} is still working; stop it before restarting its agent session`);
+        }
+        this.clearStartWarning();
+        this.clearWorkflowWarnings();
+        const backend = this.backend;
+        this.backend = null;
+        this.starting = null;
+        this.launchedSelection = null;
+        // What the init frame of the process that goes announced; a skill added since would be filtered out by it.
+        this.emit([this.thread.patchInfo({ running: false, effectiveRuntimeMode: undefined, permissionMode: undefined, skills: undefined })]);
+        this.options.persist();
+        return backend?.dispose() ?? Promise.resolve();
+    }
     /* Ends the process and stops listening to it, as the host goes down; the thread stays as it is. */
     freeze() {
-        this.clearUi();
+        this.uiReplies.clear();
         this.clearStartWarning();
         this.clearWorkflowWarnings();
         this.frozen = true;
@@ -989,7 +1051,7 @@ export class ChatSession {
     }
     /* Ends the CLI and everything it started; settles once it exited or was sent the SIGKILL. */
     dispose() {
-        this.clearUi();
+        this.uiReplies.clear();
         this.clearStartWarning();
         this.clearWorkflowWarnings();
         if (this.titleTimer !== null) {
@@ -1146,7 +1208,9 @@ export class ChatSession {
     }
     /* Marks every running subagent of the CLI's own as stopped, for a person stopping the turn together with them. */
     markSubagentsStopped() {
-        this.markStopped(this.thread.list().filter((item) => item.kind === 'subagent' && item.status === 'running' && item.origin !== 'ruimte'));
+        this.markStopped(this.thread
+            .list()
+            .filter((item) => item.kind === 'subagent' && item.status === 'running' && item.origin !== HOST_TASK_ORIGIN));
     }
     markStopped(rows) {
         if (rows.length === 0) {
@@ -1424,7 +1488,7 @@ export class ChatSession {
         return runningInBackground(this.thread.list()).length > 0 || (this.info.background?.length ?? 0) > 0;
     }
     processInUse() {
-        return this.hasNativeWork() || this.thread.pending().length > 0 || this.awaitingBackgroundReport;
+        return this.hasNativeWork() || this.thread.pending().length > 0 || this.awaitingBackgroundReport || this.goalWorks();
     }
     replacementWaits() {
         return this.requiresReplacement() && (this.info.activeTurnId !== null || this.processInUse());
@@ -1469,6 +1533,7 @@ export class ChatSession {
             saveGeneratedImage: this.options.saveGeneratedImage,
             instructions: this.options.instructions?.() ?? null,
             resumeNote: this.options.resumeNote?.() ?? null,
+            ...(info.goal === undefined ? {} : { goal: info.goal }),
             ...(folders.length > 0 ? { folders } : {}),
             ...(this.options.spawn ? { spawn: this.options.spawn } : {})
         };
@@ -1594,7 +1659,7 @@ export class ChatSession {
         }
         this.emit(projected);
         this.trackSubagentOwner(generation, event);
-        this.watchWorkflows(event);
+        this.watchWorkflows(generation, event);
         if (isMainAgentOutput(event)) {
             this.spokenTurnId = this.thread.info.activeTurnId;
         }
@@ -1660,48 +1725,54 @@ export class ChatSession {
         }
         this.workflowWarnings.clear();
     }
-    watchWorkflows(event) {
-        if (!['tool.started', 'tool.progress', 'tool.output', 'tool.done', 'workflow.progress', 'task.started', 'task.done', 'exit', 'failed'].includes(event.type)) {
+    watchWorkflows(generation, event) {
+        if (event.type === 'tool.output' || event.type === 'tool.progress') {
+            // These come by the thousand, and only the call they name can be a workflow they move.
+            const item = this.projector.itemOf(generation, event.ref);
+            if (item?.kind === 'tool' && item.name === 'Workflow') {
+                this.watchWorkflow(item, true);
+            }
+            return;
+        }
+        if (!['tool.started', 'tool.done', 'workflow.progress', 'task.started', 'task.done', 'exit', 'failed'].includes(event.type)) {
             return;
         }
-        const clock = this.options.clock ?? systemClock;
         const ref = 'ref' in event ? event.ref : null;
         for (const item of this.thread.list()) {
-            if (item.kind !== 'tool' || item.name !== 'Workflow') {
-                continue;
+            if (item.kind === 'tool' && item.name === 'Workflow') {
+                this.watchWorkflow(item, ref === item.toolUseId && ['workflow.progress', 'tool.started', 'tool.done', 'task.started'].includes(event.type));
             }
-            const existing = this.workflowWarnings.get(item.id);
-            const progress = ref === item.toolUseId &&
-                ['workflow.progress', 'tool.started', 'tool.progress', 'tool.output', 'tool.done', 'task.started'].includes(event.type);
-            if (item.state !== 'running' || progress) {
-                if (existing !== undefined) {
-                    clock.clearTimeout(existing);
-                    this.workflowWarnings.delete(item.id);
-                }
-            }
-            if (item.state !== 'running' || (!progress && existing !== undefined) || (!progress && item.workflow?.stalledAt !== undefined)) {
-                continue;
-            }
-            if (progress) {
-                this.emit([
-                    this.thread.upsert({
-                        ...item,
-                        workflow: { name: null, phases: [], agents: [], ...item.workflow, lastProgressAt: clock.now(), stalledAt: undefined }
-                    })
-                ]);
-            }
-            this.workflowWarnings.set(item.id, clock.setTimeout(() => {
+        }
+    }
+    watchWorkflow(item, progress) {
+        const clock = this.options.clock ?? systemClock;
+        const existing = this.workflowWarnings.get(item.id);
+        if (item.state !== 'running' || progress) {
+            if (existing !== undefined) {
+                clock.clearTimeout(existing);
                 this.workflowWarnings.delete(item.id);
-                const current = this.thread.get(item.id);
-                if (this.frozen || current?.kind !== 'tool' || current.state !== 'running') {
-                    return;
-                }
-                this.emit([
-                    this.thread.upsert({ ...current, workflow: { name: null, phases: [], agents: [], ...current.workflow, stalledAt: clock.now() } })
-                ]);
-                this.options.persist();
-            }, 5 * 60_000));
+            }
+        }
+        if (item.state !== 'running' || (!progress && existing !== undefined) || (!progress && item.workflow?.stalledAt !== undefined)) {
+            return;
         }
+        if (progress) {
+            this.emit([
+                this.thread.upsert({
+                    ...item,
+                    workflow: { name: null, phases: [], agents: [], ...item.workflow, lastProgressAt: clock.now(), stalledAt: undefined }
+                })
+            ]);
+        }
+        this.workflowWarnings.set(item.id, clock.setTimeout(() => {
+            this.workflowWarnings.delete(item.id);
+            const current = this.thread.get(item.id);
+            if (this.frozen || current?.kind !== 'tool' || current.state !== 'running') {
+                return;
+            }
+            this.emit([this.thread.upsert({ ...current, workflow: { name: null, phases: [], agents: [], ...current.workflow, stalledAt: clock.now() } })]);
+            this.options.persist();
+        }, 5 * 60_000));
     }
     /* Whether the CLI that reports was started on a pick standing for the same window as the chat's own. */
     reportsCurrentWindow() {
@@ -1802,121 +1873,9 @@ export class ChatSession {
     }
     emit(events) {
         const delegating = this.delegatingChange(events);
-        for (let event of delegating === null ? events : [...events, delegating]) {
-            if (event.type === 'reset') {
-                this.clearUi();
-            }
-            if (event.type === 'item' && event.item.kind === 'tool') {
-                this.uiAttachments.delete(event.item.turnId);
-            }
-            const item = event.type === 'item' ? event.item : event.type === 'delta' ? this.thread.get(event.itemId) : null;
-            if (item?.kind !== 'assistant' || item.parentToolUseId) {
-                this.options.emit(event);
-                continue;
-            }
-            const tail = this.unscannedUiText(item, event.type === 'item');
-            if (uiMayReferenceHost(tail)) {
-                this.uiReferencing.add(item.id);
-            }
-            let stream = this.uiStreams.get(item.id);
-            if (!stream && !uiHasFence(tail, this.uiFenceLanguage)) {
-                this.forgetUiScan(item);
-                this.options.emit(event);
-                continue;
-            }
-            if (!stream) {
-                stream = new UiStream({
-                    querySchemas: this.options.ui?.schemas,
-                    fenceLanguage: this.uiFenceLanguage,
-                    id: item.id,
-                    clock: this.options.clock ?? systemClock,
-                    emit: (preview) => {
-                        this.uiCompiled.set(item.id, preview);
-                        this.options.emit({ type: 'delta', itemId: item.id, text: '', ui: preview.blocks, textLength: preview.textLength });
-                    }
-                });
-                this.uiStreams.set(item.id, stream);
-            }
-            if (this.uiReferencing.has(item.id)) {
-                this.options.ui?.observe(item, false);
-            }
-            this.forgetUiScan(item);
-            const latestAttachment = this.latestUiAttachment(item.turnId);
-            if (event.type === 'item' && !item.streaming) {
-                const ui = stream
-                    .finish(item.text, latestAttachment)
-                    .map((block) => ({ ...block, revision: createHash('sha256').update(JSON.stringify(block)).digest('hex') }));
-                this.uiStreams.delete(item.id);
-                this.uiCompiled.delete(item.id);
-                const diagnostics = [...new Set(ui.flatMap((block) => block.diagnostics.map((diagnostic) => diagnostic.message)))].slice(0, 6);
-                if (diagnostics.length > 0) {
-                    const repair = `Your last ${this.uiFenceLanguage} block had these diagnostics: ${diagnostics.join(' ')} Use the catalog's supported props and components.`.slice(0, 1200);
-                    if (!this.pendingPreambles.includes(repair)) {
-                        this.pendingPreambles = [...this.pendingPreambles, repair];
-                    }
-                }
-                const current = this.thread.get(item.id);
-                const completed = { ...item, ui, ...(current?.kind === 'assistant' && current.uiQueries ? { uiQueries: current.uiQueries } : {}) };
-                event = this.thread.upsert(completed);
-                this.options.emit(event);
-                this.options.ui?.observe(completed, true);
-            }
-            else {
-                this.options.emit(event);
-                stream.update(item.text, latestAttachment);
-            }
-        }
-    }
-    /*
-     * The text a scan has not covered yet, from the start of the line the last scan ended in, since a fence
-     * is one line; a long line is cut short, behind a character no fence or tag can follow.
-     */
-    unscannedUiText(item, whole) {
-        const scanned = whole ? 0 : (this.uiScanned.get(item.id) ?? 0);
-        this.uiScanned.set(item.id, item.text.length);
-        if (scanned === 0 || scanned > item.text.length) {
-            return item.text;
-        }
-        const line = item.text.lastIndexOf('\n', scanned - 1) + 1;
-        const from = Math.max(line, scanned - UI_SCAN_OVERLAP);
-        return from === line ? item.text.slice(from) : `\0${item.text.slice(from)}`;
-    }
-    forgetUiScan(item) {
-        if (!item.streaming) {
-            this.uiScanned.delete(item.id);
-            this.uiReferencing.delete(item.id);
-        }
-    }
-    /* Looked up once per turn, and again only after one of its tool calls changed. */
-    latestUiAttachment(turnId) {
-        if (this.uiAttachments.has(turnId)) {
-            return this.uiAttachments.get(turnId);
-        }
-        const attachment = this.findUiAttachment(turnId);
-        this.uiAttachments.set(turnId, attachment);
-        return attachment;
-    }
-    findUiAttachment(turnId) {
-        for (const item of this.thread.list().toReversed()) {
-            if (item.kind !== 'tool' || item.turnId !== turnId || item.name !== 'ImageGeneration' || item.state !== 'done') {
-                continue;
-            }
-            const input = GeneratedImageInputSchema.safeParse(item.input);
-            if (input.success && input.data.attachment?.mime.startsWith('image/')) {
-                return input.data.attachment.id;
-            }
-        }
-        return undefined;
-    }
-    clearUi() {
-        for (const stream of this.uiStreams.values()) {
-            stream.dispose();
+        for (const event of delegating === null ? events : [...events, delegating]) {
+            this.uiReplies.pass(event);
         }
-        this.uiStreams.clear();
-        this.uiCompiled.clear();
-        this.uiScanned.clear();
-        this.uiReferencing.clear();
-        this.uiAttachments.clear();
     }
     /* Said on the info as well as by the rows, since a client with the thread closed sees only the info. */
     delegatingChange(events) {

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

@@ -33,6 +33,7 @@ export declare class ChatStore {
     writeSync(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): void;
     read(chatId: string): Promise<ChatRecord | null>;
     unreadable(chatId: string): Promise<boolean>;
+    settled(chatId: string): Promise<boolean>;
     private readSnapshot;
     delete(chatId: string): Promise<void>;
 }

package/dist/chat/chat-store.js

@@ -1,5 +1,5 @@
 import { mkdirSync } from 'node:fs';
-import { mkdir, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { mkdir, open, readdir, readFile, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ChatInfoSchema, ChatItemSchema } from '@adecore/agent-contracts';
 import { z } from 'zod';
@@ -30,6 +30,7 @@ function withoutOwnKeys(record) {
 function logName(chatId) {
     return `${encodeURIComponent(chatId)}.log`;
 }
+// `settled` reads the info from the head of the record, so it stays the first key.
 function recordBody(info, items, at, preambles, extras, uiAccess) {
     return JSON.stringify({
         info,
@@ -154,6 +155,18 @@ export class ChatStore {
     async unreadable(chatId) {
         return (await this.readSnapshot(chatId)) === UNREADABLE;
     }
+    /*
+     * Whether the chat has neither a turn in flight nor a resume after a limit, by the info its record
+     * starts with and the last one its log wrote, without parsing the thread. False whenever that
+     * cannot be told so cheaply, which leaves the decision to `read`.
+     */
+    async settled(chatId) {
+        if (!settledInfo(await leadingInfo(join(this.dir, recordFileName(chatId))))) {
+            return false;
+        }
+        const last = lastLoggedInfo((await readOrNull(this.logPath(chatId))) ?? '');
+        return last === undefined || settledInfo(last);
+    }
     async readSnapshot(chatId) {
         const raw = await readOrNull(join(this.dir, recordFileName(chatId)));
         if (raw === null) {
@@ -182,6 +195,97 @@ export class ChatStore {
     }
 }
 const UNREADABLE = Symbol('unreadable');
+const RECORD_HEAD = Buffer.from('{"info":{');
+const HEAD_CHUNK_BYTES = 16384;
+const QUOTE = 0x22;
+const BACKSLASH = 0x5c;
+const OPEN_BRACE = 0x7b;
+const CLOSE_BRACE = 0x7d;
+/*
+ * The info a record starts with, read only as far as it goes; undefined for a record that is missing,
+ * starts otherwise (an older or hand-edited one) or ends before its info does. Scanning bytes is safe
+ * in UTF-8, where no byte of a multibyte character equals a quote, a backslash or a brace.
+ */
+async function leadingInfo(path) {
+    let handle;
+    try {
+        handle = await open(path, 'r');
+    }
+    catch (e) {
+        if (isNotFound(e)) {
+            return undefined;
+        }
+        throw e;
+    }
+    try {
+        let head = Buffer.alloc(0);
+        let at = RECORD_HEAD.length;
+        let depth = 1;
+        let inString = false;
+        let escaped = false;
+        const chunk = Buffer.alloc(HEAD_CHUNK_BYTES);
+        let { bytesRead } = await handle.read(chunk, 0, chunk.length, 0);
+        while (bytesRead > 0) {
+            head = Buffer.concat([head, chunk.subarray(0, bytesRead)]);
+            if (!head.subarray(0, RECORD_HEAD.length).equals(RECORD_HEAD.subarray(0, Math.min(head.length, RECORD_HEAD.length)))) {
+                return undefined;
+            }
+            for (; at < head.length; at++) {
+                const byte = head[at];
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (inString) {
+                    escaped = byte === BACKSLASH;
+                    inString = byte !== QUOTE;
+                }
+                else if (byte === QUOTE) {
+                    inString = true;
+                }
+                else if (byte === OPEN_BRACE) {
+                    depth += 1;
+                }
+                else if (byte === CLOSE_BRACE) {
+                    depth -= 1;
+                    if (depth === 0) {
+                        return parseOrUndefined(head.subarray(RECORD_HEAD.length - 1, at + 1).toString('utf8'));
+                    }
+                }
+            }
+            ({ bytesRead } = await handle.read(chunk, 0, chunk.length, head.length));
+        }
+        return undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/* The info of the last info or reset line in a log, unvalidated; undefined when no line carries one. */
+function lastLoggedInfo(raw) {
+    const lines = raw.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        // Most lines are items and deltas, which are larger and never carry this key.
+        if (!lines[i].includes('"info"')) {
+            continue;
+        }
+        const event = parseOrUndefined(lines[i])?.event;
+        if (event?.type === 'info' || event?.type === 'reset') {
+            return event.info;
+        }
+    }
+    return undefined;
+}
+function settledInfo(info) {
+    return typeof info === 'object' && info !== null && info.activeTurnId === null && !('resumeAt' in info);
+}
+function parseOrUndefined(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
 async function exists(path) {
     try {
         await stat(path);

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

@@ -12,6 +12,7 @@ export declare class ClaudeBackend implements ChatBackend {
     private stdinClosed;
     private interrupted;
     private readonly steers;
+    private steerTimer;
     private active;
     constructor(launch: BackendLaunch, host: BackendHost, options?: ClaudeBackendOptions);
     get running(): boolean;
@@ -31,7 +32,10 @@ export declare class ClaudeBackend implements ChatBackend {
     private readLines;
     private handleLine;
     private readLine;
+    private awaitSteers;
+    private clearSteerTimer;
     private rejectSteers;
+    private broken;
     private failed;
     private respond;
     private write;