toolroll 0.9.96 → 0.9.97

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;

package/dist/store.js

@@ -13,6 +13,8 @@ import { codeMapRemoteChanged, codeMapShapeProblem, forgetCodeMap, V152_ADDED_CO
 import { readStamps, stampDigest, stampRefusal, V154_SCHEMA } from "./check-stamp.js";
 import { FINDING_SOURCES, FINDING_SOURCES_BEFORE_LEAD, V155_SCHEMA, V155_STEPS } from "./fleet-schema.js";
 import { V156_SCHEMA, V156_STEPS } from "./fallback-schema.js";
+import { V158_ADDED_COLUMNS, V158_SCHEMA, V158_STEPS, LEAD_FAILURE_DETAILS, LEAD_ROUTES } from "./lead-latency-schema.js";
+import { V157_SCHEMA, V157_STEPS } from "./chat-live-schema.js";
 import { refArchived, taskArchived } from "./task-archive.js";
 export { refArchived, taskArchived } from "./task-archive.js";
 import { CHAT_PROVIDERS, CHAT_SCHEMA } from "./contracts/chat-tables.js";
@@ -1142,7 +1144,11 @@ const REGISTERED_AT_FILING = "again, as it was filed";
 // v155 adds, and changes no saved row (docs/plans/fleet-follow-through.md): findings and their answers, check repairs,
 // before-and-after evidence and provider captures (V155_SCHEMA, new tables only; fleet-schema.ts).
 // v156 adds fallback chains (V156_SCHEMA, new tables only; fallback-schema.ts), after v155.
-export const SCHEMA_VERSION = 156;
+// v157 is the chat apps' live placeholders (chat-apps slice; merged separately).
+// v158 adds, and changes no saved row (docs/plans/responsive-chat.md, slice 5): the tools each lead step asked for, an
+// exact failure detail on a step and a reply, which model answered a reply (mate_turn.route), and the quick-answer
+// switch (lead_quick_setting). V158_SCHEMA, V158_ADDED_COLUMNS (lead-latency-schema.ts): saved rows read NULL.
+export 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 const V118_MERGED_TABLES = Object.freeze({ api_token: "person", coordinator_credential: "coordinator", lead_credential: "lead" });
 /** The foreign keys that named a merged table, exactly as their DDL wrote them; each names `credential(id)` instead. */
@@ -1275,7 +1281,7 @@ const V115_DROPPED_REFERENCES = /\s+REFERENCES (?:contestant|contest|tournament_
  * unchanged), and adds the nullable column in V125_ADDED_COLUMNS, checked the same way. v126 only adds a new table
  * (task_source) and the columns in V126_ADDED_COLUMNS (null or 0), checked the same way.
  */
-export const UPDATE_SAFE_MIGRATIONS = Object.freeze([108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156]);
+export const UPDATE_SAFE_MIGRATIONS = Object.freeze([108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158]);
 /** v119: the columns it adds, by table, with the value every row saved before it reads (toolroll-update's HISTORY_RULES). */
 export const V119_ADDED_COLUMNS = Object.freeze({
     task_ref: { planning_generation: { definition: "INTEGER NOT NULL DEFAULT 0", saved: "0" } },
@@ -1936,6 +1942,8 @@ export const V153_STEPS = Object.freeze(["plain-tables", "plain-columns"]);
 export const V154_STEPS = Object.freeze(["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
@@ -5274,6 +5282,17 @@ CREATE INDEX IF NOT EXISTS run_checkpoint_by_task ON run_checkpoint (task_ref, i
     // v156: fallback chains (new tables only). Idempotent, as v155's steps are.
     db.exec(V156_SCHEMA);
     step("fallback-tables");
+    // v157: live replies in Slack, Discord and Teams (new tables only). Idempotent, as v156's step is.
+    db.exec(V157_SCHEMA);
+    step("chat-live-tables");
+    // v158: the lead's latency records and its quick-answer switch (V158_SCHEMA, V158_ADDED_COLUMNS: saved rows read
+    // NULL). Idempotent, as v156's and v157's steps are.
+    db.exec(V158_SCHEMA);
+    step("lead-quick-setting");
+    for (const [table, columns] of Object.entries(V158_ADDED_COLUMNS))
+        for (const [column, { definition }] of Object.entries(columns))
+            addColumn(db, table, column, definition);
+    step("lead-latency-columns");
     // Keep the epoch until reclamation succeeds, including a retry after compaction already committed. A new file has
     // nothing to reclaim.
     if (!fresh)
@@ -13210,9 +13229,9 @@ export class Store {
         const changed = this.db
             .prepare(`UPDATE chat_turn SET state = ?, failure_reason = ?, tokens_in = ?, tokens_out = ?,
            settled_microusd = ?, unknown_spend = ?, reply_bytes = ?, candidate_count = ?, cache_read_tokens = ?, cache_write_tokens = ?,
-           model_reported = ?, provider_turns = ?, reported_cost_usd = ?, billing_reported = ?, finished_at = ?
+           model_reported = ?, provider_turns = ?, reported_cost_usd = ?, billing_reported = ?, tools = ?, failure_detail = ?, finished_at = ?
          WHERE id = ? AND generation = ? AND state IN ('queued','running')`)
-            .run(outcome.state, outcome.failureReason ?? null, outcome.tokensIn ?? null, outcome.tokensOut ?? null, outcome.settledMicrousd, outcome.unknownSpend === true ? 1 : 0, outcome.replyBytes ?? null, outcome.candidateCount ?? null, outcome.cacheReadTokens ?? null, outcome.cacheWriteTokens ?? null, reportedModelOf(outcome.modelReported), providerTurnsOf(outcome.providerTurns), reportedCostUsdOf(outcome.reportedCostUsd), outcome.billingReported === "subscription" || outcome.billingReported === "api-key" ? outcome.billingReported : null, now.toISOString(), id, generation);
+            .run(outcome.state, outcome.failureReason ?? null, outcome.tokensIn ?? null, outcome.tokensOut ?? null, outcome.settledMicrousd, outcome.unknownSpend === true ? 1 : 0, outcome.replyBytes ?? null, outcome.candidateCount ?? null, outcome.cacheReadTokens ?? null, outcome.cacheWriteTokens ?? null, reportedModelOf(outcome.modelReported), providerTurnsOf(outcome.providerTurns), reportedCostUsdOf(outcome.reportedCostUsd), outcome.billingReported === "subscription" || outcome.billingReported === "api-key" ? outcome.billingReported : null, outcome.tools === undefined ? null : JSON.stringify(outcome.tools.filter(name => /^[a-z_]{1,64}$/.test(name)).slice(0, 32)), outcome.failureDetail != null && LEAD_FAILURE_DETAILS.includes(outcome.failureDetail) ? outcome.failureDetail : null, now.toISOString(), id, generation);
         return Number(changed.changes) === 1;
     }
     /**
@@ -18016,9 +18035,9 @@ export class Store {
                 return false;
             const settled = outcome.unknownSpend === true ? Math.max(Number(before["reserved"]), outcome.settledMicrousd) : outcome.settledMicrousd;
             const changed = this.db
-                .prepare(`UPDATE mate_turn SET state = ?, settled_microusd = ?, tokens_in = ?, tokens_out = ?, failure_reason = ?, finished_at = ?
+                .prepare(`UPDATE mate_turn SET state = ?, settled_microusd = ?, tokens_in = ?, tokens_out = ?, failure_reason = ?, failure_detail = ?, finished_at = ?
            WHERE id = ? AND generation = ? AND state IN ('queued','running')`)
-                .run(outcome.state, settled, outcome.tokensIn, outcome.tokensOut, outcome.failureReason ?? null, now.toISOString(), id, generation);
+                .run(outcome.state, settled, outcome.tokensIn, outcome.tokensOut, outcome.failureReason ?? null, outcome.failureDetail != null && LEAD_FAILURE_DETAILS.includes(outcome.failureDetail) ? outcome.failureDetail : null, now.toISOString(), id, generation);
             if (Number(changed.changes) !== 1)
                 return false;
             this.db.prepare("UPDATE lead_session SET spent_microusd = spent_microusd + ? WHERE id = ?").run(settled, Number(before["session"]));
@@ -21235,6 +21254,8 @@ function readLeadTurn(row) {
         tokensIn: maybeN("tokens_in"),
         tokensOut: maybeN("tokens_out"),
         failureReason: maybe("failure_reason"),
+        failureDetail: LEAD_FAILURE_DETAILS.includes(row["failure_detail"]) ? row["failure_detail"] : null,
+        route: LEAD_ROUTES.includes(row["route"]) ? row["route"] : null,
     };
 }
 function readVerifyCommand(row) {
@@ -23173,3 +23194,35 @@ function widenFindingSources(db) {
     const columns = db.prepare("PRAGMA table_info(finding)").all().map(one => String(one["name"]));
     rebuildExact(db, "finding", named(stored), named(stored.replace(FINDING_SOURCES_BEFORE_LEAD, FINDING_SOURCES)), columns);
 }
+/** 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 function latestLeadTurnOfThread(store, thread) {
+    const row = store.handle.prepare("SELECT * FROM mate_turn WHERE thread = ? ORDER BY id DESC LIMIT 1").get(thread);
+    return row === undefined ? null : readLeadTurn(row);
+}
+/** 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 function leadQuickAnswersOn(store) {
+    const row = store.handle.prepare("SELECT enabled FROM lead_quick_setting WHERE id = 1").get();
+    return row !== undefined && Number(row["enabled"]) === 1;
+}
+/** Turn quick answers on or off, recording who and when (the caller proved the person may change the lead's settings). */
+export function setLeadQuickAnswers(store, enabled, by, now) {
+    store.handle.prepare(`INSERT INTO lead_quick_setting (id, enabled, updated_by, updated_at) VALUES (1, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET enabled = excluded.enabled, updated_by = excluded.updated_by, updated_at = excluded.updated_at`).run(enabled ? 1 : 0, by, now.toISOString());
+}
+/** 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 function setLeadTurnRoute(store, turn, generation, route) {
+    if (!LEAD_ROUTES.includes(route))
+        return false;
+    return Number(store.handle.prepare("UPDATE mate_turn SET route = ? WHERE id = ? AND generation = ? AND state = 'running'").run(route, turn, generation).changes) === 1;
+}
+/** 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 function leadAskAwaitsAnswer(store, thread, now) {
+    const row = store.handle.prepare(`SELECT a.created_at AS at FROM lead_message m JOIN lead_ask a ON a.turn = m.turn JOIN mate_turn t ON t.id = m.turn
+      WHERE m.id = (SELECT MAX(id) FROM lead_message WHERE thread = ? AND role = 'assistant') AND t.state = 'answered'`).get(thread);
+    return row !== undefined && Date.parse(String(row["at"])) + LEAD_ASK_TTL_MS > now.getTime();
+}

package/dist/subscription-chat.d.ts

@@ -27,6 +27,7 @@ export type SubscriptionLeadRunner = (request: SubscriptionLeadRequest) => Promi
 } | {
     ok: false;
     problem: string;
+    quiet?: boolean;
 }>;
 /** The model-visible request. Tool results are already redacted by leadView. */
 export declare function composeSubscriptionLeadPrompt(request: Omit<SubscriptionLeadRequest, "provider" | "model" | "timeoutMs" | "signal">): string;
@@ -49,4 +50,5 @@ export declare function performSubscriptionLeadRequest(request: SubscriptionLead
 } | {
     ok: false;
     problem: string;
+    quiet?: boolean;
 }>;

package/dist/subscription-chat.js

@@ -260,8 +260,10 @@ export async function performSubscriptionLeadRequest(request, runner = run) {
             processGroup: true,
             ...(streaming ? { onStdout: claudeStreamReader(request.onText) } : {}),
         });
+        // Whether the harness wrote anything at all before its deadline (v158, responsive-chat.md §7.5): a silent one never
+        // started answering; one with output was answering slowly. Recorded, never shown.
         if (result.timedOut)
-            return { ok: false, problem: "timeout" };
+            return { ok: false, problem: "timeout", quiet: result.stdout.trim() === "" };
         if (result.notFound)
             return { ok: false, problem: "not-found" };
         // v105: a streamed Claude turn says its plan's usage windows, and (once it answered) how this computer's Claude bills

package/dist/teams-chat.d.ts

@@ -1,8 +1,11 @@
-import { ChatState, type ChatIdentity } from "./chat-delivery-state.js";
+import { ChatState, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
+import { type ChatAckHooks, type ChatLiveTransport, type LiveReplies } from "./chat-live.js";
 import { type ChatDeliveryOptions } from "./chat-delivery.js";
 import { type TeamsApi } from "./teams-api.js";
-export type TeamsChatOptions = Omit<ChatDeliveryOptions, "state" | "label" | "member" | "partSize" | "maxProposal"> & {
+export type TeamsChatOptions = Omit<ChatDeliveryOptions, "state" | "label" | "member" | "partSize" | "maxProposal" | "live"> & {
     api: TeamsApi;
+    /** The live "Working on it…" message (chat-live.ts): on in the worker. */
+    liveReplies?: LiveReplies;
 };
 export declare const teamsUserId: (v: unknown) => v is string;
 /** A conversation id; a channel post's carries its thread as ";messageid=<first message>" (v89). */
@@ -27,3 +30,7 @@ export declare function teamsCard(text: string, actions: Record<string, unknown>
 export declare function teamsMessages(text: string, markdown: boolean, last: (text: string) => Record<string, unknown>): Record<string, unknown>[];
 /** Send the next pending part: a plain message, an edit, or a card with its tokens. */
 export declare function deliverTeamsPart(options: TeamsChatOptions): Promise<boolean>;
+/** The live message for one owner message: a plain Markdown activity, replaced whole (PUT) on every edit. */
+export declare function teamsLive(options: Pick<TeamsChatOptions, "api" | "identity">, state: ChatState, event: ChatEvent, spacingMs?: number): ChatLiveTransport | null;
+/** Teams gives bots no reactions: the arrival ack is "typing…", with nothing to take off. */
+export declare function teamsAckHooks(options: Pick<TeamsChatOptions, "api" | "identity">, state: ChatState): ChatAckHooks;

package/dist/teams-chat.js

@@ -4,6 +4,7 @@ import { resultShotsPruned } from "./result-shots.js";
 import { chatQuestionButtons } from "./subagent-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { ChatDeliveryError, ChatState, chatHash, partContent } from "./chat-delivery-state.js";
+import { isLiveMessage, liveSpacingOf, underCooldown } from "./chat-live.js";
 import { channelAccess, chatObject as object, heldForWatch, planChatNotifications, planRoomMessages, processChatEvent, splitChatText } from "./chat-delivery.js";
 import { PLATFORM_LIMITS } from "./text-limits.js";
 import { LEAD_MESSAGE_MAX_CHARS } from "./lead.js";
@@ -14,6 +15,9 @@ import { admitChatEvent } from "./chat-admission.js";
 import { chatResultHref } from "./chat-controls.js";
 import { TeamsError } from "./teams-api.js";
 import { readTeamsSubmit } from "./contracts/teams-callback.js";
+import { readChatPart } from "./contracts/chat-content.js";
+const TEAMS_GONE = "Teams refused the request (404)";
+const TEAMS_SLOW = "Teams asked to slow down";
 const serviceKey = (conversation) => `serviceUrl:${conversation}`;
 export const teamsUserId = (v) => typeof v === "string" && /^29:[A-Za-z0-9_=-]{10,200}$/.test(v);
 /** A conversation id; a channel post's carries its thread as ";messageid=<first message>" (v89). */
@@ -43,6 +47,7 @@ export async function teamsMember(api, state, installation, member, channel) {
         return false;
     }
 }
+const teamsRateLimited = (error) => error instanceof TeamsError && error.code === TEAMS_SLOW ? error.retryMs : null;
 export const teamsDelivery = (options) => {
     const state = new ChatState(options.store, "teams");
     return {
@@ -52,12 +57,13 @@ export const teamsDelivery = (options) => {
         member: (member, channel) => teamsMember(options.api, state, options.identity.installation, member, channel),
         // "Typing…" while the lead works; Teams gives bots no reactions, so there is no 👍 here.
         warm: (event) => ({
-            typing: async () => {
+            typing: underCooldown(state, options.identity.installation, teamsRateLimited, () => options.clock?.() ?? new Date(), async () => {
                 const serviceUrl = state.meta(options.identity.installation, serviceKey(event.channel));
                 if (serviceUrl !== null)
                     await options.api("POST", serviceUrl, `/v3/conversations/${encodeURIComponent(event.channel)}/activities`, { type: "typing" });
-            },
+            }),
         }),
+        ...(options.liveReplies ? { live: (event) => teamsLive(options, state, event, liveSpacingOf(options.liveReplies)) } : {}),
         partSize: 3500,
         maxProposal: 6000,
     };
@@ -246,8 +252,50 @@ export async function deliverTeamsPart(options) {
             state.dropPart(row.id, error.message);
             return true;
         }
+        // The live message the reply was to replace is gone: the reply goes out as a new message.
+        const saved = readChatPart(row.payload), content = saved.ok ? saved.value : null;
+        if (content?.edit !== undefined && error instanceof TeamsError && error.code === TEAMS_GONE && isLiveMessage(state, row.event, content.edit)) {
+            const { edit: _edit, ...asNew } = content;
+            state.repaint(row.id, asNew);
+            return true;
+        }
         const problem = error instanceof TeamsError ? error : new TeamsError("Teams delivery failed", 15_000, true);
         state.partFailed(row.id, { problem: problem.message, until: new Date(now.getTime() + problem.retryMs).toISOString(), uncertain: problem.uncertain }, 20);
         return true;
     }
 }
+/** The live message for one owner message: a plain Markdown activity, replaced whole (PUT) on every edit. */
+export function teamsLive(options, state, event, spacingMs) {
+    const serviceUrl = state.meta(options.identity.installation, serviceKey(event.channel));
+    if (serviceUrl === null)
+        return null;
+    const activities = `/v3/conversations/${encodeURIComponent(event.channel)}/activities`;
+    const body = (text) => ({ type: "message", text, textFormat: "markdown" });
+    return {
+        platform: "teams",
+        ...(spacingMs === undefined ? {} : { spacingMs }),
+        limit: PLATFORM_LIMITS.teams - 200,
+        create: async (text) => {
+            const answer = await options.api("POST", serviceUrl, activities, body(text));
+            if (typeof answer.id !== "string" || answer.id === "")
+                throw new TeamsError("Teams did not confirm the message", 15_000, true);
+            return answer.id;
+        },
+        edit: async (message, text) => { await options.api("PUT", serviceUrl, `${activities}/${encodeURIComponent(message)}`, body(text)); },
+        rateLimited: error => error instanceof TeamsError && error.code === TEAMS_SLOW ? error.retryMs : null,
+        uncertain: error => !(error instanceof TeamsError) || error.uncertain,
+    };
+}
+/** Teams gives bots no reactions: the arrival ack is "typing…", with nothing to take off. */
+export function teamsAckHooks(options, state) {
+    return {
+        typing: async (event) => {
+            const serviceUrl = state.meta(options.identity.installation, serviceKey(event.channel));
+            if (serviceUrl !== null)
+                await options.api("POST", serviceUrl, `/v3/conversations/${encodeURIComponent(event.channel)}/activities`, { type: "typing" });
+        },
+        refused: () => false,
+        settled: () => false,
+        rateLimited: error => error instanceof TeamsError && error.code === TEAMS_SLOW ? error.retryMs : null,
+    };
+}

package/dist/teams.js

@@ -8,7 +8,8 @@ import { abortablePause, workChatQueue } from "./chat-follow.js";
 import { ChatState } from "./chat-delivery-state.js";
 import { chatObject as object } from "./chat-delivery.js";
 import { loadTeamsCredentials, teamsAccessToken, teamsApi, verifyTeamsToken, TeamsError } from "./teams-api.js";
-import { deliverTeamsPart, planTeamsNotifications, planTeamsRooms, processTeamsEvent, receiveTeams } from "./teams-chat.js";
+import { deliverTeamsPart, planTeamsNotifications, planTeamsRooms, processTeamsEvent, receiveTeams, teamsAckHooks } from "./teams-chat.js";
+import { runChatAcks } from "./chat-live.js";
 import { limitWords } from "./request-budget.js";
 export const TEAMS_ACTIVITY_BYTES = 64 * 1024;
 export const TEAMS_MESSAGES_PATH = "/teams/messages";
@@ -95,7 +96,7 @@ export async function followTeams(options) {
         options.signal.addEventListener("abort", stop, { once: true });
         const heartbeat = setInterval(() => { if (!same() || !state.lease(credentials.installation, owner, new Date()))
             stop(); }, 10_000);
-        const chat = { ...options, identity: credentials, owner, api: teamsApi(credentials, options.fetcher), canNotify: options.notifications, current: same };
+        const chat = { ...options, identity: credentials, owner, api: teamsApi(credentials, options.fetcher), canNotify: options.notifications, current: same, liveReplies: true };
         try {
             // Connected means the app can sign in; inbound reachability is the operator's endpoint to verify.
             try {
@@ -107,6 +108,8 @@ export async function followTeams(options) {
                 await pause(30_000);
                 continue;
             }
+            // "typing…" on each owner message as it arrives (the receiver saves it, maybe in another process), beside the queue.
+            runChatAcks({ state, installation: credentials.installation, owner, current: same, hooks: teamsAckHooks(chat, state), same, signal: options.signal });
             await workChatQueue({
                 same,
                 ready: () => !(state.retryAt(credentials.installation) > new Date().toISOString()),

package/dist/telegram-lead.d.ts

@@ -2,6 +2,7 @@ import { type PhoneLink } from "./chat-channel.js";
 export { channelRepos as telegramConversationRepos, resolveChannelLead as resolveTelegramLead, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText, CHAT_ACTION_PARITY as TELEGRAM_ACTION_PARITY, parityGaps, type PhoneLink, type ResolvedLead, type ParitySupport } from "./chat-channel.js";
 import { type LeadAsk, type Store, type TelegramBinding } from "./store.js";
 import type { SubscriptionLeadRunner } from "./subscription-chat.js";
+import { type TelegramLiveTiming } from "./telegram-live.js";
 import type { TelegramTransport } from "./telegram.js";
 import { type TelegramCallbackButton, type TelegramUpdate } from "./contracts/telegram-callback.js";
 /** How long one claimed turn may go without a heartbeat before another poller may take it over. */
@@ -39,6 +40,8 @@ export type TelegramConversationOptions = {
         ok: false;
         message: string;
     }>;
+    /** Injected by tests: the live reply's timings (telegram-live.ts); production uses its defaults. */
+    liveTiming?: TelegramLiveTiming;
 };
 /** One Bot API call, the shape telegram.ts injects. */
 export type Transport = TelegramTransport;