toolroll 0.9.95 → 0.9.97

package/dist/live-reply.js

@@ -0,0 +1,302 @@
+/**
+ * The shared live-reply core (docs/plans/responsive-chat.md §2): one lead turn's `LeadProgress` turned into text-only
+ * views that every surface renders. Surfaces never read `LeadProgress` themselves.
+ *
+ *   queued → working (one status line) → writing (status + display-safe partial text) → closed (answered | failed | blocked)
+ *
+ * Nothing here is durable or authoritative: the saved thread message and its cards remain the record, and no view ever
+ * carries a card, a button, an ask or an approval. A partial is the reply as written so far, cut back to what is
+ * settled (never an unfinished word, code span, link or bold run), withheld while its tail could be the start of a
+ * password or key, and shaped with the final reply's own presentation policy (presentation, not redaction).
+ *
+ * `createLiveSender` is the one sender per live surface message (§2.4): at most one request in flight, one pending
+ * slot holding only the newest view, a generation that only grows, and `close()` — after which nothing more is sent,
+ * and which resolves only once the request in flight has settled, so durable delivery can start strictly after it.
+ */
+import { scanForSecrets } from "./evidence.js";
+import { shapeReply, shapeReplyPrefix } from "./reply-shape.js";
+/** The status line's fixed words (§2.3). A running tool reads as its own label plus "…". */
+export const LIVE_STATUS = {
+    queued: "Waiting for your earlier messages…",
+    thinking: "Thinking…",
+    writing: "Writing…",
+    repair: "Fixing the reply…",
+    shorten: "Shortening the reply…",
+    /** A preview closed because text looked like a password or key; the turn itself may still answer. */
+    held: "Working on it…",
+};
+/** One token that could still grow into a match of a secret family: a non-empty prefix of one of its openings, or the
+ * whole opening followed by its body characters. Preceded by a non-word character or the start, as the detectors'
+ * own word boundaries are. */
+function opening(leads, body) {
+    const escape = (text) => text.replace(/[.*+?^${}()|[\]\\/-]/g, "\\$&");
+    const alternatives = new Set();
+    for (const lead of leads) {
+        for (let length = 1; length < lead.length; length += 1)
+            alternatives.add(escape(lead.slice(0, length)));
+        alternatives.add(`${escape(lead)}${body}*`);
+    }
+    return `(?:${[...alternatives].join("|")})`;
+}
+/**
+ * The start of every `SECRET_PATTERNS` family (evidence.ts), checked against the end of the text written so far:
+ * while any matches, the partial is withheld. Single-token families look at the unfinished last token; the families
+ * whose match spans spaces (a private-key header, an npm `_authToken = value`) look at the whole last line.
+ */
+const SECRET_STARTS = [
+    // private-key: "-----BEGIN RSA PRIVATE KEY-----", partway. No start boundary: the complete detector has none either.
+    /-{1,5}(?:B(?:E(?:G(?:I(?:N(?:[ \t][A-Z \t]*-{0,5})?)?)?)?)?)?$/,
+    // npm-auth-token: "_authToken = value", partway.
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9])${opening(["_authToken"], String.raw `[\s=]`)}\S*$`),
+    // aws-access-key, github-token, slack-token, openai-key, stripe-key, google-api-key, gitlab-token.
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["AKIA", "ASIA"], "[0-9A-Z]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["ghp_", "gho_", "ghu_", "ghs_", "ghr_", "github_pat_"], "[A-Za-z0-9_]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["xoxb-", "xoxa-", "xoxp-", "xoxr-", "xoxs-"], "[A-Za-z0-9-]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["sk-"], "[A-Za-z0-9_-]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["sk_live_", "sk_test_", "rk_live_", "rk_test_", "whsec_"], "[A-Za-z0-9]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["AIza"], "[0-9A-Za-z_-]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["glpat-"], "[A-Za-z0-9_-]")}$`),
+    // telegram-bot-token: "123456789:AA…".
+    /(?:^|[^A-Za-z0-9_])\d+(?::(?:A(?:A[A-Za-z0-9_-]*)?)?)?$/,
+    // discord-bot-token: "M…24.…6.…27".
+    /(?:^|[^A-Za-z0-9_])[MN][A-Za-z\d]*(?:\.[\w-]*(?:\.[\w-]*)?)?$/,
+    // password-in-url: "scheme://user:password@host", partway (a scheme and its colon are enough to wait).
+    /(?:^|[^A-Za-z0-9+.-])[a-z][a-z0-9+.-]*:\S*$/i,
+];
+/** Could the end of this text be the start of a password or key? Then nothing of it shows yet. */
+export function secretMayStart(text) {
+    const lastLine = text.replace(/\r\n?/g, "\n").split("\n").at(-1) ?? "";
+    return SECRET_STARTS.some(pattern => pattern.test(lastLine));
+}
+/**
+ * What of a reply still being written is settled: everything before its last whitespace (the unfinished last word
+ * stays out), then cut back before any code fence, code span, bold run or link that hasn't closed yet. Trailing
+ * whitespace is trimmed.
+ */
+export function settledText(raw) {
+    const text = raw.replace(/\r\n?/g, "\n");
+    let end = text.length;
+    while (end > 0 && !/\s/.test(text[end - 1]))
+        end -= 1;
+    const shown = text.slice(0, end);
+    let fence = -1, code = -1, bold = -1, link = -1;
+    let linkState = null;
+    for (let index = 0; index < shown.length; index += 1) {
+        if (shown.startsWith("```", index)) {
+            fence = fence === -1 ? index : -1;
+            index += 2;
+            continue;
+        }
+        if (fence !== -1)
+            continue;
+        const char = shown[index];
+        if (char === "\n") {
+            code = -1;
+            bold = -1;
+            link = -1;
+            linkState = null;
+            continue;
+        }
+        if (char === "`") {
+            code = code === -1 ? index : -1;
+            continue;
+        }
+        if (code !== -1)
+            continue;
+        if (shown.startsWith("**", index)) {
+            bold = bold === -1 ? index : -1;
+            index += 1;
+            continue;
+        }
+        if (char === "[" && linkState === null) {
+            link = index;
+            linkState = "label";
+            continue;
+        }
+        if (linkState === "label" && char === "]") {
+            if (shown[index + 1] === "(") {
+                linkState = "url";
+                index += 1;
+            }
+            else {
+                link = -1;
+                linkState = null;
+            }
+            continue;
+        }
+        if (linkState === "url" && (char === ")" || /\s/.test(char))) {
+            link = -1;
+            linkState = null;
+        }
+    }
+    const cut = Math.min(...[fence, code, bold, link].filter(at => at !== -1), shown.length);
+    return shown.slice(0, cut).trimEnd();
+}
+/**
+ * A partial as it may be shown: `blocked` when it holds a password or key (the preview closes), `withheld` while its
+ * tail could still become one (show nothing new), else the settled text shaped for display. A step's finished text
+ * (`final`, secret-checked whole by the engine) shows whole.
+ */
+export function partialDisplay(raw, final, shape = {}) {
+    if (scanForSecrets(raw).length > 0)
+        return { kind: "blocked" };
+    if (!final && secretMayStart(raw))
+        return { kind: "withheld" };
+    const text = final ? shapeReply(raw, shape) : shapeReplyPrefix(settledText(raw), shape);
+    // Shaping only relabels and removes; a secret in what it returns would mean it came from somewhere else. Never shown.
+    if (scanForSecrets(text).length > 0)
+        return { kind: "blocked" };
+    return { kind: "shown", text };
+}
+/** One turn's live reply. `shape`: the owner's message (`asked`) and this app's origins, as the final reply is shaped. */
+export function createLiveReply(shape = {}, options = {}) {
+    const steps = [];
+    let queued = options.queued === true;
+    let closed = null;
+    let turn = null;
+    let last = "";
+    const current = () => steps.at(-1) ?? (steps.push({ calls: [], raw: "", shown: "" }), steps.at(-1));
+    const status = () => {
+        const step = steps.at(-1);
+        const running = step?.calls.filter(call => call.state === "running").at(-1);
+        if (running !== undefined)
+            return `${running.label}…`;
+        if (step?.reason !== undefined)
+            return LIVE_STATUS[step.reason];
+        if (closed === "blocked")
+            return LIVE_STATUS.held;
+        if (step !== undefined && step.raw.trim() !== "")
+            return LIVE_STATUS.writing;
+        return LIVE_STATUS.thinking;
+    };
+    const view = () => {
+        if (closed !== null)
+            return { phase: "closed", why: closed };
+        if (queued && steps.length === 0)
+            return { phase: "queued" };
+        const text = [...steps].reverse().find(step => step.shown !== "")?.shown ?? "";
+        return text === "" ? { phase: "working", status: status() } : { phase: "writing", status: status(), text };
+    };
+    const changed = () => {
+        const now = JSON.stringify(view());
+        if (now === last)
+            return false;
+        last = now;
+        return true;
+    };
+    last = JSON.stringify(view());
+    return {
+        get turn() { return turn; },
+        push(event) {
+            if (closed !== null)
+                return false;
+            turn ??= event.turn;
+            queued = false;
+            switch (event.kind) {
+                case "started": break;
+                case "step":
+                    steps.push({ calls: [], raw: "", shown: "", ...(event.reason === undefined ? {} : { reason: event.reason }) });
+                    break;
+                case "tool":
+                    current().calls.push({ id: event.id, label: event.label, state: "running" });
+                    break;
+                case "tool-result":
+                    for (const step of steps) {
+                        const index = step.calls.findIndex(call => call.id === event.id);
+                        if (index !== -1) {
+                            step.calls[index] = { id: event.id, label: step.calls[index].label, ...event.outcome };
+                            break;
+                        }
+                    }
+                    break;
+                case "text": {
+                    const step = current();
+                    step.raw = event.text;
+                    const shown = partialDisplay(event.text, event.final === true, shape);
+                    if (shown.kind === "blocked") {
+                        closed = "blocked";
+                        for (const one of steps)
+                            one.shown = "";
+                    }
+                    else if (shown.kind === "shown")
+                        step.shown = shown.text;
+                    break;
+                }
+                case "blocked":
+                    closed = "blocked";
+                    for (const one of steps)
+                        one.shown = "";
+                    break;
+            }
+            return changed();
+        },
+        close(why) {
+            if (closed === null)
+                closed = why;
+            for (const one of steps)
+                one.shown = "";
+            changed();
+        },
+        view,
+        status,
+        tools: () => steps.map(step => step.calls.map(call => ({ ...call }))),
+    };
+}
+/**
+ * The serialized sender for one live surface message (§2.4). `standing` re-proves the viewer's right to see this turn
+ * before every send (it may await; the close is re-checked after it). `spacingMs` is the least time between two sends,
+ * read before each one (a surface widens it after the platform asks for a pause). A failed send drops that view:
+ * previews are best effort.
+ */
+export function createLiveSender(options) {
+    const spacing = () => typeof options.spacingMs === "function" ? options.spacingMs() : options.spacingMs ?? 0;
+    const now = options.now ?? Date.now;
+    let generation = 0;
+    let closed = false;
+    let pending = null;
+    let inflight = null;
+    let timer = null;
+    let lastSent = Number.NEGATIVE_INFINITY;
+    const pump = () => {
+        if (closed || inflight !== null || timer !== null || pending === null)
+            return;
+        const wait = lastSent + spacing() - now();
+        if (wait > 0) {
+            timer = setTimeout(() => { timer = null; pump(); }, wait);
+            timer.unref?.();
+            return;
+        }
+        const next = pending;
+        pending = null;
+        inflight = (async () => {
+            try {
+                if (options.standing !== undefined && !(await options.standing()))
+                    return;
+                if (closed)
+                    return;
+                lastSent = now();
+                await options.send(next.view, next.generation);
+            }
+            catch { /* best effort: this view is dropped */ }
+        })().finally(() => { inflight = null; pump(); });
+    };
+    return {
+        get generation() { return generation; },
+        get closed() { return closed; },
+        offer(view) {
+            if (closed)
+                return;
+            generation += 1;
+            pending = { view, generation };
+            pump();
+        },
+        async close() {
+            closed = true;
+            pending = null;
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = null;
+            await inflight;
+        },
+    };
+}

