toolroll 0.9.95 → 0.9.97

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",
             ],
         },
     },

package/dist/slack-chat.d.ts

@@ -1,6 +1,7 @@
-import { ChatState } from "./chat-delivery-state.js";
+import { ChatState, type ChatEvent } from "./chat-delivery-state.js";
 import { uploadSlackBytes, type SlackApi, type SlackIdentity } from "./slack-api.js";
 import { type Store } from "./store.js";
+import { type ChatAckHooks, type ChatLiveTransport, type LiveReplies } from "./chat-live.js";
 import type { SubscriptionLeadRunner } from "./subscription-chat.js";
 export type SlackChatOptions = {
     store: Store;
@@ -15,6 +16,8 @@ export type SlackChatOptions = {
     canNotify?: () => boolean;
     clock?: () => Date;
     upload?: typeof uploadSlackBytes;
+    /** The live "Working on it…" message (chat-live.ts): on in the worker, off unless asked for. */
+    liveReplies?: LiveReplies;
 };
 /** Synchronous receipt before ACK. Never stores response_url, raw tokens, or a pairing code. */
 export declare function receiveSlack(state: ChatState, identity: SlackIdentity, type: string, raw: unknown, now: Date): boolean;
@@ -25,3 +28,10 @@ export declare function slackBlocks(text: string, buttons?: Record<string, unkno
 /** The lead's reply as mrkdwn sections: no header block, so its first line stays an ordinary line. */
 export declare function slackVoiceBlocks(mrkdwn: string, buttons?: Record<string, unknown>[]): Record<string, unknown>[];
 export declare function deliverSlackPart(options: SlackChatOptions): Promise<boolean>;
+/** A live message's exact payload (§3.2): the rendered mrkdwn as the top-level text and as verbatim sections, every
+ * field sent on every edit, nothing parsed, linked or unfurled, no buttons. */
+export declare function slackLivePayload(channel: string, mrkdwn: string): Record<string, unknown>;
+/** The live message for one owner message, in its thread (where the reply goes). */
+export declare function slackLive(options: Pick<SlackChatOptions, "api">, event: ChatEvent, spacingMs?: number): ChatLiveTransport;
+/** The 👀 on the owner's message (reactions:write). An install without that scope is asked at most once a minute, quietly. */
+export declare function slackAckHooks(options: Pick<SlackChatOptions, "api">): ChatAckHooks;

package/dist/slack-chat.js

@@ -17,7 +17,9 @@ import { readSlackBlockActions, readSlackButton, SLACK_LINK_ACTION } from "./con
 import { object, slackId, slackTs, slackMember, SlackError, uploadSlackBytes, } from "./slack-api.js";
 import { resultImageFileName, safeResultImageCaption, verifyResultImage, } from "./chat-evidence.js";
 import {} from "./store.js";
+import { isLiveMessage, liveSpacingOf } from "./chat-live.js";
 const SLACK_REFUSED_BLOCKS = new Set(["invalid_blocks", "invalid_blocks_format", "invalid_arguments", "msg_too_long", "msg_blocks_too_long"]);
+const SLACK_UNEDITABLE = new Set(["message_not_found", "cant_update_message", "edit_window_closed"]);
 const nowOf = (options) => options.clock?.() ?? new Date();
 const split = (text, size = 2800) => {
     const parts = [];
@@ -125,10 +127,8 @@ const delivery = (options) => ({
     state: new ChatState(options.store, "slack"),
     label: "Slack",
     member: (member, channel) => slackMember(options.api, options.identity, member, channel),
-    // A 👍 on the owner's message where the app has reactions:write; Slack shows bots no typing indicator.
-    warm: (event) => ({
-        react: () => options.api("reactions.add", { channel: event.channel, timestamp: event.ts, name: "thumbsup" }),
-    }),
+    // Slack shows bots no typing indicator; the 👀 goes at arrival (slackAckHooks) and the live message shows the rest.
+    ...(options.liveReplies ? { live: (event) => slackLive(options, event, liveSpacingOf(options.liveReplies)) } : {}),
 });
 export const processSlackEvent = (options) => processChatEvent(delivery(options));
 export const planSlackNotifications = (options) => planChatNotifications(delivery(options));
@@ -157,7 +157,8 @@ export function slackBlocks(text, buttons = []) {
 export function slackVoiceBlocks(mrkdwn, buttons = []) {
     const blocks = split(mrkdwn).map((part) => ({
         type: "section",
-        text: { type: "mrkdwn", text: part },
+        // verbatim: Slack never turns words of the reply into a mention, a channel or a link (renderReply escapes the rest).
+        text: { type: "mrkdwn", text: part, verbatim: true },
     }));
     if (buttons.length)
         blocks.push({ type: "actions", elements: buttons });
@@ -396,6 +397,7 @@ export async function deliverSlackPart(options) {
             blocks: content.rich ? slackCardBlocks(content.rich, buttons) : voiced === null ? slackBlocks(text, buttons) : slackVoiceBlocks(voiced, buttons),
             mrkdwn: voiced !== null,
             parse: "none",
+            link_names: false,
             unfurl_links: false,
             unfurl_media: false,
         };
@@ -423,6 +425,12 @@ export async function deliverSlackPart(options) {
         }
         // No permission to upload files here: one plain line instead of the result's screenshots.
         const saved = readChatPart(row.payload), content = saved.ok ? saved.value : null;
+        // The live message the reply was to replace is gone (deleted, or too old to edit): the reply goes out as a new one.
+        if (content?.edit !== undefined && error instanceof SlackError && SLACK_UNEDITABLE.has(error.code) && isLiveMessage(state, row.event, content.edit)) {
+            const { edit: _edit, ...asNew } = content;
+            state.repaint(row.id, asNew);
+            return true;
+        }
         // Slack refused the card's blocks: the part's own plain text goes instead, so the message is never lost.
         if (content?.rich && error instanceof SlackError && SLACK_REFUSED_BLOCKS.has(error.code)) {
             state.repaint(row.id, withoutCard(content));
@@ -444,3 +452,40 @@ export async function deliverSlackPart(options) {
         return true;
     }
 }
+/** A live message's exact payload (§3.2): the rendered mrkdwn as the top-level text and as verbatim sections, every
+ * field sent on every edit, nothing parsed, linked or unfurled, no buttons. */
+export function slackLivePayload(channel, mrkdwn) {
+    return { channel, text: mrkdwn, blocks: slackVoiceBlocks(mrkdwn), mrkdwn: true, parse: "none", link_names: false, unfurl_links: false, unfurl_media: false };
+}
+/** The live message for one owner message, in its thread (where the reply goes). */
+export function slackLive(options, event, spacingMs) {
+    return {
+        platform: "slack",
+        ...(spacingMs === undefined ? {} : { spacingMs }),
+        limit: 2_800,
+        create: async (text) => {
+            const answer = await options.api("chat.postMessage", { ...slackLivePayload(event.channel, text), thread_ts: event.thread });
+            if (!slackTs(answer.ts))
+                throw new SlackError("Slack did not confirm the message identity", 15_000, true);
+            return answer.ts;
+        },
+        edit: async (message, text) => {
+            const answer = await options.api("chat.update", { ...slackLivePayload(event.channel, text), ts: message });
+            if (answer.ts !== message)
+                throw new SlackError("Slack did not confirm the message identity", 15_000, true);
+        },
+        rateLimited: error => error instanceof SlackError && error.code === "ratelimited" ? error.retryMs : null,
+        uncertain: error => !(error instanceof SlackError) || error.uncertain,
+    };
+}
+/** The 👀 on the owner's message (reactions:write). An install without that scope is asked at most once a minute, quietly. */
+export function slackAckHooks(options) {
+    const code = (error) => error instanceof SlackError ? error.code : "";
+    return {
+        react: (event) => options.api("reactions.add", { channel: event.channel, timestamp: event.ts, name: "eyes" }),
+        unreact: (event) => options.api("reactions.remove", { channel: event.channel, timestamp: event.ts, name: "eyes" }),
+        refused: error => ["missing_scope", "no_permission", "not_in_channel", "channel_not_found"].includes(code(error)),
+        settled: error => ["already_reacted", "no_reaction", "message_not_found"].includes(code(error)),
+        rateLimited: error => code(error) === "ratelimited" ? error.retryMs : null,
+    };
+}

package/dist/slack-settings.js

@@ -1,11 +1,18 @@
 import { html, joinHtml } from "./html.js";
 import { loadSlackCredentials } from "./slack-api.js";
 import { chatSecretRow, chatSettingsHtml } from "./chat-settings-page.js";
+import { ChatState } from "./chat-delivery-state.js";
+import { ACK_REFUSED_META } from "./chat-live.js";
+import { notice } from "./server/kit.js";
 export function slackSettingsHtml(store, dir, options = {}) {
+    const credentials = loadSlackCredentials(dir);
+    // Slack answered "missing scope" to the 👀: an app installed before reactions:write needs one reinstall.
+    const reinstall = credentials !== null && new ChatState(store, "slack").meta(credentials.installation, ACK_REFUSED_META) !== null;
     return chatSettingsHtml(store, dir, options, {
         provider: "slack",
         label: "Slack",
-        credentials: loadSlackCredentials(dir),
+        credentials,
+        ...(reinstall ? { connection: notice(html `Reinstall needed for reactions. Update the app with the new <a class="k-link" href="/settings/slack/manifest">app manifest</a>, then reinstall it to your workspace.`) } : {}),
         intro: "Manage projects and review results in a private Slack conversation.",
         steps: html `<ol class="k-note"><li>Download the <a class="k-link" href="/settings/slack/manifest">app manifest</a>, then <a class="k-link" href="https://api.slack.com/apps" target="_blank" rel="noopener noreferrer">create an app</a> in your workspace using that manifest.</li><li>Under Basic Information, create an app-level token with <code class="k-mono">connections:write</code>.</li><li>Under OAuth &amp; Permissions, install the app and copy its bot token.</li></ol>`,
         fields: joinHtml([

package/dist/slack.js

@@ -3,7 +3,8 @@ import { randomBytes } from "node:crypto";
 import { abortablePause, workChatQueue } from "./chat-follow.js";
 import { loadSlackCredentials, slackApi } from "./slack-api.js";
 import { ChatState } from "./chat-delivery-state.js";
-import { receiveSlack, processSlackEvent, deliverSlackPart, planSlackNotifications, planSlackRooms, } from "./slack-chat.js";
+import { runChatAcks } from "./chat-live.js";
+import { receiveSlack, processSlackEvent, deliverSlackPart, planSlackNotifications, planSlackRooms, slackAckHooks, } from "./slack-chat.js";
 export async function followSlack(options) {
     const owner = randomBytes(16).toString("hex"), state = new ChatState(options.store, "slack");
     const pause = abortablePause(options.signal);
@@ -74,11 +75,16 @@ export async function followSlack(options) {
             problem("Reconnecting to Slack…");
         });
         client.on("error", () => problem("Slack connection failed. Check the app tokens and reconnect."));
+        // The 👀 on each owner message as it arrives, beside the queue (a turn there can take a minute).
+        const api = slackApi(credentials.botToken);
+        const acks = runChatAcks({ state, installation: credentials.installation, owner, current: () => same() && connected,
+            hooks: slackAckHooks({ api }), same, signal: options.signal });
         client.on("slack_event", (envelope) => {
             if (!same())
                 return;
             try {
-                receiveSlack(state, credentials, envelope.type, envelope.body, new Date());
+                if (receiveSlack(state, credentials, envelope.type, envelope.body, new Date()))
+                    acks.wake();
                 void envelope
                     .ack()
                     .catch(() => problem("Slack acknowledgement was lost; a repeated event will be recognized."));
@@ -91,9 +97,10 @@ export async function followSlack(options) {
             ...options,
             identity: credentials,
             owner,
-            api: slackApi(credentials.botToken),
+            api,
             canNotify: options.notifications,
             current: same,
+            liveReplies: true,
         };
         try {
             await client.start();

package/dist/store.d.ts

@@ -8,6 +8,8 @@ import { type AcpLaunch } from "./acp-attest.js";
 import { type CheckStamp, type StampReading } from "./check-stamp.js";
 import { V155_STEPS } from "./fleet-schema.js";
 import { V156_STEPS } from "./fallback-schema.js";
+import { V158_STEPS, type LeadFailureDetail, type LeadRoute } from "./lead-latency-schema.js";
+import { V157_STEPS } from "./chat-live-schema.js";
 export { refArchived, taskArchived } from "./task-archive.js";
 import { type ChatBinding } from "./chat-core.js";
 import { ChatMessages, TELEGRAM_HOLD_REASONS, TELEGRAM_SKIPPED_ELSEWHERE, TELEGRAM_SKIPPED_OTHER_CHAT, TELEGRAM_SKIPPED_QUIET } from "./chat-messages.js";
@@ -248,7 +250,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 156;
+export declare const SCHEMA_VERSION = 158;
 /** v118: the tables merged into `credential`, in the order they move (a person's API tokens keep their ids first). */
 export declare const V118_MERGED_TABLES: Readonly<Record<string, CredentialKind>>;
 /**
@@ -440,7 +442,7 @@ export declare const V147_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
 }>>>>;
 /** The v147 migration's steps after the epoch, in order: a test seam (OpenOptions.migrationStep) may stop after each. */
 export declare const V147_STEPS: readonly ["epoch", "local-mode", "password-set", "web-session", "console-instance"];
-export type MigrationStep = (typeof V147_STEPS)[number] | (typeof V148_STEPS)[number] | (typeof V149_STEPS)[number] | (typeof V150_STEPS)[number] | (typeof V151_STEPS)[number] | (typeof V152_STEPS)[number] | (typeof V153_STEPS)[number] | (typeof V154_STEPS)[number] | (typeof V156_STEPS)[number] | (typeof V155_STEPS)[number];
+export type MigrationStep = (typeof V147_STEPS)[number] | (typeof V148_STEPS)[number] | (typeof V149_STEPS)[number] | (typeof V150_STEPS)[number] | (typeof V151_STEPS)[number] | (typeof V152_STEPS)[number] | (typeof V153_STEPS)[number] | (typeof V154_STEPS)[number] | (typeof V156_STEPS)[number] | (typeof V155_STEPS)[number] | (typeof V157_STEPS)[number] | (typeof V158_STEPS)[number];
 /**
  * v148 (docs/plans/results-routing.md): every table the results-routing arc uses, landed at once because a current
  * store runs no DDL. Slice 1 writes run_cohort, route_record and models_generation; route_rule, route_exposure* and
@@ -528,6 +530,8 @@ export declare const V153_STEPS: readonly ["plain-tables", "plain-columns"];
 export declare const V154_STEPS: readonly ["check-stamps"];
 export { V155_STEPS };
 export { V156_STEPS };
+export { V157_STEPS };
+export { V158_STEPS };
 /**
  * v135: one approval per release (docs/plans/release-once.md). `release_authority` is the single source of truth for a
  * release a person approved: one row per generation, changed only by compare-and-swap on `rev`, with a lease whose
@@ -1188,6 +1192,10 @@ export type LeadTurn = {
     tokensIn: number | null;
     tokensOut: number | null;
     failureReason: string | null;
+    /** v158: why it failed, more exactly (lead-latency-schema.ts); null when unknown or before v158. */
+    failureDetail?: LeadFailureDetail | null;
+    /** v158: which model answered (default, the quick model, or the main model after a quick step asked for more). */
+    route?: LeadRoute | null;
 };
 /** Who placed a hold — and therefore who alone may lift it. */
 /** 'stop' (v52) = the pause one exact attempt's operator stop placed — lifted
@@ -4393,6 +4401,10 @@ export declare class Store {
         reportedCostUsd?: number | null;
         /** v141: how the request's own events said it was billed (a subscription harness); absent or null: unknown. */
         billingReported?: "subscription" | "api-key" | null;
+        /** v158: the tool names a lead step asked for (names only, never arguments); absent: not recorded. */
+        tools?: readonly string[];
+        /** v158: why it failed, more exactly than failureReason; absent: unknown. */
+        failureDetail?: LeadFailureDetail | null;
     }, now: Date): boolean;
     /**
      * The crash sweep: turns past their deadline become failed('crashed'),
@@ -6583,6 +6595,8 @@ export declare class Store {
         tokensIn: number;
         tokensOut: number;
         failureReason?: string;
+        /** v158: why it failed, more exactly than failureReason (the words a later reader shows); absent: unknown. */
+        failureDetail?: LeadFailureDetail | null;
         /** Answered turns: the assistant row, written in the same transaction as the promotion. A timed-out turn's notice. */
         message?: {
             text: string;
@@ -8521,3 +8535,18 @@ export declare function taskCheckStamp(store: Store, repo: string, taskId: strin
     runId: number;
     reading: StampReading;
 } | null;
+/** A thread's newest lead turn, whatever its state; null before its first. What a surface reads back to say how the
+ * last reply ended after a restart (docs/plans/responsive-chat.md §3.4): the saved row, never process memory. */
+export declare function latestLeadTurnOfThread(store: Store, thread: number): LeadTurn | null;
+/** Settings → Lead's "Quick answers use a faster model" (v158): absent reads off, the shipped default
+ * (docs/plans/responsive-chat.md §8: on only once the lead-answer eval passes). */
+export declare function leadQuickAnswersOn(store: Store): boolean;
+/** Turn quick answers on or off, recording who and when (the caller proved the person may change the lead's settings). */
+export declare function setLeadQuickAnswers(store: Store, enabled: boolean, by: string, now: Date): void;
+/** Which model answers a running reply (v158): written at admission and when a quick step hands over to the main model.
+ * Only the turn's own running generation may write it. */
+export declare function setLeadTurnRoute(store: Store, turn: number, generation: number, route: LeadRoute): boolean;
+/** Whether a new message in this thread may be the answer to the lead's own question (ask_owner): the thread's newest
+ * reply asked one, less than LEAD_ASK_TTL_MS ago. Conservative on purpose: the quick-answer router (§8) keeps such a
+ * message on the main model. */
+export declare function leadAskAwaitsAnswer(store: Store, thread: number, now: Date): boolean;