@adecore/agents 0.21.1 → 0.22.0

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

@@ -7,12 +7,12 @@ export interface CodexBackendOptions {
 }
 export declare class CodexBackend implements ChatBackend {
     readonly acknowledgesTurns = true;
-    private promptId;
     private readonly launch;
-    private imageWrites;
     private readonly host;
     private readonly protocol;
     private readonly client;
+    private promptId;
+    private imageWrites;
     private transport;
     private threadId;
     private contextPending;

package/dist/chat/codex-backend.js

@@ -1,10 +1,10 @@
 import { accessSync, constants } from 'node:fs';
 import { attachmentImageMime } from '@adecore/agent-contracts';
+import { errorText } from '../error-text.js';
 import { codexServiceTier, codexThreadOptions } from '../providers/codex.js';
 import { CodexProtocol } from './codex-protocol.js';
-import { attachmentNote } from './input.js';
 import { CodexTransport, DEFAULT_CODEX_CLIENT } from './codex-transport.js';
-import { errorText } from '../error-text.js';
+import { attachmentNote } from './input.js';
 function textInput(text) {
     return [{ type: 'text', text, text_elements: [] }];
 }
@@ -37,18 +37,15 @@ export function parseSkillsList(result) {
  */
 export class CodexBackend {
     acknowledgesTurns = true;
-    promptId = null;
     launch;
-    imageWrites = null;
     host;
     protocol;
     client;
+    promptId = null;
+    imageWrites = null;
     transport = null;
     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.
     contextPending = null;
     imageInputSupported = null;
     /* A turn asked for that Codex has not named yet; `turn/interrupt` needs that name. */

package/dist/chat/codex-protocol.js

@@ -130,7 +130,7 @@ function elicitationInput(meta) {
     }
     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) {
     const spent = windows.filter((window) => window.used >= 1);
     if (spent.length === 0 || spent.some((window) => window.resetsAt === null)) {

package/dist/chat/codex-thread.js

@@ -1,8 +1,8 @@
+import { errorText } from '../error-text.js';
 import { CodexProtocol } from './codex-protocol.js';
 import { CodexTransport, DEFAULT_CODEX_CLIENT } from './codex-transport.js';
 import { ChatError } from './errors.js';
 import { readingThread, settledReading } from './subagent-projection.js';
-import { errorText } from '../error-text.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -85,14 +85,13 @@ async function nthTurnId(transport, threadId, turns) {
     let seen = 0;
     let cursor = 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/dist/chat/composer-preferences.js

@@ -1,8 +1,7 @@
 /*
  * 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 {
     byClient = new Map();

package/dist/chat/errors.d.ts

@@ -1,4 +1,4 @@
 import { CodedError } from '../coded-error.ts';
-export type ChatErrorCode = 'refused-query' | 'stale-ui-query' | 'history-expired' | 'chat-not-found' | 'chat-unreadable' | 'chat-busy' | 'request-not-found' | 'chat-unsupported' | 'invalid-attachments' | 'subagent-not-found' | 'task-not-found' | 'transcript-missing' | 'transcript-format' | 'fork-failed' | 'turn-not-found' | 'item-not-found' | 'bookmark-not-found' | 'too-many-bookmarks' | 'visual-invalid' | 'visual-too-large';
+export type ChatErrorCode = 'refused-query' | 'stale-ui-query' | 'history-expired' | 'chat-not-found' | 'chat-unreadable' | 'chat-busy' | 'request-not-found' | 'chat-unsupported' | 'invalid-attachments' | 'subagent-not-found' | 'subagent-stale' | 'task-not-found' | 'transcript-missing' | 'transcript-format' | 'fork-failed' | 'turn-not-found' | 'item-not-found' | 'bookmark-not-found' | 'too-many-bookmarks' | 'visual-invalid' | 'visual-too-large';
 export declare class ChatError<TCode extends string = ChatErrorCode> extends CodedError<TCode> {
 }

package/dist/chat/external-sessions.d.ts

@@ -0,0 +1,26 @@
+export interface SessionFs {
+    readdir(path: string): Promise<string[]>;
+    stat(path: string): Promise<{
+        mtimeMs: number;
+    } | null>;
+    readHead(path: string, maxBytes: number): Promise<string>;
+}
+export interface ExternalSession {
+    provider: 'claude' | 'codex';
+    sessionId: string;
+    title: string;
+    updatedAt: number;
+    cwd: string;
+}
+export declare function listClaudeSessions({ projectsDir, folder, fs }: {
+    projectsDir: string;
+    folder: string;
+    fs: SessionFs;
+}): Promise<ExternalSession[]>;
+export declare function listCodexSessions({ sessionsDir, folder, fs, maxFiles }: {
+    sessionsDir: string;
+    folder: string;
+    fs: SessionFs;
+    maxFiles?: number;
+}): Promise<ExternalSession[]>;
+export declare function nodeSessionFs(): Promise<SessionFs>;

package/dist/chat/external-sessions.js

@@ -0,0 +1,136 @@
+import { join } from 'node:path';
+import { clipText } from '@adecore/agent-contracts';
+import { isForkOrSubagent } from '../usage/readers/codex.js';
+import { claudeProjectSlug, spokenText } from './claude-transcript.js';
+const TITLE_LENGTH = 120;
+// Claude writes hook output and attachments ahead of the first prompt, and Codex its instructions.
+const HEAD_BYTES = 256 * 1024;
+const CLAUDE_MAX_FILES = 200;
+function titleOf(text) {
+    return clipText(text.replace(/\s+/g, ' ').trim(), TITLE_LENGTH);
+}
+function records(head) {
+    const lines = head.split('\n');
+    // The head ends wherever the byte limit fell, so its last line may not parse.
+    return lines.flatMap((line) => {
+        if (line === '') {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(line);
+            return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+const CLAUDE_BOOKKEEPING = new Set(['summary', 'file-history-snapshot', 'queue-operation']);
+/* A reminder or the wrapper of a slash command is written as a user line too, but nobody said it. */
+function claudePrompt(entry) {
+    if (CLAUDE_BOOKKEEPING.has(String(entry.type)) || entry.type !== 'user' || entry.isSidechain === true || entry.isMeta === true) {
+        return null;
+    }
+    const message = typeof entry.message === 'object' && entry.message !== null ? entry.message : {};
+    const said = spokenText(message.content);
+    if (said === null || said.trim() === '' || said.startsWith('<command-') || said.startsWith('<local-command-')) {
+        return null;
+    }
+    return said;
+}
+/*
+ * The conversations Claude Code kept for a folder, newest first. Only the folder's own directory is
+ * read, and only the `.jsonl` files in it, so the transcripts of subagents in `<session>/subagents` stay out.
+ * A file without a prompt somebody said is no conversation.
+ */
+export async function listClaudeSessions({ projectsDir, folder, fs }) {
+    const dir = join(projectsDir, claudeProjectSlug(folder));
+    const names = (await fs.readdir(dir)).filter((name) => name.endsWith('.jsonl'));
+    const stats = await Promise.all(names.map(async (name) => ({ name, stat: await fs.stat(join(dir, name)) })));
+    const newest = stats
+        .flatMap(({ name, stat }) => (stat === null ? [] : [{ name, mtimeMs: stat.mtimeMs }]))
+        .sort((left, right) => right.mtimeMs - left.mtimeMs)
+        .slice(0, CLAUDE_MAX_FILES);
+    const sessions = [];
+    for (const { name, mtimeMs } of newest) {
+        const prompt = records(await fs.readHead(join(dir, name), HEAD_BYTES))
+            .map(claudePrompt)
+            .find((said) => said !== null);
+        if (prompt !== undefined && prompt !== null) {
+            sessions.push({ provider: 'claude', sessionId: name.slice(0, -'.jsonl'.length), title: titleOf(prompt), updatedAt: mtimeMs, cwd: folder });
+        }
+    }
+    return sessions;
+}
+function codexPrompt(entry) {
+    const payload = typeof entry.payload === 'object' && entry.payload !== null ? entry.payload : null;
+    if (payload === null) {
+        return null;
+    }
+    if (entry.type === 'event_msg' && payload.type === 'user_message' && typeof payload.message === 'string') {
+        return payload.message.trim() === '' ? null : payload.message;
+    }
+    return null;
+}
+/* The newest names first; the folders are named by year, month and day, and the files by when they began. */
+function newestFirst(names) {
+    return [...names].sort().reverse();
+}
+async function rolloutFiles(sessionsDir, fs, max) {
+    const files = [];
+    for (const year of newestFirst(await fs.readdir(sessionsDir))) {
+        for (const month of newestFirst(await fs.readdir(join(sessionsDir, year)))) {
+            for (const day of newestFirst(await fs.readdir(join(sessionsDir, year, month)))) {
+                const names = newestFirst((await fs.readdir(join(sessionsDir, year, month, day))).filter((name) => name.startsWith('rollout-') && name.endsWith('.jsonl')));
+                for (const name of names) {
+                    files.push(join(sessionsDir, year, month, day, name));
+                    if (files.length >= max) {
+                        return files;
+                    }
+                }
+            }
+        }
+    }
+    return files;
+}
+/*
+ * The conversations Codex kept for a folder, newest first, out of the newest `maxFiles` rollouts. A
+ * rollout counts when its first line, the session's metadata, names this folder and is no fork or subagent.
+ */
+export async function listCodexSessions({ sessionsDir, folder, fs, maxFiles = 400 }) {
+    const sessions = [];
+    for (const path of await rolloutFiles(sessionsDir, fs, maxFiles)) {
+        const entries = records(await fs.readHead(path, HEAD_BYTES));
+        const meta = entries[0];
+        const payload = meta?.type === 'session_meta' && typeof meta.payload === 'object' && meta.payload !== null ? meta.payload : null;
+        if (payload === null || payload.cwd !== folder || typeof payload.id !== 'string' || isForkOrSubagent(payload)) {
+            continue;
+        }
+        const prompt = entries.map(codexPrompt).find((said) => said !== null);
+        if (prompt === undefined || prompt === null) {
+            continue;
+        }
+        const stat = await fs.stat(path);
+        sessions.push({ provider: 'codex', sessionId: payload.id, title: titleOf(prompt), updatedAt: stat?.mtimeMs ?? 0, cwd: folder });
+    }
+    return sessions;
+}
+/* A `node:fs` behind the seam, for a host that lists the real thing. */
+export async function nodeSessionFs() {
+    const { readdir, stat, open } = await import('node:fs/promises');
+    return {
+        readdir: async (path) => readdir(path).catch(() => []),
+        stat: async (path) => stat(path).catch(() => null),
+        readHead: async (path, maxBytes) => {
+            const handle = await open(path, 'r');
+            try {
+                const buffer = Buffer.alloc(maxBytes);
+                const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+                return buffer.subarray(0, bytesRead).toString('utf8');
+            }
+            finally {
+                await handle.close();
+            }
+        }
+    };
+}

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/limit-resume.js

@@ -2,13 +2,8 @@
 export const LIMIT_RETRY_DELAYS_MS = [60_000, 5 * 60_000, 15 * 60_000];
 /* The last turn of a thread, when it stopped on a limit. */
 export function limitedTurn(items) {
-    for (let i = items.length - 1; i >= 0; i--) {
-        const item = items[i];
-        if (item.kind === 'turn') {
-            return item.state === 'error' && item.limit !== undefined ? item : null;
-        }
-    }
-    return null;
+    const last = items.findLast((item) => item.kind === 'turn');
+    return last?.kind === 'turn' && last.state === 'error' && last.limit !== undefined ? last : null;
 }
 /* How many turns in a row, up to and including this one, stopped on a limit: the tries a person did not step in between. */
 function limitedInARow(items, turn) {

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

@@ -59,6 +59,12 @@ function tooLarge(bytes) {
     return refuse('visual-too-large', `The page is ${mebibytes(bytes)} and a visual may be at most ${mebibytes(VISUAL_LIMITS.bytes)}; ` +
         'load libraries from a public CDN URL and refer to large images by their http(s) URL instead of inlining them');
 }
+function refuseOversized(html) {
+    const bytes = Buffer.byteLength(html, 'utf8');
+    if (bytes > VISUAL_LIMITS.bytes) {
+        tooLarge(bytes);
+    }
+}
 /*
  * The visuals of every chat. The list of a chat is one file beside its record under `<home>/chats`;
  * each page is a file in the chat's attachment folder, `<id>.html`, so whatever serves an attachment
@@ -104,9 +110,7 @@ export class VisualStore {
         if (html.trim() === '') {
             refuse('visual-invalid', 'The page is empty; pass one self-contained HTML document');
         }
-        if (Buffer.byteLength(html, 'utf8') > VISUAL_LIMITS.bytes) {
-            tooLarge(Buffer.byteLength(html, 'utf8'));
-        }
+        refuseOversized(html);
         return this.writeWorkspaceFile(chatId, name, html);
     }
     writePreview(chatId, png) {
@@ -116,9 +120,7 @@ export class VisualStore {
     async publish(chatId, input) {
         const { title, html, maxHeight, layout, heights } = checked(input);
         // Before the bootstrap is added, so a page far too large is never copied first.
-        if (Buffer.byteLength(html, 'utf8') > VISUAL_LIMITS.bytes) {
-            tooLarge(Buffer.byteLength(html, 'utf8'));
-        }
+        refuseOversized(html);
         const page = Buffer.from(injectVisualBootstrap(html), 'utf8');
         if (page.byteLength > VISUAL_LIMITS.bytes) {
             tooLarge(page.byteLength);

package/dist/context/refusal.js

@@ -1,8 +1,7 @@
 /*
  * How every no reads: `refused`, the code a script branches on and the sentence a model reads, and
- * under it a line per thing the actor can do instead. One row per line, and a line is a row of
- * tab-separated fields of its own, so only a newline is taken out of it: that would split the row in
- * two, and everything under the first row is read as advice.
+ * under it a line per thing the actor can do instead. A line keeps its tabs but loses its newlines,
+ * since everything under the first row is read as advice.
  */
 /* A field that goes into a tab-separated line; a tab or a newline in a title would split the row. */
 export function field(value) {
@@ -19,10 +18,7 @@ export function refusalBody(code, message, lines = []) {
     const [first, ...rest] = rows(code, message, lines);
     return [`refused\t${first}`, ...rest].join('\n');
 }
-/*
- * The same without the word that names it, for a host that adds the prefix in its CLI:
- * The context CLI puts the prefix on, so a CLI of an older build still prints one refusal.
- */
+/* Without the `refused` prefix, for a host whose CLI adds it, so a CLI of an older build still prints one refusal. */
 export function refusalRows(code, message, lines = []) {
     return rows(code, message, lines).join('\n');
 }

package/dist/context/verb.js

@@ -223,11 +223,7 @@ export function lengthOf(input) {
 export function requiredField(needs) {
     return z.string({ error: needs }).min(1, needs);
 }
-/*
- * What a refusal lists, or one line saying the set is empty. A refusal that promises the groups of a
- * canvas and then prints nothing reads as a daemon that lost them, where the truth is that there are
- * none, which is a different thing to do something about.
- */
+/* A refusal that promises a list and prints nothing reads as a host that lost it, where there is none. */
 export function orNote(lines, note) {
     return lines.length === 0 ? [`note\t${note}`] : lines;
 }

package/dist/host/agent-host.js

@@ -10,8 +10,8 @@ function isAgentRequest(type) {
 }
 /*
  * The chats of an app that has no daemon: it answers the agent requests over any `FramePort` and
- * sends the agent events back on it, frames checked on arrival. One port is one client. Closing the host writes every thread and ends every CLI; a chat
- * goes on at the next start through its CLI's own session.
+ * sends the agent events back on it, frames checked on arrival. One port is one client. A chat
+ * closed with the host goes on at the next start through its CLI's own session.
  */
 export class AgentHost {
     chats;

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),
@@ -81,7 +81,6 @@ export function chatHandlers(chats, providers) {
         'chat.list': () => ({ chats: chats.list() })
     };
 }
-/* The accounts are the person's settings of this host. */
 export function accountHandlers(accounts) {
     return {
         'accounts.list': () => accounts.snapshot(),

package/dist/host/wiring.js

@@ -6,10 +6,10 @@ import { suggestChatTitle } from '../chat/chat-title.js';
 import { VisualStore } from '../chat/visual-store.js';
 import { ClaudeTitleReader } from '../chat/claude-title.js';
 import { DEFAULT_CODEX_CLIENT } from '../chat/codex-transport.js';
+import { errorText } from '../error-text.js';
 import { definedEnv } from '../providers/accounts/launch.js';
 import { ProviderAccountsService } from '../providers/accounts/service.js';
 import { createClaudeProvider } from '../providers/claude-provider.js';
-import { errorText } from '../error-text.js';
 import { createCodexProvider } from '../providers/codex-provider.js';
 import { codexRulesPathIn, defaultCodexHome, installCodexRules } from '../providers/codex-rules.js';
 import { ProviderRegistry } from '../providers/registry.js';

package/dist/lineage.js

@@ -25,8 +25,8 @@ function openedByAgent(entry) {
     return entry.agent && entry.relation !== 'fork';
 }
 /*
- * Lineage lives in `lineage` under the host's data folder, outside the agent-writable project, so agents
- * cannot reset their own depth. Persisting it also prevents a restart of the host from resetting recursion limits.
+ * Lives under the host's data folder, outside the agent-writable project, so an agent cannot reset its
+ * own depth; on disk, so a restart of the host does not reset it either.
  */
 export class AgentLineageStore {
     dir;
@@ -117,7 +117,6 @@ export class AgentLineageStore {
         const entry = this.opened.get(nodeId);
         return entry?.relation === 'fork' ? entry.openedBy : null;
     }
-    /* The forks made from a chat. */
     forksOf(nodeId) {
         return [...this.opened.all()].filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId).map((entry) => entry.nodeId);
     }

package/dist/messages/deliver-message.js

@@ -5,13 +5,11 @@ export const DeliverMessageWorkSchema = z.object({
     payload: z.object({ from: z.string().min(1) })
 });
 /*
- * Opens the turn a message earns a chat. The messages themselves are not carried here: they wait in
- * the notice store and the turn's preamble takes them (`NoticeNotes`), the same channel a person's
- * own prompt reads them through, so one message is heard once whichever of the two opens the turn.
+ * Opens the turn a message earns a chat. The messages wait in the notice store and the turn's preamble
+ * takes them (`NoticeNotes`), as a person's own prompt does, so a message is heard once either way.
  *
- * One attempt, never `wait`. A chat that turned out to be in a turn reads the message in front of its
- * next one, which is what a message to a busy chat has always done; holding the entry instead would
- * make the host start turns nobody asked for long after the news was worth anything.
+ * One attempt, never `wait`: a chat already in a turn reads the message in front of its next one, and
+ * holding the entry would start turns nobody asked for long after the news mattered.
  */
 export function deliverMessageHandler(deps) {
     return async (entry) => {
@@ -27,11 +25,8 @@ export function deliverMessageHandler(deps) {
         if (chat === null) {
             return;
         }
-        /*
-         * No note of its own, and the preamble stays off the thread. A person read the message as it
-         * landed (`showNotices`), so anything the turn adds about it only says the same thing again;
-         * the label on the turn already names who it came from.
-         */
+        // No note and no preamble on the thread: a person read the message as it landed (`showNotices`),
+        // and the label on the turn names who it came from.
         chat.wake({
             text: deps.words.prompt(waiting.length),
             label: deps.words.label(waiting),