package/dist/operate.js

@@ -9,6 +9,7 @@ import { adapterPolicy } from "./server/route-policy.js";
 import { UNSENT_REPLY_MS } from "./telegram-settings.js";
 import { checkPublicCommand } from "./public-check.js";
 import { leadNameOf } from "./lead-identity.js";
+import { modelName, quickLeadModel } from "./lead-route.js";
 import { maybeTriggerRepair } from "./dispose.js";
 import { CHECK_LEVEL_HINTS, CHECK_LEVEL_WORDS, isCheckLevel, liveQuickCommand, projectCheckLevel, quickVerifyKey, setProjectCheckLevel, setTaskCheckLevel, suggestQuickCommand } from "./check-levels.js";
 import { fileAddTestsTask, requestFollowUpChecks, runFollowUpCheck, runWaitingChecks } from "./result-follow-ups.js";
@@ -122,7 +123,7 @@ import { homedir, hostname } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { releaseStalledUpdate, waitingUpdate } from "./toolroll-update.js";
 import { dur } from "./design/kit.js";
-import { checkoutIdle, setCheckoutIdle, openStore, openStoreNoMigrate, initLocalMode, enrollOwnerPassword, installationCreatedBy, laptopPortOf, recordLaptopPort, localModeOf, localOwnerBinding, archiveTaskFamily, restoreTaskFamily, shipChecksForTask, elapsedSeconds, CONCURRENT_WRITER_WAIT_MS, isDatabaseBusy, databasePath, BUILT_IN, parseCapabilityKey, verifiedAuthor, isDigestTime, predecessorWatches, RESULT_SCREENSHOTS, lifecycleOf, reportLifecycle, beatLifecycle, } from "./store.js";
+import { checkoutIdle, setCheckoutIdle, leadQuickAnswersOn, setLeadQuickAnswers, openStore, openStoreNoMigrate, initLocalMode, enrollOwnerPassword, installationCreatedBy, laptopPortOf, recordLaptopPort, localModeOf, localOwnerBinding, archiveTaskFamily, restoreTaskFamily, shipChecksForTask, elapsedSeconds, CONCURRENT_WRITER_WAIT_MS, isDatabaseBusy, databasePath, BUILT_IN, parseCapabilityKey, verifiedAuthor, isDigestTime, predecessorWatches, RESULT_SCREENSHOTS, lifecycleOf, reportLifecycle, beatLifecycle, } from "./store.js";
 import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import { claimInstance, clearInstance, openInstanceSocket } from "./console-instance.js";
 import { backgroundOff, backgroundOn, backgroundShow, laptopStatus, laptopStop, restartOwnBuilder } from "./laptop-background.js";
