toolroll 0.9.96 → 0.9.98

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/reply-voice.d.ts

@@ -0,0 +1,23 @@
+export type ReplyVoice = {
+    /** Characters of the shaped reply. */
+    characters: number;
+    sentences: number;
+    /** The `PLAIN_WORDS` rows said outside code, plus "owner" when the reply calls the person "the owner". */
+    internalWords: string[];
+    /** Opens with its own steps or a filler word ("I checked", "Let me", "Sure,") instead of the answer. */
+    narratedOpening: boolean;
+};
+/** A reply longer than this is counted as long in the eval's report. */
+export declare const LONG_REPLY_CHARACTERS = 320;
+export declare function replyVoice(reply: string): ReplyVoice;
+export type VoiceSummary = {
+    answers: number;
+    medianCharacters: number;
+    /** Share of answers over `LONG_REPLY_CHARACTERS`, from 0 to 1. */
+    longShare: number;
+    /** Internal words said, summed over the answers. */
+    internalWords: number;
+    narratedOpenings: number;
+};
+/** One model's answers, summed up for the report. */
+export declare function summarizeVoice(voices: readonly ReplyVoice[]): VoiceSummary;

package/dist/reply-voice.js

@@ -0,0 +1,37 @@
+/**
+ * How a lead reply reads (docs/plans/lead-voice.md, V3): its length, its sentences, the internal words it says and
+ * whether it opens by describing its own steps. Measured on the shaped text a person sees, never the raw reply.
+ * A measure for the lead-answer eval's report; nothing gates on it and no reply is rewritten from it.
+ */
+import { PLAIN_WORDS } from "./plain-words.js";
+import { shapeReply } from "./reply-shape.js";
+/** A reply longer than this is counted as long in the eval's report. */
+export const LONG_REPLY_CHARACTERS = 320;
+const CODE = /```[\s\S]*?(?:```|$)|`[^`\n]+`/g;
+const OWNER_AS_ADDRESS = /(?<![\w-])the\s+owner(?![\w-])/i;
+const NARRATED_OPENING = /^(?:i\s+checked|i\s+looked\s+at|let\s+me|certainly|sure,)/i;
+export function replyVoice(reply) {
+    const shaped = shapeReply(reply);
+    const prose = shaped.replace(CODE, " ");
+    const internalWords = PLAIN_WORDS.filter(one => one.pattern.test(prose)).map(one => one.never);
+    if (OWNER_AS_ADDRESS.test(prose))
+        internalWords.push("owner");
+    return {
+        characters: shaped.length,
+        sentences: prose.split(/(?<=[.!?])\s+|\n+/).filter(part => /[\p{L}\p{N}]/u.test(part)).length,
+        internalWords,
+        narratedOpening: NARRATED_OPENING.test(shaped.trimStart()),
+    };
+}
+/** One model's answers, summed up for the report. */
+export function summarizeVoice(voices) {
+    const sorted = voices.map(one => one.characters).sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return {
+        answers: voices.length,
+        medianCharacters: sorted.length === 0 ? 0 : sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2,
+        longShare: voices.length === 0 ? 0 : voices.filter(one => one.characters > LONG_REPLY_CHARACTERS).length / voices.length,
+        internalWords: voices.reduce((sum, one) => sum + one.internalWords.length, 0),
+        narratedOpenings: voices.filter(one => one.narratedOpening).length,
+    };
+}

package/dist/scope.d.ts

@@ -796,10 +796,15 @@ export declare function fileAndSealUnderMode(store: Store, input: ScopeInput & {
     detail?: string;
 };
 export declare function approve(store: Store, taskId: string, by: string, now: Date, sawDigest: string, token: string, mutation?: Mutation, 
-/** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it. */
+/** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it.
+ * `typed`: a typed yes to a Start card (one-step-chat.md C5), the message that was the yes, recorded beside the marker. */
 fastStart?: {
     rule: string;
     at: string;
+    typed?: {
+        provider: string;
+        event: string;
+    };
 }, 
 /** A person's own yes in chat (owner's decision, docs/plans/toolroll-cards.md): their tap or signed-in click stands in
  * for a password, so `token` is unused. Every rule below still applies. The caller has proved the person is the one

package/dist/scope.js

@@ -1075,7 +1075,8 @@ export function fileAndSealUnderMode(store, input) {
     });
 }
 export function approve(store, taskId, by, now, sawDigest, token, mutation = {}, 
-/** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it. */
+/** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it.
+ * `typed`: a typed yes to a Start card (one-step-chat.md C5), the message that was the yes, recorded beside the marker. */
 fastStart, 
 /** A person's own yes in chat (owner's decision, docs/plans/toolroll-cards.md): their tap or signed-in click stands in
  * for a password, so `token` is unused. Every rule below still applies. The caller has proved the person is the one
@@ -1216,7 +1217,7 @@ export const APPROVAL_PROOF = "approval proved";
 export const approvalProofDetail = (at, generation, digest, local) => `${new Date(at).toISOString()} · generation ${generation}${local === undefined ? "" : ` · local ${local.generation} ${local.transport}`} · digest ${digest}`;
 /** A fast start's proof: the v1 record proofDetailOf reads, with the marker. `local` keeps the legacy words
  * localSealStandsSql reads, so a local owner's seal stands on the same rule. */
-const fastProofDetail = (fastStart) => (at, generation, digest, local) => JSON.stringify({ v: 1, at: new Date(at).toISOString(), generation, digest, fastStart, ...(local === undefined ? {} : { local: `proof · local ${local.generation} ${local.transport} · seal` }) });
+const fastProofDetail = ({ typed, ...fastStart }) => (at, generation, digest, local) => JSON.stringify({ v: 1, at: new Date(at).toISOString(), generation, digest, fastStart, ...(typed === undefined ? {} : { typed: { provider: typed.provider, event: typed.event } }), ...(local === undefined ? {} : { local: `proof · local ${local.generation} ${local.transport} · seal` }) });
 /** The proof of THIS approval: the approver's own row for these exact bytes (never another approval's words). */
 export function approvalProofOf(store, taskId, by, digest) {
     const rows = store.handle.prepare("SELECT outcome, detail FROM action_ledger WHERE task_id = ? AND action = ? AND actor = ? ORDER BY id DESC LIMIT 50").all(taskId, APPROVAL_PROOF, by);

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";
@@ -779,7 +780,7 @@ export function createChatHandlers(runtime) {
         const cardJson = String(request.headers["accept"] ?? "").includes("application/json") && !body.has("nonce");
         const cardAnswer = (status, ok, said, taskId = null) => respond(response, status, "application/json", JSON.stringify({ ok, said, taskId }));
         if (principal === null)
-            return cardJson ? cardAnswer(403, false, "Your approver standing changed. Sign in again.") : refuse(response, who, 403, "your approver standing changed — sign in again", back);
+            return cardJson ? cardAnswer(403, false, "Your sign-in changed. Sign in again.") : refuse(response, who, 403, "Your sign-in changed. Sign in again.", back);
         if (op === "dismiss") {
             const dismissed = dismissLeadProposal(store, principal, id, now);
             if (cardJson)
@@ -848,7 +849,7 @@ export function createChatHandlers(runtime) {
             return refuse(response, who, 403, "proposals are confirmed from the browser or the CLI");
         const principal = leadPrincipal(who);
         if (principal === null)
-            return refuse(response, who, 403, "your approver standing changed — sign in again", "/chat");
+            return refuse(response, who, 403, "Your sign-in changed. Sign in again.", "/chat");
         const id = Number(url.pathname.split("/")[2]);
         store.sweepCoordinatorProposals(now);
         const back = body.get("return") === null ? "/chat" : safeReturn(body.get("return"));
@@ -918,7 +919,7 @@ export function createChatHandlers(runtime) {
         if (who.role === "approver" && enabled.billing === "subscription" && unbound) {
             const principal = leadPrincipal(who);
             if (principal === null)
-                return wantsJson ? said(403, "your approver standing changed — sign in again") : refuse(response, who, 403, "your approver standing changed — sign in again", back);
+                return wantsJson ? said(403, "Your sign-in changed. Sign in again.") : refuse(response, who, 403, "Your sign-in changed. Sign in again.", back);
             const sentRequest = body.get("request");
             if (sentRequest !== null && (body.getAll("request").length !== 1 || !/^[a-f0-9]{32}$/.test(sentRequest)))
                 return said(409, "This conversation changed. Reload it before sending your message.");
@@ -960,7 +961,7 @@ export function createChatHandlers(runtime) {
             const requestId = sentRequest ?? randomBytes(16).toString("hex");
             const principal = leadPrincipal(who);
             if (principal === null)
-                return wantsJson ? said(403, "your approver standing changed — sign in again") : refuse(response, who, 403, "your approver standing changed — sign in again", back);
+                return wantsJson ? said(403, "Your sign-in changed. Sign in again.") : refuse(response, who, 403, "Your sign-in changed. Sign in again.", back);
             const message = (body.get("message") ?? "").trim();
             if (message === "" || message.length > LEAD_MESSAGE_MAX_CHARS) {
                 return said(400, `a message is 1 to ${LEAD_MESSAGE_MAX_CHARS} characters`, leadSession.id);
@@ -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/chrome.js

@@ -726,7 +726,7 @@ export function workToolRows(scoped = false, _offersChat = false, offersCode = f
         { key: "tasks", href: "/tasks", label: "Task list", hint: "everything, filterable by state" },
         { key: "recipes", href: "/recipes", label: "Recipes", hint: "choose, customize, and reuse a workflow" },
         { key: "workbench", href: "/tasks?scope=all", label: "Every project", hint: "every project's tasks in one list" },
-        { key: "ledger", href: "/ledger", label: "Action ledger", hint: "who acted, what happened, and the result" },
+        { key: "ledger", href: "/ledger", label: "Audit log", hint: "who acted, what happened, and the result" },
         { key: "spend", href: "/spend", label: "Spend", hint: "what agent work cost, and monthly budgets" },
     ];
     return scoped ? rows.filter(row => row.key !== "workbench" && row.key !== "spend") : rows;
@@ -737,7 +737,7 @@ export function settingsRows(scoped = false, offersSettings = false) {
         { key: "fleet", href: "/fleet", label: "Fleet", hint: "who is working, and on what" },
         { key: "caps", href: "/caps", label: "Requirements", hint: "tools and credentials builds need" },
         { key: "people", href: "/people", label: "People", hint: "who can sign in, and what they have done" },
-        { key: "mode", href: "/mode", label: "Operating mode", hint: "the signed posture this repository runs under" },
+        { key: "mode", href: "/mode", label: "Operating mode", hint: "how much this project may do without asking" },
         { key: "system", href: "/system", label: "System", hint: "workers, providers, and grants" },
     ];
     return scoped ? rows.filter(row => row.key === "people" || row.key === "settings") : rows;

package/dist/server/home.d.ts

@@ -1,7 +1,7 @@
 /**
  * Home ("/", UI revamp wave B): one sentence that answers "what needs me?", four counts read from the same work index
- * the Tasks list filters (so a count and the list it opens always agree), what waits on this person grouped by what it
- * asks, what is running, and the lead's message box. Reads only: every act keeps its own route and rules (an agent's
+ * the Tasks list filters (so a count and the list it opens always agree), the work in three groups (Waiting on you,
+ * Working, Done; home-groups.ts), and the lead's message box. Reads only: every act keeps its own route and rules (an agent's
  * question is answered through POST /d/<id>/answer, the same one-click act as its own page).
  */
 import type { BrowserHomeView } from "../browser-workspace.js";
@@ -37,5 +37,6 @@ export declare function homeSentence(needs: number, perProject: readonly {
     name: string;
     needs: number;
 }[], scope: string | null, any: boolean): string;
-/** Home's view for one person and scope, from two reads of the work index (what waits, what runs). */
+/** Home's view for one person and scope, from four reads of the work index (what waits on you, what runs, what waits on
+ * Toolroll, what was done), grouped by the one rule every surface shares (home-groups.ts). */
 export declare function homeView(facts: HomeFacts): BrowserHomeView;

package/dist/server/home.js

@@ -1,15 +1,16 @@
 import { browserWorkActionHref } from "../browser-crew.js";
-import { ASK_LABEL } from "../needs-you.js";
+import { HOME_GROUP_LABEL, homeGroupOf } from "../home-groups.js";
 import { projectName } from "../project.js";
 import { workIndexPage } from "../work-index.js";
 import { relativeAge } from "./chrome.js";
 import { taskHref } from "./http.js";
 const TONE = { attention: "needs", ready: "needs", live: "live", done: "done", problem: "failed", muted: "", neutral: "" };
-const ASKS = ["decide", "review", "unblock"];
 const ASK_WORD = { decide: "Decision", review: "Result", unblock: "Blocked" };
 /** How many waiting rows Home lists; the rest open in Tasks. */
 export const HOME_NEEDS_SHOWN = 30;
 const HOME_RUNNING_SHOWN = 8;
+/** How many rows finished in the last 7 days Home lists; the rest open in Tasks. */
+const HOME_DONE_SHOWN = 8;
 /** "7 need you across 2 projects." — the sentence and the figures read the same totals. */
 export function homeSentence(needs, perProject, scope, any) {
     if (!any)
@@ -51,50 +52,54 @@ function rowOf(store, item, now, multi, canAnswer, closedDoor) {
             : href === null || action === null ? null : { label: action.label, href }, question,
     };
 }
-/** Home's view for one person and scope, from two reads of the work index (what waits, what runs). */
+/** Home's view for one person and scope, from four reads of the work index (what waits on you, what runs, what waits on
+ * Toolroll, what was done), grouped by the one rule every surface shares (home-groups.ts). */
 export function homeView(facts) {
     const { store, now, access, project } = facts;
     const read = (view, limit) => workIndexPage(store, now, access, { view, limit, project, ...(facts.evidenceRoot === undefined ? {} : { root: facts.evidenceRoot }) });
     const needs = read("needs-you", HOME_NEEDS_SHOWN);
     const running = read("running", HOME_RUNNING_SHOWN);
-    // Waiting (docs/plans/plain-toolroll.md P1.4): what Toolroll or another task moves on, with no person asked.
-    const waiting = workIndexPage(store, now, access, { view: "queued", limit: HOME_RUNNING_SHOWN, project, ...(facts.evidenceRoot === undefined ? {} : { root: facts.evidenceRoot }) });
+    // Queued: what waits its turn, or what Toolroll or another task moves on, with no person asked.
+    const waiting = read("queued", HOME_RUNNING_SHOWN);
+    // Done: the Completed list is ordered by completion time, newest first, so its first rows are the newest finished;
+    // only those finished in the last 7 days are listed, and that filter runs before the cap.
+    const completed = read("completed", HOME_DONE_SHOWN);
     const totals = needs.totals;
     // Queued: the Tasks list's own Queued count (the same predicate its view=queued filter lists).
     const queued = totals.queued;
     // Every project is said by name (scope=all): /tasks alone would narrow to the session's open project.
     const scopeQuery = project === null ? "scope=all&" : `project=${encodeURIComponent(project)}&`;
+    // Each figure keeps the name of the list it opens; Done is the whole Completed list, not just this week.
     const counts = [
-        { key: "needs", label: "Needs you", value: totals["needs-you"], href: `/tasks?${scopeQuery}view=needs-you` },
+        { key: "needs", label: HOME_GROUP_LABEL.you, value: totals["needs-you"], href: `/tasks?${scopeQuery}view=needs-you` },
         { key: "running", label: "Running", value: totals.running, href: `/tasks?${scopeQuery}view=running` },
         { key: "queued", label: "Queued", value: queued, href: `/tasks?${scopeQuery}view=queued` },
-        { key: "finished", label: "Finished", value: totals.completed, href: `/tasks?${scopeQuery}view=completed` },
+        { key: "finished", label: HOME_GROUP_LABEL.done, value: totals.completed, href: `/tasks?${scopeQuery}view=completed` },
     ];
-    const multi = project === null && new Set([...needs.items, ...running.items].map(one => one.repo ?? "")).size > 1;
+    // One row per family, in the first group that claims it.
+    const seen = new Set();
+    const take = (items, group) => items.filter(one => {
+        if (homeGroupOf(one) !== group || seen.has(one.rootId))
+            return false;
+        seen.add(one.rootId);
+        return true;
+    });
+    // Waiting on you, in today's order of what it asks: decide (with any row whose ask the index couldn't name, which
+    // still waits on this person and is never lost), then review, then unblock. Each row's chip names its ask.
+    const yours = take(["decide", null, "review", "unblock"].flatMap(ask => needs.items.filter(one => one.ask === ask)), "you");
+    // Working: what runs, then what is queued (waits its turn, or on Toolroll or another task), each read with its own bound.
+    const working = [...take(running.items, "working"), ...take(waiting.items, "working")];
+    const weekAgo = new Date(now.getTime() - 7 * 86_400_000).toISOString();
+    const done = take(completed.items.filter(one => (one.completion?.at ?? one.updatedAt) >= weekAgo), "done").slice(0, HOME_DONE_SHOWN);
+    const multi = project === null && new Set([...yours, ...working, ...done].map(one => one.repo ?? "")).size > 1;
     const groups = [];
-    for (const ask of ASKS) {
-        const rows = needs.items.filter(one => one.ask === ask).map(one => rowOf(store, one, now, multi, facts.canAnswer, facts.closedDoor));
-        if (rows.length > 0)
-            groups.push({ key: ask, label: ASK_LABEL[ask], rows });
+    for (const [key, items] of [["you", yours], ["working", working], ["done", done]]) {
+        if (items.length > 0)
+            groups.push({ key, label: HOME_GROUP_LABEL[key], rows: items.map(one => rowOf(store, one, now, multi, facts.canAnswer, facts.closedDoor)) });
     }
-    // A waiting row whose ask the index couldn't name still waits on this person: it goes under Decide, never lost.
-    const unnamed = needs.items.filter(one => one.ask === null).map(one => rowOf(store, one, now, multi, facts.canAnswer, facts.closedDoor));
-    if (unnamed.length > 0) {
-        const decide = groups.find(one => one.key === "decide");
-        if (decide)
-            decide.rows.push(...unnamed);
-        else
-            groups.unshift({ key: "decide", label: ASK_LABEL.decide, rows: unnamed });
-    }
-    const live = running.items.filter(one => !one.status.views.includes("needs-you")).map(one => rowOf(store, one, now, multi, facts.canAnswer, facts.closedDoor));
-    if (live.length > 0)
-        groups.push({ key: "running", label: "Running", rows: live });
-    const waits = waiting.items.filter(one => one.status.label === "Waiting" && !one.status.views.includes("needs-you")).map(one => rowOf(store, one, now, multi, facts.canAnswer, facts.closedDoor));
-    if (waits.length > 0)
-        groups.push({ key: "waiting", label: "Waiting", rows: waits });
     const perProject = needs.projects.map(one => ({ name: one.repo === null ? "Unplaced" : projectName(one.repo), needs: one.totals["needs-you"] }));
     const any = totals.all > 0 || totals.completed > 0 || (totals.archived ?? 0) > 0;
-    const shown = groups.filter(one => one.key !== "running" && one.key !== "waiting").reduce((sum, one) => sum + one.rows.length, 0);
+    const shown = yours.length;
     return {
         kind: "home",
         say: homeSentence(totals["needs-you"], perProject, project === null ? null : projectName(project), any),

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;