toolroll 0.9.95 → 0.9.97

package/dist/lead-cli-live.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The terminal's live reply for `toolroll chat` (docs/plans/responsive-chat.md §3.6): on a TTY only, one status line
+ * shown at once and redrawn in place, then the answer as it is written, in a block of at most six rows wrapped to the
+ * terminal's width by display width (wide and combining characters). Piped output and `--json` never get here.
+ *
+ * Only this renderer emits cursor controls. Every piece of model-derived text it draws (the partial reply, and the
+ * status line, which can carry a tool's label) passes through `terminalText` first, on the whole accumulated text
+ * every time, so an escape sequence split across stream chunks can never get past it.
+ *
+ * Views come from the shared live-reply core and are drawn through its serialized sender, so `finish()` resolves only
+ * after the last draw: the block is erased and the caller prints the final answer (or the failure) strictly after.
+ * The erase moves up within the block's known height; a terminal that scrolled meanwhile keeps what it showed.
+ * Every draw first re-proves the caller's `standing`: once it fails, the block is erased and nothing more is drawn.
+ */
+import type { LeadProgress } from "./lead-progress.js";
+import { type ShapeOptions } from "./reply-shape.js";
+/** Where the live block is drawn: the terminal, or a test's recording. */
+export type TerminalLiveOutput = {
+    write(chunk: string): void;
+    /** The terminal's width now, in columns; undefined when unknown. */
+    columns(): number | undefined;
+    /** Call the listener when the terminal is resized; returns the unsubscribe. */
+    onResize(listener: () => void): () => void;
+    /** Call the listener on Ctrl-C during a turn (the process then exits, as Ctrl-C always did); returns the unsubscribe. */
+    onInterrupt(listener: () => void): () => void;
+    /** Draw the status line dimmed (off under NO_COLOR). */
+    dim?: boolean;
+};
+/** At most this many rows of the reply show under the status line. */
+export declare const LIVE_TERMINAL_ROWS = 6;
+/** The columns one grapheme takes: 0 for a lone combining or format mark, 2 for wide and emoji, else 1. */
+export declare function graphemeWidth(cluster: string): number;
+/** The columns a line of text takes on a terminal. */
+export declare function displayWidth(text: string): number;
+/** Text wrapped to rows of at most `width` columns: at the last space where there is one, else mid-word. */
+export declare function wrapRows(text: string, width: number): string[];
+export type TerminalLive = {
+    /** Feed one engine event (the turn's `onProgress`). */
+    progress(event: LeadProgress): void;
+    /** The turn ended: wait for the last draw, then erase the block. The final answer or failure prints after this. */
+    finish(): Promise<void>;
+};
+/**
+ * Start one turn's live block: the status line shows at once. `shape` is the final reply's shaping (the owner's
+ * message and this app's origins), so a partial reads as the final will.
+ */
+export declare function startTerminalLive(out: TerminalLiveOutput, shape?: ShapeOptions, options?: {
+    spacingMs?: number;
+    /** Re-proved immediately before every draw (the person, the conversation, its projects and the turn, once known,
+     * running under the generation it was admitted with). False: the block is erased and nothing more is drawn. */
+    standing?: (turn: number | null) => boolean;
+}): TerminalLive;
+/** The real terminal: stdout, its resize events, and Ctrl-C (which still ends the process, after the block is gone). */
+export declare function processTerminal(env?: Record<string, string | undefined>): TerminalLiveOutput;
+/** A live block only on a real terminal that can move its cursor, and never for an agent driving the CLI. */
+export declare function liveTerminalWanted(json: boolean, env: Record<string, string | undefined>, tty: boolean, agent: () => boolean): boolean;

package/dist/lead-cli-live.js

@@ -0,0 +1,200 @@
+import { createLiveReply, createLiveSender } from "./live-reply.js";
+import { renderReply } from "./reply-shape.js";
+import { terminalText } from "./terminal-text.js";
+/** At most this many rows of the reply show under the status line. */
+export const LIVE_TERMINAL_ROWS = 6;
+/** The least time between two redraws. */
+const REDRAW_MS = 50;
+const STOPPED = "Stopped.";
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+/** East Asian wide and fullwidth ranges: these take two columns. */
+const WIDE = [
+    [0x1100, 0x115f], [0x231a, 0x231b], [0x2329, 0x232a], [0x23e9, 0x23ec], [0x23f0, 0x23f0], [0x23f3, 0x23f3],
+    [0x2e80, 0x303e], [0x3041, 0x33ff], [0x3400, 0x4dbf], [0x4e00, 0x9fff], [0xa000, 0xa4cf], [0xa960, 0xa97f],
+    [0xac00, 0xd7a3], [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60], [0xffe0, 0xffe6],
+    [0x1f300, 0x1f64f], [0x1f900, 0x1f9ff], [0x20000, 0x2fffd], [0x30000, 0x3fffd],
+];
+/** The columns one grapheme takes: 0 for a lone combining or format mark, 2 for wide and emoji, else 1. */
+export function graphemeWidth(cluster) {
+    if (cluster === "")
+        return 0;
+    if (/\p{Regional_Indicator}/u.test(cluster))
+        return 2;
+    if (/\p{Extended_Pictographic}/u.test(cluster) && (cluster.includes("️") || /\p{Emoji_Presentation}/u.test(cluster)))
+        return 2;
+    if (/^[\p{Mn}\p{Me}\p{Cf}]/u.test(cluster))
+        return 0;
+    const point = cluster.codePointAt(0);
+    return WIDE.some(([low, high]) => point >= low && point <= high) ? 2 : 1;
+}
+/** The columns a line of text takes on a terminal. */
+export function displayWidth(text) {
+    let width = 0;
+    for (const { segment } of graphemes.segment(text))
+        width += graphemeWidth(segment);
+    return width;
+}
+/** One line cut to fit `width` columns, ending in "…" when it was cut. */
+function fitRow(text, width) {
+    if (displayWidth(text) <= width)
+        return text;
+    let shown = "";
+    let used = 0;
+    for (const { segment } of graphemes.segment(text)) {
+        const next = graphemeWidth(segment);
+        if (used + next > width - 1)
+            break;
+        shown += segment;
+        used += next;
+    }
+    return `${shown}…`;
+}
+/** Text wrapped to rows of at most `width` columns: at the last space where there is one, else mid-word. */
+export function wrapRows(text, width) {
+    const rows = [];
+    for (const line of text.split("\n")) {
+        let row = [];
+        let used = 0;
+        let space = -1;
+        for (const { segment } of graphemes.segment(line)) {
+            const next = graphemeWidth(segment);
+            if (used + next > width && row.length > 0) {
+                // A space that doesn't fit ends the row there; it is not carried to the next one.
+                if (segment === " ") {
+                    rows.push(row.join("").trimEnd());
+                    row = [];
+                    used = 0;
+                    space = -1;
+                    continue;
+                }
+                while (used + next > width && row.length > 0) {
+                    if (space > 0) {
+                        rows.push(row.slice(0, space).join("").trimEnd());
+                        row = row.slice(space + 1);
+                    }
+                    else {
+                        rows.push(row.join(""));
+                        row = [];
+                    }
+                    used = row.reduce((sum, one) => sum + graphemeWidth(one), 0);
+                    space = row.lastIndexOf(" ");
+                }
+            }
+            row.push(segment);
+            used += next;
+            if (segment === " ")
+                space = row.length - 1;
+        }
+        rows.push(row.join("").trimEnd());
+    }
+    return rows;
+}
+/**
+ * Start one turn's live block: the status line shows at once. `shape` is the final reply's shaping (the owner's
+ * message and this app's origins), so a partial reads as the final will.
+ */
+export function startTerminalLive(out, shape = {}, options = {}) {
+    const reply = createLiveReply(shape);
+    /** The turn this block follows, once the engine has said it started. */
+    let turn = null;
+    /** The rows on screen now, as drawn (without the dim styling); empty when nothing is. */
+    let drawn = [];
+    let ended = false;
+    const columns = () => {
+        const known = out.columns();
+        return known !== undefined && Number.isFinite(known) && known > 0 ? Math.floor(known) : 80;
+    };
+    /** Back to the block's first row and clear to the end of the screen. Rows are measured at the width now, as a
+     * terminal that reflows on resize has rewrapped them. */
+    const eraseSequence = () => {
+        if (drawn.length === 0)
+            return "";
+        const now = columns();
+        const height = drawn.reduce((sum, row) => sum + Math.max(1, Math.ceil(displayWidth(row) / now)), 0);
+        drawn = [];
+        return `\r${height > 1 ? `\x1b[${height - 1}A` : ""}\x1b[J`;
+    };
+    const draw = () => {
+        if (ended)
+            return;
+        if (options.standing !== undefined && !options.standing(turn)) {
+            // Standing lost: clear what is shown and close the preview; the turn's own outcome says why.
+            ended = true;
+            void sender.close();
+            stopResize();
+            const erase = eraseSequence();
+            if (erase !== "")
+                out.write(erase);
+            return;
+        }
+        // Three columns short of the edge: a full row never leaves the cursor waiting to wrap, and the "^C" a terminal
+        // echoes after the last row on Ctrl-C never wraps it, so the erase's height stays right.
+        const width = Math.max(10, columns() - 3);
+        const view = reply.view();
+        const status = view.phase === "working" || view.phase === "writing" ? view.status : reply.status();
+        const text = view.phase === "writing" ? terminalText(renderReply(view.text, "terminal")) : "";
+        const rows = [fitRow(terminalText(status), width), ...(text === "" ? [] : wrapRows(text, width).slice(-LIVE_TERMINAL_ROWS))];
+        const erase = eraseSequence();
+        const styled = rows.map((row, index) => (index === 0 && out.dim !== false ? `\x1b[2m${row}\x1b[22m` : row));
+        out.write(`${erase}${styled.join("\n")}`);
+        drawn = rows;
+    };
+    const sender = createLiveSender({ send: draw, spacingMs: options.spacingMs ?? REDRAW_MS });
+    const stopResize = out.onResize(() => sender.offer(null));
+    const stopInterrupt = out.onInterrupt(() => {
+        void sender.close();
+        const erase = eraseSequence();
+        ended = true;
+        stopResize();
+        out.write(`${erase}${STOPPED}\n`);
+    });
+    draw();
+    return {
+        progress(event) {
+            turn ??= event.turn;
+            // Model text is made terminal-safe before it is settled and shaped, on the whole text written so far.
+            if (reply.push(event.kind === "text" ? { ...event, text: terminalText(event.text) } : event))
+                sender.offer(null);
+        },
+        async finish() {
+            await sender.close();
+            stopResize();
+            stopInterrupt();
+            if (ended)
+                return;
+            ended = true;
+            const erase = eraseSequence();
+            if (erase !== "")
+                out.write(erase);
+        },
+    };
+}
+/** The real terminal: stdout, its resize events, and Ctrl-C (which still ends the process, after the block is gone). */
+export function processTerminal(env = process.env) {
+    return {
+        write: chunk => { process.stdout.write(chunk); },
+        columns: () => process.stdout.columns,
+        onResize(listener) {
+            process.stdout.on("resize", listener);
+            return () => { process.stdout.off("resize", listener); };
+        },
+        onInterrupt(listener) {
+            const handler = () => {
+                process.off("SIGINT", handler);
+                try {
+                    listener();
+                }
+                finally {
+                    process.exit(130);
+                }
+            };
+            process.on("SIGINT", handler);
+            return () => { process.off("SIGINT", handler); };
+        },
+        dim: env["NO_COLOR"] === undefined || env["NO_COLOR"] === "",
+    };
+}
+/** A live block only on a real terminal that can move its cursor, and never for an agent driving the CLI. */
+export function liveTerminalWanted(json, env, tty, agent) {
+    return !json && tty && env["TERM"] !== "dumb" && !agent();
+}

package/dist/lead-cli.d.ts

@@ -1,6 +1,7 @@
 import { type LeadProposal, type Store } from "./store.js";
 import { type ShapeOptions } from "./reply-shape.js";
 import type { SubscriptionLeadRunner } from "./subscription-chat.js";
+import { type TerminalLiveOutput } from "./lead-cli-live.js";
 export type LeadCliSeams = {
     fetcher?: typeof fetch;
     env?: Record<string, string | undefined>;
@@ -30,6 +31,8 @@ export type LeadCliInput = {
     evidenceRoot?: string;
     /** The console's address(es): a reply's links there are named as its pages ("the task"), not by host. */
     appOrigin?: ShapeOptions["appOrigin"];
+    /** A real terminal (never piped, never `--json`): each turn shows a live status line and the answer as it is written. */
+    liveTerminal?: TerminalLiveOutput;
 };
 export type LeadCliResult = {
     code: number;

package/dist/lead-cli.js

@@ -16,13 +16,15 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { LEAD_ASK_OTHER } from "./store.js";
 import { CHAT_KEY_ENV, credentialKeyOf, isDirectChatProvider, priceForConfig, subscriptionCredentialKey } from "./converse.js";
-import { verifyApproverByPassword } from "./principal.js";
+import { reproveApprover, verifyApproverByPassword } from "./principal.js";
 import { runLeadTurn } from "./lead.js";
 import { voiceReply } from "./reply-shape.js";
 import { confirmLeadProposal, dismissLeadProposal } from "./lead-doors.js";
 import { projectName } from "./project.js";
 import { CHAT_CONTROLS, chatControlHref, isChatControl } from "./chat-controls.js";
 import { CHAT_TASK_ACTIONS, isChatTaskAction } from "./chat-task-actions.js";
+import { terminalText } from "./terminal-text.js";
+import { startTerminalLive } from "./lead-cli-live.js";
 export const LEAD_CLI_EXIT = { ok: 0, failed: 1, usage: 2, refused: 3 };
 function money(microusd) {
     return `$${(microusd / 1_000_000).toFixed(2)}`;
@@ -135,9 +137,11 @@ export async function runLeadCli(input) {
     const seams = input.seams ?? {};
     const clock = seams.clock ?? (() => new Date());
     const env = seams.env ?? process.env;
+    // Everything said to a person's terminal passes the terminal filter: replies, cards and asks carry model-written
+    // text, and only Toolroll's own renderer may move the cursor. (`--json` escapes control characters itself.)
     const say = (line) => {
         if (!json)
-            write(line);
+            write(terminalText(line));
     };
     const emit = (envelope) => {
         if (json)
@@ -255,7 +259,33 @@ export async function runLeadCli(input) {
             const outcome = { ok: false, refused: "session-ended", message: "This conversation has ended. Run chat again to start a new one." };
             return outcome;
         }
-        return runLeadTurn({ store, who, session: live, thread, config, key, message, channel: "terminal", ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
+        // Before every draw: this approver as verified, this conversation and thread still open under the same projects,
+        // and the turn still running under the generation it was admitted with (as the engine's own guard re-proves).
+        let admitted = null;
+        const standing = (turnId) => {
+            if (!reproveApprover(store, who).ok)
+                return false;
+            const nowSession = store.getLeadSession(live.id), nowThread = store.getLeadThread(thread.id);
+            if (nowSession === null || nowSession.endedAt !== null || nowSession.approver !== who.name || nowSession.approverGeneration !== who.generation || nowSession.ceilingDigest !== who.ceilingDigest)
+                return false;
+            if (nowThread === null || nowThread.closedAt !== null || nowThread.approver !== who.name || nowThread.ceilingDigest !== who.ceilingDigest)
+                return false;
+            if (turnId === null)
+                return true;
+            const row = store.getLeadTurn(turnId);
+            if (row === null || row.state !== "running" || row.session !== live.id || row.thread !== thread.id)
+                return false;
+            admitted ??= row.generation;
+            return row.generation === admitted;
+        };
+        // The live block draws only on a real terminal; its last draw is erased before the answer or failure is printed.
+        const watch = input.liveTerminal === undefined || json ? null : startTerminalLive(input.liveTerminal, { appOrigin: input.appOrigin ?? null, asked: message }, { standing });
+        try {
+            return await runLeadTurn({ store, who, session: live, thread, config, key, message, channel: "terminal", ...(watch === null ? {} : { onProgress: watch.progress }), ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
+        }
+        finally {
+            await watch?.finish();
+        }
     };
     const report = (outcome, message) => {
         if (outcome.ok && outcome.replayed) {
@@ -268,7 +298,7 @@ export async function runLeadCli(input) {
             emit({ ok: true, turn: outcome.turn, reply: outcome.reply, activity: outcome.activity, steps: outcome.steps, settledMicrousd: outcome.settledMicrousd, proposals: pendingProposals().map(one => ({ id: one.id, ordinal: ordinalOf(one), kind: one.kind, payload: one.payload })),
                 ...(ask === null ? {} : { ask: { question: ask.question, options: [...ask.options, LEAD_ASK_OTHER] } }) });
             say(`  ${outcome.activity}`);
-            say(voiceReply(outcome.reply, "terminal", { appOrigin: input.appOrigin ?? null, ...(message === undefined ? {} : { asked: message }) }));
+            say(voiceReply(terminalText(outcome.reply), "terminal", { appOrigin: input.appOrigin ?? null, ...(message === undefined ? {} : { asked: message }) }));
             // The lead's question: the terminal has no buttons, so the options are listed to type back.
             if (ask !== null)
                 say(`${ask.question}\n${ask.options.map(one => `  · ${one}`).join("\n")}\n  · ${LEAD_ASK_OTHER} (type your answer)`);

package/dist/lead-latency-schema.d.ts

@@ -0,0 +1,24 @@
+/**
+ * v158: the lead's latency records and its quick-answer switch (docs/plans/responsive-chat.md, slice 5). Adds only:
+ * a saved row reads as it did. Kept beside nothing else so the update road can read the lists without the store.
+ *
+ * - `chat_turn.tools`: the tool names one lead step asked for, as a JSON array of names (never arguments); saved rows
+ *   read NULL (not recorded). So the next latency decision (a prefetched brief, §7.2) is made from data.
+ * - `chat_turn.failure_detail` and `mate_turn.failure_detail`: why a step or reply failed, more exactly than
+ *   failure_reason (LEAD_FAILURE_DETAILS); saved rows read NULL (unknown), and read the plain reason's words as before.
+ * - `mate_turn.route`: which model answered (§8): `default`, `fast` (the quick model answered) or `escalated` (a quick
+ *   step asked for more than reading, so the main model took the reply over); saved rows read NULL (before routing).
+ * - `lead_quick_setting`: Settings → Lead's "Quick answers use a faster model", one row; absent reads off.
+ */
+export declare const LEAD_FAILURE_DETAILS: readonly ["not-installed", "sign-in", "refused", "lost", "timeout-silent", "timeout-output"];
+export type LeadFailureDetail = typeof LEAD_FAILURE_DETAILS[number];
+export declare const LEAD_ROUTES: readonly ["default", "fast", "escalated"];
+export type LeadRoute = typeof LEAD_ROUTES[number];
+export declare const V158_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_quick_setting (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  enabled    INTEGER NOT NULL CHECK (enabled IN (0, 1)),\n  updated_by TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n";
+export declare const V158_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+export declare const V158_TABLES: readonly ["lead_quick_setting"];
+/** The v158 migration's steps, in order (a test seam may stop after each). */
+export declare const V158_STEPS: readonly ["lead-quick-setting", "lead-latency-columns"];

package/dist/lead-latency-schema.js

@@ -0,0 +1,36 @@
+/**
+ * v158: the lead's latency records and its quick-answer switch (docs/plans/responsive-chat.md, slice 5). Adds only:
+ * a saved row reads as it did. Kept beside nothing else so the update road can read the lists without the store.
+ *
+ * - `chat_turn.tools`: the tool names one lead step asked for, as a JSON array of names (never arguments); saved rows
+ *   read NULL (not recorded). So the next latency decision (a prefetched brief, §7.2) is made from data.
+ * - `chat_turn.failure_detail` and `mate_turn.failure_detail`: why a step or reply failed, more exactly than
+ *   failure_reason (LEAD_FAILURE_DETAILS); saved rows read NULL (unknown), and read the plain reason's words as before.
+ * - `mate_turn.route`: which model answered (§8): `default`, `fast` (the quick model answered) or `escalated` (a quick
+ *   step asked for more than reading, so the main model took the reply over); saved rows read NULL (before routing).
+ * - `lead_quick_setting`: Settings → Lead's "Quick answers use a faster model", one row; absent reads off.
+ */
+export const LEAD_FAILURE_DETAILS = ["not-installed", "sign-in", "refused", "lost", "timeout-silent", "timeout-output"];
+export const LEAD_ROUTES = ["default", "fast", "escalated"];
+const detailCheck = (column) => `TEXT CHECK (${column} IS NULL OR ${column} IN (${LEAD_FAILURE_DETAILS.map(one => `'${one}'`).join(",")}))`;
+export const V158_SCHEMA = `
+CREATE TABLE IF NOT EXISTS lead_quick_setting (
+  id         INTEGER PRIMARY KEY CHECK (id = 1),
+  enabled    INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+  updated_by TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+`;
+export const V158_ADDED_COLUMNS = Object.freeze({
+    chat_turn: {
+        tools: { definition: "TEXT", saved: "NULL" },
+        failure_detail: { definition: detailCheck("failure_detail"), saved: "NULL" },
+    },
+    mate_turn: {
+        route: { definition: `TEXT CHECK (route IS NULL OR route IN (${LEAD_ROUTES.map(one => `'${one}'`).join(",")}))`, saved: "NULL" },
+        failure_detail: { definition: detailCheck("failure_detail"), saved: "NULL" },
+    },
+});
+export const V158_TABLES = Object.freeze(["lead_quick_setting"]);
+/** The v158 migration's steps, in order (a test seam may stop after each). */
+export const V158_STEPS = Object.freeze(["lead-quick-setting", "lead-latency-columns"]);

package/dist/lead-progress.d.ts

@@ -4,10 +4,13 @@
 export type LeadProgress = {
     kind: "started";
     turn: number;
-} | {
+}
+/** `reason`: the step re-asks the model about its own reply (a repair of a claim it can't back, or a shorten). */
+ | {
     kind: "step";
     turn: number;
     step: number;
+    reason?: "repair" | "shorten";
 } | {
     kind: "tool";
     turn: number;
@@ -28,6 +31,12 @@ export type LeadProgress = {
     step: number;
     text: string;
     final?: true;
+}
+/** Text was held back because it looked like a password or key (mid-stream, or the finished reply refused): every
+ * live preview of this turn closes and clears at once (docs/plans/responsive-chat.md §2.1). */
+ | {
+    kind: "blocked";
+    turn: number;
 };
 export type LeadToolOutcome = {
     state: "succeeded";

package/dist/lead-progress.js

@@ -48,7 +48,7 @@ const TOOL_LABELS = {
 export function leadToolLabel(name) {
     if (name in TOOL_LABELS)
         return TOOL_LABELS[name];
-    return name.startsWith("propose_") ? "Preparing a card for you to confirm" : "Working";
+    return name.startsWith("propose_") ? "Preparing a card for you to confirm" : "Working on it";
 }
 /** Tool errors instruct the model how to retry. Only known, fixed copy belongs
  * in the live UI; never echo arguments, redaction placeholders or exceptions. */

package/dist/lead-queue-runtime.d.ts

@@ -28,7 +28,7 @@ export type PersonalQueueRuntimeOptions = {
     };
     /** The console's live reply display: started per turn, ended with the progress handle it returned. */
     live?: {
-        begin: (thread: number) => (event: LeadProgress) => void;
+        begin: (thread: number, asked: string) => (event: LeadProgress) => void;
         end: (thread: number, ok: boolean, progress: (event: LeadProgress) => void) => void;
     };
     subscriptionRunner?: LeadTurnInput["subscriptionRunner"];

package/dist/lead-queue-runtime.js

@@ -105,7 +105,7 @@ export function createPersonalQueueRuntime(options) {
                 onAdmitted: turn => {
                     if (!queue.bindTurn(claim, turn))
                         throw new Error("The queued message changed before admission.");
-                    progress = options.live?.begin(claim.thread);
+                    progress = options.live?.begin(claim.thread, claim.text);
                 },
                 ...(context === undefined ? {} : { context }), channel: "console", clock, evidenceRoot: options.evidenceRoot,
                 ...(options.live === undefined ? {} : { onProgress: (event) => progress?.(event) }),

package/dist/lead-route.d.ts

@@ -0,0 +1,56 @@
+import type { LeadRoute } from "./lead-latency-schema.js";
+import type { Store } from "./store.js";
+/** Words that ask for something to be done (§8's fixed list, plus a few plain synonyms). Any of them keeps a message on
+ * the main model. Matched as whole words in their plain form, the form a request takes ("fix it", "can you merge",
+ * "file a task"): "what's running?" or "is it merged?" ask about a state and stay quick. A quick step that asks to act
+ * anyway is escalated (quickStepEscalates), so this list is the first line, not the only one. */
+export declare const QUICK_ACT_WORDS: readonly string[];
+/** The longest message the quick model takes: longer ones are rarely a plain status question. */
+export declare const QUICK_MESSAGE_MAX_CHARS = 240;
+/** Whether a message reads as a status or read question with no act word (§8's message rule). */
+export declare function quickQuestion(message: string): boolean;
+/**
+ * The tools a quick reply's requests advertise: reads only. Every one is a read of saved state as this person sees it;
+ * none drafts, records a question, a promise, a memory or a card, or opens a page. `find_tools` is advertised beside them
+ * but is not one of them: it is how a quick step says it needs something else ("search before saying something can't
+ * be done"), so calling it hands the reply to the main model, unrun (more conservative than §8's "find_tools for
+ * something to change": any search escalates).
+ */
+export declare const QUICK_READ_TOOLS: ReadonlySet<string>;
+/** Whether a quick step's request advertises this tool: the reads, and find_tools as the way to ask for more. */
+export declare function quickAdvertises(name: string): boolean;
+/** The faster model, as the model catalog names it: the newest Sonnet this computer's Claude has been seen to run, else
+ * the compiled current one. Always an exact id, never an alias that could move under a recorded route. */
+export declare function quickLeadModel(store: Store): string;
+export type QuickRouteInput = {
+    /** Settings → Lead's switch. */
+    enabled: boolean;
+    provider: string;
+    /** The configured model, which a quick reply would otherwise run on. */
+    mainModel: string;
+    message: string;
+    /** Server-authored context for this turn (a task page, a crew update): present keeps the main model. */
+    hasContext: boolean;
+    /** The message replies to an image (a result's screenshot). */
+    hasReplyImage: boolean;
+    /** The thread's newest reply asked the owner a question. */
+    askOpen: boolean;
+    /** The faster model, and whether the organisation policy allows it. */
+    quickModel: string;
+    quickAllowed: boolean;
+};
+/** Which model answers: the faster one only when every condition holds. */
+export declare function quickRoute(input: QuickRouteInput): {
+    route: Extract<LeadRoute, "fast">;
+    model: string;
+} | {
+    route: Extract<LeadRoute, "default">;
+};
+/** Whether a quick step asked for anything beyond the quick reads: its calls are then discarded unrun (§8). */
+export declare function quickStepEscalates(calls: readonly {
+    name: string;
+}[]): boolean;
+/** "Sonnet 5.5" for claude-sonnet-5-5; the id itself for anything else. */
+export declare function modelName(model: string): string;
+/** The activity line's words for a routed reply: "answered by Sonnet 5.5", "moved to Opus"; nothing for the default. */
+export declare function routeWords(route: LeadRoute, quickModel: string, mainModel: string): string | null;

package/dist/lead-route.js

@@ -0,0 +1,104 @@
+/**
+ * The quick-answer router (docs/plans/responsive-chat.md §8, owner decision 7): which model answers a reply, decided
+ * before the turn, deterministically and conservatively. A reply goes to the faster model only when quick answers are
+ * on, the lead runs on the Claude membership, the organisation policy allows that model, the message carries no task
+ * or reply context, it doesn't answer the lead's own open question, and it reads as a status or read question with no
+ * act word. Everything else stays on the main model, unchanged.
+ *
+ * A quick reply is read-only by construction: its requests advertise only QUICK_READ_TOOLS (and find_tools, the way to
+ * ask for more). A quick step that asks for anything else has its calls discarded unrun, and the main model takes the reply over from that step (lead.ts).
+ */
+import { aliasTarget } from "./model-catalog.js";
+import { exactModelId } from "./phase-routing.js";
+import { SONNET } from "./model-choices.js";
+/** Words that ask for something to be done (§8's fixed list, plus a few plain synonyms). Any of them keeps a message on
+ * the main model. Matched as whole words in their plain form, the form a request takes ("fix it", "can you merge",
+ * "file a task"): "what's running?" or "is it merged?" ask about a state and stay quick. A quick step that asks to act
+ * anyway is escalated (quickStepEscalates), so this list is the first line, not the only one. */
+export const QUICK_ACT_WORDS = Object.freeze([
+    "file", "make", "create", "add", "fix", "change", "build", "plan", "approve", "confirm", "merge", "release", "ship",
+    "deploy", "cancel", "pause", "hold", "resume", "retry", "steer", "remember", "delete", "archive", "send", "run",
+    "start", "stop",
+    // Plain synonyms of the same acts.
+    "rerun", "redo", "undo", "revert", "push", "publish", "kill", "edit", "remove", "rename", "reset", "restart",
+    "install", "upgrade", "enable", "disable", "accept", "reject", "schedule", "assign", "write", "draft", "set", "move",
+    "close", "reopen", "unhold", "dismiss", "prioritize", "prioritise", "split", "revise",
+]);
+/** Openings that ask about the state of things. */
+const ASKING_OPENINGS = new Set([
+    "what", "what's", "whats", "which", "who", "who's", "whose", "why", "when", "where", "how", "how's", "is", "are", "was",
+    "were", "did", "does", "do", "has", "have", "had", "any", "anything", "show", "list", "status", "tell", "give",
+]);
+/** The longest message the quick model takes: longer ones are rarely a plain status question. */
+export const QUICK_MESSAGE_MAX_CHARS = 240;
+const words = (text) => text.toLowerCase().replace(/[’]/g, "'").split(/[^a-z0-9']+/).filter(one => one !== "");
+/** Whether a message reads as a status or read question with no act word (§8's message rule). */
+export function quickQuestion(message) {
+    const text = message.trim();
+    if (text === "" || text.length > QUICK_MESSAGE_MAX_CHARS || /[\r\n]/.test(text))
+        return false;
+    const all = words(text);
+    if (all.length === 0)
+        return false;
+    if (all.some(word => QUICK_ACT_WORDS.includes(word.replace(/'s$/, ""))))
+        return false;
+    // A negated or conditional request ("don't…", "if…, then…") is a judgement call: the main model takes it.
+    if (all.some(word => word === "don't" || word === "dont" || word === "if" || word === "please"))
+        return false;
+    return text.endsWith("?") || ASKING_OPENINGS.has(all[0]);
+}
+/**
+ * The tools a quick reply's requests advertise: reads only. Every one is a read of saved state as this person sees it;
+ * none drafts, records a question, a promise, a memory or a card, or opens a page. `find_tools` is advertised beside them
+ * but is not one of them: it is how a quick step says it needs something else ("search before saying something can't
+ * be done"), so calling it hands the reply to the main model, unrun (more conservative than §8's "find_tools for
+ * something to change": any search escalates).
+ */
+export const QUICK_READ_TOOLS = new Set([
+    "get_brief", "get_project_context", "get_code_map", "get_project_activity", "get_actions", "get_action_status", "get_skills",
+    "get_acceptance_evidence", "recap", "list_repos", "list_tasks", "get_task", "get_result", "get_result_images", "get_controls",
+    "get_agents", "get_project_knowledge", "get_flaky_tests", "get_task_conversation", "get_diff", "get_check_log",
+    "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue",
+    "get_findings", "get_subagents", "get_person", "get_integrations", "get_capabilities", "search_project_memory", "get_models", "get_sweep",
+]);
+/** Whether a quick step's request advertises this tool: the reads, and find_tools as the way to ask for more. */
+export function quickAdvertises(name) {
+    return QUICK_READ_TOOLS.has(name) || name === "find_tools";
+}
+/** The faster model, as the model catalog names it: the newest Sonnet this computer's Claude has been seen to run, else
+ * the compiled current one. Always an exact id, never an alias that could move under a recorded route. */
+export function quickLeadModel(store) {
+    const seen = aliasTarget(store, "sonnet")?.id ?? null;
+    return seen !== null && exactModelId(seen) ? seen : SONNET;
+}
+/** Which model answers: the faster one only when every condition holds. */
+export function quickRoute(input) {
+    if (!input.enabled || input.provider !== "claude-subscription" || !input.quickAllowed)
+        return { route: "default" };
+    if (input.quickModel === input.mainModel || input.hasContext || input.hasReplyImage || input.askOpen)
+        return { route: "default" };
+    return quickQuestion(input.message) ? { route: "fast", model: input.quickModel } : { route: "default" };
+}
+/** Whether a quick step asked for anything beyond the quick reads: its calls are then discarded unrun (§8). */
+export function quickStepEscalates(calls) {
+    return calls.some(call => !QUICK_READ_TOOLS.has(call.name));
+}
+/** "Sonnet 5.5" for claude-sonnet-5-5; the id itself for anything else. */
+export function modelName(model) {
+    if (model === "default")
+        return "the main model";
+    const family = /^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?/.exec(model);
+    if (family !== null)
+        return `${family[1].charAt(0).toUpperCase()}${family[1].slice(1)} ${family[2]}${family[3] === undefined ? "" : `.${family[3]}`}`;
+    if (/^(opus|sonnet|haiku|fable)$/.test(model))
+        return `${model.charAt(0).toUpperCase()}${model.slice(1)}`;
+    return model;
+}
+/** The activity line's words for a routed reply: "answered by Sonnet 5.5", "moved to Opus"; nothing for the default. */
+export function routeWords(route, quickModel, mainModel) {
+    if (route === "fast")
+        return `answered by ${modelName(quickModel)}`;
+    if (route === "escalated")
+        return `moved to ${modelName(mainModel)}`;
+    return null;
+}