@@ -208,6 +209,7 @@ import { scanRepo } from "./capscan.js";
 import { computeGaps, describeCapability } from "./gaps.js";
 import { ask as promptAsk, askHidden as promptHidden, confirm as promptConfirm, interactive as promptInteractive, underAgent } from "./prompt.js";
 import { runLeadCli, answerContextLines } from "./lead-cli.js";
+import { liveTerminalWanted, processTerminal } from "./lead-cli-live.js";
 import { confirmCoordinatorProposal, dismissCoordinatorProposal } from "./lead-doors.js";
 import { verifyApproverByPassword as approverByPassword } from "./principal.js";
 import { activeRemote, REMOTE_MESSAGES, REMOTE_REFUSED_FLAGS, REMOTE_SCOPES, RemoteRefusal, remoteAllows, remoteLensOf, remoteProjectOf, remoteRowOf, remoteSecret, reproveRemote, withRemote } from "./operate-remote.js";
@@ -598,6 +600,9 @@ Agents — which provider and model each phase runs on
       [--model <m>] [--weekly-usd <n>] [--daily-turns <n>] --as <you> --token <t>
       membership providers reuse a logged-in local harness with no dollar
       maximum; direct API providers require a key and weekly dollar ceiling
+  toolroll config set|clear|show quick-answers --as <you> --token <t>
+      quick answers on (set) or off (clear): plain status questions go to a
+      faster model on the Claude membership; changes stay on the main model
   toolroll chat --as <you> [--repo <path>…] [--say "…"] [--end]
       [--ceiling-usd <n>] [--json]                 (password at the prompt;
       --token <t> only for scripts — it lands in shell history)
