toolroll 0.9.96 → 0.9.97

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();

package/dist/server/live.js

@@ -4,6 +4,7 @@ import { agentRunFingerprint } from "../agents-board.js";
 import { createLiveRooms, LiveConnection } from "../live-bus.js";
 import { reproveRemote } from "../operate-remote.js";
 import { rowVisible } from "../project.js";
+import { createLiveSender, LIVE_STATUS } from "../live-reply.js";
 import { TEAM_PASSWORD_REVERIFY_MS } from "../team-http.js";
 import { handlersOf } from "./handler-registry.js";
 import { respond } from "./http.js";
@@ -18,6 +19,11 @@ const ROOM_NAME = /^(workspace|task|flow|chat|team|agent|summary|agents-live)(?:
 const WORKSPACE_SETTLE_MS = 1_000;
 /** A running reply's preview: at most one snapshot every 80 ms; the last one always goes out. */
 const TURN_SETTLE_MS = 80;
+function chatSnapshot(turn) {
+    const view = turn.reply?.view() ?? { phase: "working", status: LIVE_STATUS.thinking };
+    const steps = (turn.reply?.tools() ?? []).map(calls => ({ tools: calls.map(call => call.label), toolCalls: calls }));
+    return { steps, phase: view.phase, status: turn.done ? "" : turn.reply?.status() ?? LIVE_STATUS.thinking, text: view.phase === "writing" ? view.text : "", done: turn.done, ok: turn.ok };
+}
 /** A room's name, read strictly: anything else is not a room. */
 export function parseLiveRoom(name) {
     const match = ROOM_NAME.exec(name);
@@ -114,39 +120,30 @@ export function createLiveHandlers(runtime, live) {
         }
         return valid;
     }
-    /** A running reply for one viewer's thread: snapshots while it runs, then the last one. */
+    /** A running reply for one viewer's thread: snapshots while it runs, then the last one. Every snapshot goes through
+     * one serialized sender (live-reply.ts): one in flight, the newest waiting, standing re-proved before each, and the
+     * last one only after the sender has closed, so no preview lands after it. */
     function follow(viewer, thread) {
         if (!admitted(viewer, thread))
             return;
         const turn = liveTurns.get(thread);
         if (turn === undefined || turn.done || viewer.detach !== null)
             return;
-        let queued = null;
-        const snapshot = () => {
-            if (admitted(viewer, thread))
-                viewer.connection.send(viewer.room, "turn", { steps: turn.steps, done: turn.done, ok: turn.ok });
-        };
-        const flush = () => {
-            queued = null;
-            snapshot();
-            if (turn.done)
-                stop();
-        };
+        const send = (payload) => { viewer.connection.send(viewer.room, "turn", payload); };
+        const sender = createLiveSender({ send, standing: () => admitted(viewer, thread), spacingMs: TURN_SETTLE_MS });
         const listener = () => {
-            if (turn.done) {
-                if (queued !== null)
-                    clearTimeout(queued);
-                flush();
+            if (!turn.done) {
+                sender.offer(chatSnapshot(turn));
                 return;
             }
-            if (queued === null)
-                queued = setTimeout(flush, TURN_SETTLE_MS);
+            stop();
+            void sender.close().then(() => { if (admitted(viewer, thread))
+                send(chatSnapshot(turn)); });
         };
-        const stop = () => { if (queued !== null)
-            clearTimeout(queued); turn.listeners.delete(listener); viewer.detach = null; };
+        const stop = () => { turn.listeners.delete(listener); viewer.detach = null; void sender.close(); };
         turn.listeners.add(listener);
         viewer.detach = stop;
-        snapshot();
+        sender.offer(chatSnapshot(turn));
     }
     /** A reply starts on a thread: whoever has that conversation open follows it. */
     function turnStarted(thread) {

package/dist/server/render-chat.d.ts

@@ -300,6 +300,8 @@ export declare function replacedBrowserMessages(previous: ReplacedThread): impor
 /** The replaced thread for the server-rendered page: read only, then the divider. */
 export declare function replacedThreadHtml(previous: ReplacedThread | null | undefined): Html;
 export type LeadThreadRows = {
+    /** How the thread's last reply failed, from its saved turn (no message of its own); null otherwise. */
+    failure?: string | null;
     /** The lead thread a change in reachable projects replaced; shown only. */
     previous?: ReplacedThread | null;
     messages: LeadMessage[];
@@ -404,6 +406,9 @@ export type LiveTurn = {
     stepAt?: number[];
     /** Per step: its text is the provider's finished answer, secret-checked whole (lead.ts `final`). */
     confirmed?: boolean[];
+    /** The shared live-reply core (live-reply.ts): the only source of what the chat room shows — one status line, the
+     * tools behind a disclosure, and shaped, settled partial text. `steps[].text` above is raw and never sent. */
+    reply?: import("../live-reply.js").LiveReply;
 };
 export type ChatEnablement = {
     ok: true;

package/dist/server/render-chat.js

@@ -825,7 +825,7 @@ export function replacedThreadHtml(previous) {
  * A div, not a p: the Remove form can't sit inside a paragraph (the parser would close it first). */
 function queuedStateHtml(row, back) {
     if (row.status === "queued") {
-        const waiting = row.error?.startsWith("Waiting: ") === true ? row.error.slice("Waiting: ".length) : "It goes to the lead when it finishes.";
+        const waiting = row.error?.startsWith("Waiting: ") === true ? row.error.slice("Waiting: ".length) : "Waiting for your earlier messages…";
         return html `<div class="so-queued" data-queued="${row.message}" data-queue-state="queued"><span class="so-queued-state">Queued</span> · ${waiting}${postForm(`/chat/queued/${row.message}/remove`, html `<button type="submit" class="so-queued-remove quiet">Remove</button>`, { attrs: { class: "inline" }, ...(back === null ? {} : { returnTo: back }) })}</div>`;
     }
     if (row.status === "running" && row.turnId === null)
@@ -949,6 +949,8 @@ export function leadThreadHtml(data) {
         const ask = message.turn === null ? undefined : data.asks?.get(message.turn);
         thread.push(html `<div class="msg mate" data-message-role="assistant" data-key="m${message.id}"${message.id === latestReply ? html ` id="latest"` : ""}>${renderChatText(message.text, asked)}${ask === undefined ? "" : leadAskHtml(ask, { task: data.focusTask?.id ?? null, project: data.chatProject ?? null }, "chat-message", data.pending === null && data.ask?.turn === ask.turn)}${cards.map(one => leadProposalCard(one, inert, data.decisions.get(typeof one.payload["decision"] === "number" ? one.payload["decision"] : -1) ?? null, data.focusTask === null ? null : returnTo))}<div class="chat-message-foot">${chatActivity(message.activity)}<time datetime="${message.createdAt}">${relativeAge(message.createdAt, data.now)}</time></div></div>`);
     }
+    if (data.pending === null && data.failure)
+        thread.push(html `<div class="problem" data-key="failed" data-lead-failed role="alert">${data.failure}</div>`);
     parts.push(html `<div class="thread" data-key="thread" data-chat-list>\n${joinHtml(thread, "\n")}\n</div>`);
     if (data.pending !== null) {
         const subscription = data.pending.reservedMicrousd === 0;
@@ -1033,7 +1035,7 @@ export function leadPage(chrome, data) {
                 sessionId, user: approver, version: leadChatVersion(data),
                 messages: leadBrowserMessages(data, data.focusTask === null && chatProject === null ? null : returnTo, { task: data.focusTask?.id ?? null, project: chatProject }),
                 pendingTurnId: data.pending?.id ?? null, requestId: randomBytes(16).toString('hex'), maxChars: LEAD_MESSAGE_MAX_CHARS,
-                taskId: data.focusTask?.id ?? null, resultRunId: data.resultRunId ?? null, project: chatProject,
+                taskId: data.focusTask?.id ?? null, resultRunId: data.resultRunId ?? null, project: chatProject, failure: data.pending === null ? data.failure ?? null : null,
                 ...(data.previous == null ? {} : { previous: { messages: replacedBrowserMessages(data.previous) } }),
             },
             focus: data.focusTask === null ? null : { id: data.focusTask.id, title: data.focusTask.title,

package/dist/server/render-settings.d.ts

@@ -41,6 +41,14 @@ export declare function leadSettingsHtml(data: {
         when: string;
         until: string;
     }[];
+    /** Quick answers (responsive-chat.md §8): whether they're on, the faster model's name, whether this person may change
+     * them (an instance operator), and whether the last save was this one. Absent: not shown. */
+    quick?: {
+        on: boolean;
+        model: string;
+        canChange: boolean;
+        saved: boolean;
+    };
     /** D5: the lead's subagents in the projects this person can use: name and role, project, and whether it's paused. */
     subagents?: {
         id: number;

package/dist/server/render-settings.js

@@ -11,7 +11,7 @@ import {} from "../telegram.js";
 import { chatMoney, screen, when } from "./chrome.js";
 import { taskHref } from "./http.js";
 import { html, joinHtml, postForm } from "../html.js";
-import { acts, btn, chip, codeLine, disclose, facts, formRow, input, note, notice, select, settingsLink, settingsRecord, settingsSection, textarea } from "./kit.js";
+import { acts, btn, chip, codeLine, disclose, facts, formRow, input, note, notice, select, settingsLink, settingsRecord, settingsSection, switchInput, textarea } from "./kit.js";
 import { kitSectionForm, SECRET_OPT_OUTS } from "../settings-kit.js";
 import { settingsSubPage } from "../settings-groups-ui.js";
 /** Settings → Lead: one line for what runs the lead and one action; the full form, turning it off and stored keys under Advanced. */
@@ -43,6 +43,17 @@ export function leadSettingsHtml(data) {
                 attrs: { maxlength: ABOUT_YOU_MAX_LINES * (ABOUT_YOU_LINE_MAX + 1), placeholder: "Keep copy terse.\nI test changes myself.", "aria-label": "What your lead knows about you" } }), "top"),
             html `<div class="k-ssave">${savedLine(data.aboutSaved === true)}${btn("Save", { sm: true, type: "submit" })}</div>`,
         ]), { attrs: { "data-lead-about": true } }) });
+    // Quick answers: plain status questions go to a faster model; anything that asks for a change stays on the main one.
+    const quick = data.quick === undefined || config === null ? "" : settingsSection({ id: "lead-quick", title: "Quick answers",
+        lead: config.provider === "claude-subscription"
+            ? `Short questions about what's going on, like "what's running?", are answered by ${data.quick.model}, a faster model. Anything that asks for a change still goes to the lead's main model.`
+            : "Short questions about what's going on can go to a faster model. This works only when the lead uses the Anthropic membership.",
+        body: data.quick.canChange
+            ? postForm("/settings/lead/quick", joinHtml([
+                switchInput({ id: "lead-quick", name: "enabled", label: "Quick answers use a faster model", on: data.quick.on }),
+                html `<div class="k-ssave">${savedLine(data.quick.saved)}${btn("Save", { sm: true, type: "submit" })}</div>`,
+            ]), { attrs: { "data-lead-quick": true } })
+            : note(data.quick.on ? "On." : "Off.") });
     // What the lead promised to follow up on; it reports each once, here in chat, and drops it after 7 days.
     const promises = (data.promises ?? []).length === 0 ? "" : settingsSection({ id: "lead-promises", title: "Promises", lead: "What the lead said it would follow up on. Each is reported once, then dropped after 7 days.",
         body: joinHtml(data.promises.map(one => settingsRecord({
@@ -69,7 +80,7 @@ export function leadSettingsHtml(data) {
             save: { label: "Turn the lead off", variant: "danger" }, confirm: "Turn the lead off", body: note("The lead stops answering until you turn it on again.") }) });
     return settingsSubPage("agents", "Lead", joinHtml([
         data.problem ? notice(data.problem.charAt(0).toUpperCase() + data.problem.slice(1)) : data.said === null ? "" : html `<p class="k-notice info" role="status">${data.said}</p>`,
-        runs, identity, about, promises, subagents,
+        runs, identity, about, quick, promises, subagents,
         disclose("Advanced", joinHtml([leadConfigForm(config, facts), keys, off])),
     ], "\n"));
 }

package/dist/server/route-table.js

@@ -619,6 +619,8 @@ post("chat", "onboarding.phone-dismiss", "/onboarding/phone/dismiss", approver("
 const LEAD_WORDS = { identity: "An approver names their lead.", about: "An approver edits what their lead knows about them.", "promise/cancel": "An approver manages the lead's promises.", on: "An approver turns the lead on." };
 for (const one of ["identity", "about", "promise/cancel", "on"])
     post("settings", `settings.lead-${one.replaceAll("/", "-")}`, `/settings/lead/${one}`, approver(LEAD_WORDS[one], "/settings/lead"));
+// Quick answers is installation-wide: which model answers everyone's plain questions (responsive-chat.md §8).
+post("settings", "settings.lead-quick", "/settings/lead/quick", { callers: ["cookie"], ...operator("An instance operator chooses how the lead answers.", "/settings/lead") });
 post("chat", "chat.config", "/chat/config", { scope: "step-up" });
 for (const one of ["mint", "follow", "end", "stop"])
     post("chat", `chat.mate-${one}`, `/chat/mate/${one}`, { callers: ["cookie"], ...(one === "mint" ? { scope: "step-up" } : {}) });

package/dist/server/settings.js

@@ -76,6 +76,7 @@ import { cleanUpHtml, decisionsHtml, framedSection, knowledgeHtml, MEMORY_INTRO,
 import { aboutYouOf, checkAboutYou, saveAboutYou } from "../lead-about.js";
 import { cancelCommitment, conditionWords, openCommitments } from '../lead-commitments.js';
 import { checkLeadIdentity, leadIdentityOf } from "../lead-identity.js";
+import { modelName as leadModelName, quickLeadModel } from "../lead-route.js";
 import { mailboxAccess, readThroughImap } from "../mailbox.js";
 import { startConnect } from "../mcp-connect.js";
 import { decideProposal, defaultTidyAnalyzer, listProposals, memoryStatus } from "../memory-pass.js";
@@ -122,6 +123,7 @@ import { addProjectInstructions, ASSISTANTS, detectPreparation, modelChoices, pr
 import { skillsHtml, skillsScript } from "../skills-ui.js";
 import { checkSlackCredentials, clearSlackCredentials, loadSlackCredentials, saveSlackCredentials, SLACK_MANIFEST, SlackError } from "../slack-api.js";
 import { slackSettingsHtml } from "../slack-settings.js";
+import { ACK_REFUSED_META } from "../chat-live.js";
 import { spendHtml, spendScript } from "../spend-ui.js";
 import { approvalFactsNow } from "./kit.js";
 import { spendReport, spendReportCsv, spendRows } from "../spend-report.js";
@@ -135,7 +137,7 @@ import { sweepSchedule } from "../storage-sweep-schedule.js";
 import { storageHtml } from "../storage-ui.js";
 import { landedSummary } from "../landed-cleanup.js";
 import { bytesWords, parseCleanup, parseIdle } from "../storage.js";
-import { checkoutIdle, isDigestTime, liveBackupState, setCheckoutIdle, localModeOf, RESULT_SCREENSHOTS, setLiveBackupSettings, setLocalModeOff } from "../store.js";
+import { checkoutIdle, isDigestTime, leadQuickAnswersOn, liveBackupState, setCheckoutIdle, localModeOf, RESULT_SCREENSHOTS, setLeadQuickAnswers, setLiveBackupSettings, setLocalModeOff } from "../store.js";
 import { defaultLiveFolder, liveFolderOf, liveFolderProblem } from "../live-backup.js";
 import { LIVE_EVERY } from "../backup-ui.js";
 import { checkTeamsCredentials, clearTeamsCredentials, loadTeamsCredentials, saveTeamsCredentials, TeamsError } from "../teams-api.js";
@@ -673,6 +675,7 @@ ${restoreHtml(chosen, retired, undoableMerges(store, chosen), disabledLessons(st
         return sendScreen(response, 200, screen("Lead", leadSettingsHtml({ config, facts, words: leadWords(), signedIn, command: agentSignInCommand(),
             said: url.searchParams.get("said"), problem: url.searchParams.get("problem"), saved: url.searchParams.get("saved") === "1", identity: leadIdentityOf(store, who.name), promises,
             about: aboutYouOf(store, who.name), aboutSaved: url.searchParams.get("saved") === "about",
+            quick: { on: leadQuickAnswersOn(store), model: leadModelName(quickLeadModel(store)), canChange: who.role === "approver" && store.isInstanceOperator(who.name), saved: url.searchParams.get("saved") === "quick" },
             subagents: store.subagents(consoleProjects().filter(repo => store.accountCanAccess(who.name, repo))).map(one => ({ id: one.id, label: labelOf(one), project: projectName(one.repo), paused: one.state === "paused" })) }), { chrome: chromeFor(project, "settings") }));
     }
     async function telegramPage(ctx) {
@@ -2005,6 +2008,8 @@ ${restoreHtml(chosen, retired, undoableMerges(store, chosen), disabledLessons(st
                 if (credentials || loadSlackCredentials(dir))
                     return show("Disconnect the current Slack app before connecting another.", 409);
                 saveSlackCredentials(dir, checked);
+                // A fresh connection asks for the 👀 again at once (an app reinstalled with reactions:write).
+                state.deleteMeta(checked.installation, ACK_REFUSED_META);
             }
             catch (error) {
                 return show(error instanceof SlackError ? error.message : "Slack could not be connected. Check the tokens and try again.");
@@ -2906,6 +2911,7 @@ ${postForm("/settings/chat-approval/save", html `\
         "mode.revoke": modeRevoke,
         "settings.lead-identity": leadIdentity,
         "settings.lead-about": leadAbout,
+        "settings.lead-quick": leadQuick,
         "settings.lead-promise-cancel": leadPromiseCancel,
         "settings.lead-on": leadOn,
         "settings.code-map": codeMapAct("switch"),
@@ -3223,5 +3229,12 @@ ${postForm("/settings/chat-approval/save", html `\
         });
         return done.ok ? back("said", "Saved. Tasks scoped from now on use it; tasks already approved keep the chain they were approved with.") : back("problem", `Nothing changed: ${done.problem}`);
     }
+    // Settings → Lead: quick answers on or off (installation-wide; the route admits an instance operator only).
+    async function leadQuick(ctx) {
+        const { who, response, now, posted } = ctx;
+        const body = readForm(posted, CONSOLE_FORMS.leadQuick);
+        setLeadQuickAnswers(store, body.get("enabled") === "on", who.name, now);
+        return redirect(response, "/settings/lead?saved=quick");
+    }
     return { registrations, modelsView };
 }

package/dist/slack-api.js

@@ -19,6 +19,10 @@ export class SlackError extends ChatDeliveryError {
                 channel_not_found: "The Slack conversation is unavailable. Pair your account again.",
                 message_not_found: "The original Slack message was removed. Open the saved chat to recover it.",
                 already_complete: "Waiting to confirm the uploaded file’s receipt.",
+                cant_update_message: "Slack wouldn't let that message be changed.",
+                edit_window_closed: "Slack wouldn't let that message be changed any more.",
+                already_reacted: "The reaction was already there.",
+                no_reaction: "The reaction was already gone.",
             }[code] ?? code;
     }
 }
@@ -36,6 +40,11 @@ const errors = new Set([
     "file_not_found",
     "already_complete",
     "not_in_channel",
+    // The 👀 and edits of the live message: named, so they are told apart from a real failure.
+    "already_reacted",
+    "no_reaction",
+    "cant_update_message",
+    "edit_window_closed",
 ]);
 export function slackApi(token, fetcher = fetch) {
     return async (method, args = {}) => {
@@ -208,6 +217,8 @@ export const SLACK_MANIFEST = {
                 "users:read",
                 "files:read",
                 "files:write",
+                // The 👀 on a message when it arrives, and taking it off once the answer is delivered.
+                "reactions:write",
             ],
         },
     },