@@ -5101,6 +5106,9 @@ async function configCommand(positional, flags, context) {
         return fail(write, json, "config", "usage", `unknown \`config ${action}\` — try ${CONFIG_ACTIONS.join(", ")}`, EXIT.usage);
     const repoGiven = text(flags, "repo");
     const scope = repoGiven === undefined ? INSTALLATION_SCOPE : canonicalProject(repoGiven) ?? resolve(repoGiven);
+    // Settings → Lead's "Quick answers use a faster model", the same switch (responsive-chat.md §8).
+    if (phase === "quick-answers")
+        return quickAnswersConfig(action ?? "show", repoGiven !== undefined, flags, context);
     if (action === undefined || action === "show") {
         const installation = store.listPhaseConfig(INSTALLATION_SCOPE);
         const project = scope === INSTALLATION_SCOPE ? [] : store.listPhaseConfig(scope);
@@ -10671,6 +10679,8 @@ async function chatCommand(flags, context) {
         ...(context.evidenceRoot === undefined ? {} : { evidenceRoot: context.evidenceRoot }),
         // The console's own address (and its public one): links there read as "the task", "the result", "Settings → Lead".
         appOrigin: [loadConsoleUrl(process.env, dirname(context.databaseFile)), phoneOrigin(process.env, dirname(context.databaseFile))],
+        // A live status line and the answer as it is written, on a real terminal only (tests drive runLeadCli directly).
+        ...(context.leadSeams === undefined && liveTerminalWanted(json, process.env, process.stdout.isTTY === true, () => underAgent(process.env)) ? { liveTerminal: processTerminal() } : {}),
     });
     return result.code;
 }
@@ -14087,3 +14097,31 @@ async function projectFallbackCommand(positional, flags, context) {
         return fail(context.write, context.json, command, "refused", done.problem, EXIT.refused);
     return succeed(context.write, context.json, command, shown(), () => [...words(), "Tasks scoped from now on use this; tasks already approved keep the chain they were approved with."]);
 }
+/** `toolroll config set|clear|show quick-answers`: Settings → Lead's quick-answer switch (responsive-chat.md §8). On
+ * or off is installation-wide, so changing it takes an instance operator's password, as the web page's route does. */
+async function quickAnswersConfig(action, repoGiven, flags, context) {
+    const { store, write, json, clock } = context;
+    const command = `config ${action}`;
+    if (repoGiven)
+        return fail(write, json, command, "usage", "quick answers are installation-wide: no --repo", EXIT.usage);
+    const said = () => {
+        const on = leadQuickAnswersOn(store);
+        const model = quickLeadModel(store);
+        return { payload: { quickAnswers: { on, model } }, lines: () => [on
+                    ? `Quick answers are on: plain status questions are answered by ${modelName(model)}; anything that asks for a change stays on the lead's main model.`
+                    : "Quick answers are off: the lead's main model answers everything."] };
+    };
+    if (action === "show") {
+        const shown = said();
+        return succeed(write, json, command, shown.payload, shown.lines);
+    }
+    const acting = await askCredentials(flags, context);
+    if (acting === null)
+        return fail(write, json, command, "usage", "changing quick answers takes `--as <you> --token <t>`", EXIT.usage);
+    const verified = authenticateApprover(store, acting.name, acting.token);
+    if (!verified.ok || !store.isInstanceOperator(acting.name))
+        return fail(write, json, command, "unauthenticated", "an instance operator changes quick answers, with their password", EXIT.refused);
+    setLeadQuickAnswers(store, action === "set", acting.name, clock());
+    const shown = said();
+    return succeed(write, json, command, shown.payload, shown.lines);
+}

package/dist/project-knowledge.d.ts

@@ -22,7 +22,6 @@ export type KnowledgeView = ReturnType<typeof knowledgeView>;
 export declare function knowledgeVersion(store: Store, repo: string, actor: string, revision: number): Knowledge;
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
-    references?: never;
     revision: number;
     stale: boolean;
     notice: string;
@@ -30,10 +29,10 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     content?: never;
     history?: never;
     instructions?: never;
+    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
-    references?: never;
     stale?: never;
     decision: {
         repo: string;
@@ -56,10 +55,10 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     revision?: never;
     history?: never;
     instructions?: never;
+    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
-    references?: never;
     stale?: never;
     revision: number;
     title: string;
@@ -67,6 +66,7 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     notice: string;
     history?: never;
     instructions?: never;
+    references?: never;
     decisions?: never;
     waiting?: never;
 } | {

package/dist/reply-shape.d.ts

@@ -35,6 +35,15 @@ export declare function linkLabel(url: string, appOrigin?: ShapeOptions["appOrig
  * changes nothing.
  */
 export declare function shapeReply(text: string, options?: ShapeOptions): string;
+/**
+ * A reply still being written, shaped with the final reply's presentation policy (docs/plans/responsive-chat.md §2.2),
+ * except that ids are dropped unless the owner asked for them: whether a reply names several of a kind isn't known
+ * until it ends, so a prefix never keeps them on that ground. Presentation, not redaction.
+ */
+export declare function shapeReplyPrefix(text: string, options?: ShapeOptions): string;
+/** The first window of a shaped text of at most `size` characters, cut where a part would be (never inside code, a link,
+ * a bold anchor or an emoji's two halves). A single link longer than the window stays whole, so the caller measures. */
+export declare function shapedWindow(shaped: string, size: number): string;
 /**
  * A long reply split into parts of at most `size` characters, then each part shaped: the cut is made on the reply as
  * written, at a paragraph or line where possible and never inside code, a link or a bold anchor, so no part carries

package/dist/reply-shape.js

@@ -199,6 +199,14 @@ function shapeWith(text, options, state) {
 export function shapeReply(text, options = {}) {
     return shapeWith(text, options, stateFor(text, options));
 }
+/**
+ * A reply still being written, shaped with the final reply's presentation policy (docs/plans/responsive-chat.md §2.2),
+ * except that ids are dropped unless the owner asked for them: whether a reply names several of a kind isn't known
+ * until it ends, so a prefix never keeps them on that ground. Presentation, not redaction.
+ */
+export function shapeReplyPrefix(text, options = {}) {
+    return shapeWith(text, options, { boldLeft: BOLD_ANCHORS, keepIds: askedForIds(options.asked) ? "all" : new Set() });
+}
 /** Where a long reply may be cut: never inside code, a link, a URL or a bold anchor; best at a paragraph, then a line,
  * then a space. Always past `from`, and never between the two halves of an emoji. */
 function cutAt(text, from, size) {
@@ -231,6 +239,11 @@ function cutAt(text, from, size) {
         end = end - 1 > from ? end - 1 : end + 1;
     return end;
 }
+/** The first window of a shaped text of at most `size` characters, cut where a part would be (never inside code, a link,
+ * a bold anchor or an emoji's two halves). A single link longer than the window stays whole, so the caller measures. */
+export function shapedWindow(shaped, size) {
+    return shaped.slice(0, cutAt(shaped, 0, size));
+}
 /**
  * A long reply split into parts of at most `size` characters, then each part shaped: the cut is made on the reply as
  * written, at a paragraph or line where possible and never inside code, a link or a bold anchor, so no part carries

package/dist/serve.js

@@ -121,7 +121,7 @@ import { findFirstTasks, firstRunSteps, signInCommandFor } from "./first-run.js"
 import { installMethod } from "./install-method.js";
 import { createIntegrationMonitor } from "./integrations.js";
 import { logEvent } from "./log.js";
-import { LEAD_MESSAGE_MAX_CHARS } from "./lead.js";
+import { LEAD_MESSAGE_MAX_CHARS, leadFailureText } from "./lead.js";
 import {} from "./model-catalog.js";
 import { modeTermsFromJson } from "./modes.js";
 import { envValue } from "./names.js";
@@ -171,7 +171,7 @@ import { createBrowserKeys, KEY_FILL_SCRIPT, pagePathOf } from './server/mutatio
 import { DEFAULT_GUARD_POLICY, passwordGuardOf, provenPasswordAccount, SourceBudget, withPasswordSource } from "./sign-in-guard.js";
 import { sourceKey } from "./source-key.js";
 import { readSsoSettings } from "./sso-settings.js";
-import { LEAD_THREAD, localOwnerBinding } from "./store.js";
+import { LEAD_THREAD, latestLeadTurnOfThread, localOwnerBinding } from "./store.js";
 import { waitingUpdate } from "./toolroll-update.js";
 import { PACKAGE_VERSION } from "./version.js";
 import { loadConsoleUrl } from "./webhooks.js";
@@ -629,7 +629,8 @@ export function createDecisionServer(options) {
             return run !== null && family.versions.some(one => one.refId === run.taskRef);
         }),
         names: { project: projectName, modes: TASK_COMPOSER_MODES },
-        live: { begin: thread => chatHandlers.beginLiveTurn(thread), end: (thread, ok, progress) => chatHandlers.endLiveTurn(thread, ok, progress) },
+        // A queued message's partials are shaped as its final reply will be: for its words, with this console's own addresses.
+        live: { begin: (thread, asked) => chatHandlers.beginLiveTurn(thread, { asked, appOrigin: [publicOrigin?.origin ?? null, options.configDir === undefined ? null : loadConsoleUrl(process.env, options.configDir)] }), end: (thread, ok, progress) => chatHandlers.endLiveTurn(thread, ok, progress) },
         ...(options.chatFetcher ? { fetcher: options.chatFetcher } : {}),
         ...(options.subscriptionChatRunner ? { subscriptionRunner: options.subscriptionChatRunner } : {}),
     });
@@ -1326,7 +1327,13 @@ export function createDecisionServer(options) {
         const replaced = thread !== null ? store.replacedLeadThread(thread)
             : found !== null && found.scope.kind === "lead" && store.listLeadMessages(found.id, 1).length > 0 ? found : null;
         const previousProposals = replaced === null ? [] : store.listLeadProposals(replaced.id);
+        // How this thread's last reply ended, read from its saved turn (never process memory, which a restart loses): a
+        // failed turn that saved no message of its own says why in the thread, until the next reply starts.
+        const lastTurn = thread === null ? null : latestLeadTurnOfThread(store, thread.id);
+        const failure = lastTurn !== null && lastTurn.state === "failed" && !messages.some(one => one.role === "assistant" && one.turn === lastTurn.id)
+            ? leadFailureText(lastTurn.failureReason, store.leadTurnCostUnconfirmed(lastTurn.id), lastTurn.failureDetail ?? null) : null;
         return {
+            failure,
             previous: replaced === null ? null : { messages: store.listLeadMessages(replaced.id, 40), proposals: previousProposals, decisions: decisionsFor(store, previousProposals) },
             messages,
             ask,
@@ -1369,7 +1376,7 @@ export function createDecisionServer(options) {
             sessionId: session?.id ?? NOT_STARTED_SESSION, user: session?.approver ?? who.name, version: leadChatVersion({ ...rows, focusTask }),
             messages: leadBrowserMessages(rows, back, { task: focusTask?.id ?? null, project: chatProject }),
             pendingTurnId: rows.pending?.id ?? null, requestId: randomBytes(16).toString("hex"), maxChars: LEAD_MESSAGE_MAX_CHARS,
-            taskId: focusTask?.id ?? null, resultRunId, project: focusTask === null ? chatProject : null,
+            taskId: focusTask?.id ?? null, resultRunId, project: focusTask === null ? chatProject : null, failure: rows.pending === null ? rows.failure : null,
         };
     }
     /** The session-layer principal (ruling 3): cookie, csrf, and role were

package/dist/server/chat.d.ts

@@ -3,6 +3,7 @@ import { type DemoResultView } from "../demo-chat.js";
 import type { DemoExchange } from "../demo.js";
 import { type FirstTaskSuggestion } from "../first-run.js";
 import type { LeadProgress } from "../lead-progress.js";
+import type { ShapeOptions } from "../reply-shape.js";
 import type { DirectChatProviderId } from "../store.js";
 import type { ServerRuntime } from './runtime.js';
 import { type ChatEnablement } from "./render-chat.js";
@@ -14,7 +15,7 @@ export declare function createChatHandlers(runtime: ServerRuntime): {
         via: "cookie";
     }, now: Date) => BrowserPhoneCard | undefined;
     chatProjectOf: (values: string[]) => string | null | undefined;
-    beginLiveTurn: (thread: number) => (event: LeadProgress) => void;
+    beginLiveTurn: (thread: number, shape?: ShapeOptions) => (event: LeadProgress) => void;
     endLiveTurn: (thread: number, ok: boolean, progress?: (event: LeadProgress) => void) => void;
     noteLead: (csrf: string, turn: number | null, message: string) => void;
     takeLeadNote: (csrf: string, liveSession: number | null) => string | null;

package/dist/server/chat.js

@@ -23,6 +23,7 @@ import { configureLeadFollow, leadFollowStatus } from '../lead-follow.js';
 import { leadActivity } from "../lead-voice.js";
 import { limitsView } from "../limits-ui.js";
 import { confirmCoordinatorProposal, confirmLeadProposal, dismissCoordinatorProposal, dismissLeadProposal } from "../lead-doors.js";
+import { createLiveReply } from "../live-reply.js";
 import { LEAD_MESSAGE_MAX_CHARS, runLeadTurn } from "../lead.js";
 import { livePin, modelOptions } from "../model-catalog.js";
 import { verifyApproverByPassword, verifyApproverStanding } from "../principal.js";
@@ -991,20 +992,24 @@ export function createChatHandlers(runtime) {
             // The live display starts once this message holds a turn: a refusal (a secret, a turn still running) never blanks
             // the display of a reply that is still running in the same conversation.
             let onProgress;
+            // Partials are shaped as the final reply is: for this message, with this console's own addresses.
+            const liveShape = { asked: message, appOrigin: requestContext.getStore()?.appOrigins ?? null };
             const ended = (ok) => { if (onProgress !== undefined)
                 endLiveTurn(opened.thread.id, ok, onProgress); };
             // Detached work never carries this request's browser session (Passwordless reads it): it runs with no session facts.
             void freshFacts.run(null, () => runLeadTurn({ store, who: principal, session: leadSession, thread: opened.thread, config: enabled.config, key: enabled.key, message,
-                onAdmitted: () => { onProgress = beginLiveTurn(opened.thread.id); }, onProgress: event => onProgress?.(event), channel: "console", requestId, ...(focusTask === null && chatProject !== null ? { context: `Current project: ${projectName(chatProject)} (${chatProject}). Keep this conversation about that project unless the operator explicitly asks to broaden it; use it as the repo for project tools.` } : {}), ...(focusTask === null ? {} : { context: `Current task: ${focusTask.id}. Read it with get_task before answering or proposing changes. Read its currentExecution next and bind new actions to that exact execution. Never replace the target of a prior proposal with a newer revision. Keep this turn about that task unless the operator explicitly asks to broaden it.${resultContext}${modeContext}` }), fetcher: chatFetcher, ...(options.subscriptionChatRunner === undefined ? {} : { subscriptionRunner: options.subscriptionChatRunner }), clock, evidenceRoot }))
+                onAdmitted: () => { onProgress = beginLiveTurn(opened.thread.id, liveShape); }, onProgress: event => onProgress?.(event), channel: "console", requestId, ...(focusTask === null && chatProject !== null ? { context: `Current project: ${projectName(chatProject)} (${chatProject}). Keep this conversation about that project unless the operator explicitly asks to broaden it; use it as the repo for project tools.` } : {}), ...(focusTask === null ? {} : { context: `Current task: ${focusTask.id}. Read it with get_task before answering or proposing changes. Read its currentExecution next and bind new actions to that exact execution. Never replace the target of a prior proposal with a newer revision. Keep this turn about that task unless the operator explicitly asks to broaden it.${resultContext}${modeContext}` }), fetcher: chatFetcher, ...(options.subscriptionChatRunner === undefined ? {} : { subscriptionRunner: options.subscriptionChatRunner }), clock, evidenceRoot }))
                 .then(outcome => {
                 // Lost a race to another turn of this person's between deciding and admission: it waits instead of being refused.
                 if (!outcome.ok && "refused" in outcome && (outcome.refused === "concurrent" || outcome.refused === "backlog") && queueIt().kind === "queued") {
                     ended(false);
                     return;
                 }
-                // A turn that saved its outcome in the thread (one stopped at its deadline) is said there, once.
-                if (!outcome.ok && !("saved" in outcome && outcome.saved === true))
-                    noteLead(who.session.csrf, "turn" in outcome ? outcome.turn : null, outcome.message);
+                // A turn that saved its outcome in the thread (one stopped at its deadline) is said there, once. Any other turn
+                // that ended failed is said from its saved row (leadConversationRows `failure`), which a restart keeps; only a
+                // refusal before any turn existed is said from memory.
+                if (!outcome.ok && !("saved" in outcome && outcome.saved === true) && !("turn" in outcome))
+                    noteLead(who.session.csrf, null, outcome.message);
                 ended(outcome.ok);
             })
                 .catch(() => { noteLead(who.session.csrf, null, "the turn failed unexpectedly"); ended(false); })
@@ -1208,11 +1213,11 @@ export function createChatHandlers(runtime) {
     /** Which live display each progress handle started: ending a turn ends only its own display (a turn stopped from
      * another window that settles late can never end the next turn's). */
     const progressOf = new WeakMap();
-    function beginLiveTurn(thread) {
+    function beginLiveTurn(thread, shape = {}) {
         const previous = liveTurns.get(thread);
         if (previous?.expiry)
             clearTimeout(previous.expiry);
-        const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set(), startedAt: clock().getTime(), stepAt: [] };
+        const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set(), startedAt: clock().getTime(), stepAt: [], reply: createLiveReply(shape) };
         liveTurns.set(thread, live);
         // A page that has this conversation open follows the reply (GET /live, its chat room).
         runtime.liveTurnStarted(thread);
@@ -1222,6 +1227,7 @@ export function createChatHandlers(runtime) {
             if (live.done)
                 return;
             live.turn ??= event.turn;
+            live.reply?.push(event);
             if (event.kind === "step")
                 newStep();
             else if (event.kind === "tool") {
@@ -1241,6 +1247,11 @@ export function createChatHandlers(runtime) {
                 current().text = event.text;
                 (live.confirmed ??= [])[live.steps.length - 1] = event.final === true;
             }
+            else if (event.kind === "blocked") {
+                // Held back as a possible password or key: no step keeps its words (the Live grid's tile reads these too).
+                for (const step of live.steps)
+                    step.text = "";
+            }
             for (const listener of live.listeners)
                 listener();
         };
@@ -1255,6 +1266,7 @@ export function createChatHandlers(runtime) {
             return;
         live.done = true;
         live.ok = ok;
+        live.reply?.close(ok ? "answered" : "failed");
         live.endedAt = clock().getTime();
         for (const listener of live.listeners)
             listener();