toolroll 0.9.8 → 0.9.10

package/dist/browser-crew.js

@@ -10,6 +10,10 @@ export function browserWorkActionHref(item) {
         return `/d/${decisionId}`;
     if (action.code === 'inspect-decisions')
         return '/';
+    if (action.code === 'sign-in')
+        return '/settings#providers';
+    if (action.code === 'confirm-stopped')
+        return `/t/${encodeURIComponent(item.rootId)}#confirm-stopped`;
     if (action.code === 'open-result' && runId !== null)
         return chatResultHref(taskId, runId);
     if (action.code === 'open-pr' && /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(item.publicationUrl ?? ''))

package/dist/browser-workspace.d.ts

@@ -342,6 +342,16 @@ export type BrowserTaskView = {
     statusHtml: string;
     /** The approval ceremony or its updated terms, exactly as signed. */
     approval: string;
+    /** Confirm it stopped, behind the password, when the status asks for it. */
+    confirmStopped?: {
+        action: string;
+        run: number;
+        checked?: boolean;
+    } | null;
+    /** Build again, in place, when the status asks for it (a result built to an earlier plan). */
+    rebuild?: {
+        action: string;
+    } | null;
     /** Server cards that may need a person now (stop/resume, scope prompt, plan, live attempt). */
     lead: {
         key: string;
@@ -450,9 +460,34 @@ export type BrowserResultPanel = {
     request: string | null;
     /** A browser session may attach feedback to this result's sealed diff. */
     canRequest: boolean;
+    /** Needs you: the one action that resolves it, first and filled; `confirm` posts behind the password. */
+    need: BrowserNeedAction | null;
     /** The feedback section holds only the closed form (no notes, revisions or history). */
     requestQuiet: boolean;
 };
+/** A Needs you action: a link, (Confirm it stopped) a form behind the password, (Build again) one
+ * button, or (on the result itself) Accept, which records the person's acceptance; `note` asks why
+ * when the evidence disagrees. */
+export type BrowserNeedAction = {
+    label: string;
+    href: string | null;
+    confirm: {
+        action: string;
+        run: number;
+        returnTo: string;
+        checked?: boolean;
+    } | null;
+    accept?: {
+        action: string;
+        run: number;
+        returnTo: string;
+        note: string | null;
+    } | null;
+    /** Build again (a result built to an earlier plan): one button, the task page's requeue. */
+    rebuild?: {
+        action: string;
+    } | null;
+};
 export type BrowserResultView = {
     kind: 'result';
     results: {
@@ -891,6 +926,11 @@ export type BrowserCatchUpItem = {
     tone: StatusTone;
     detail: string;
     at: string;
+    /** Needs you: the one action that resolves it. */
+    action?: {
+        label: string;
+        href: string;
+    } | null;
 };
 /** Plan-window use stands in for spend: subscriptions don't bill per run. */
 export type BrowserHome = {

package/dist/builder.d.ts

@@ -369,6 +369,8 @@ export declare const WIP_COMMIT_WORDS = "Work in progress: the agent stopped bef
 /** The short turn a stopped agent's own session is resumed with. */
 export declare function handoffResumePrompt(done: string): string;
 export declare const SERVICE_STOP_WORDS = "Toolroll stopped while this task was building.";
+/** The plain words for images left out of a commit. */
+export declare function evidenceImagesNotice(paths: readonly string[]): string;
 /**
  * What a non-zero agent exit means, in words a person can act on: the
  * harness's own result line names the ending (a turn ceiling, an error

package/dist/builder.js

@@ -59,11 +59,23 @@ import { TELEGRAM_TOKEN_ENVS } from "./names.js";
 import { OPENROUTER_ENV_KEY, auditOf, ALL_CREDENTIAL_ENV } from "./provider.js";
 import { openLiveLog } from "./live.js";
 import { CheckProgressTracker } from "./check-progress.js";
-import { captureParkEvidence, captureTerminalDiff, captureBaseTree, evidenceRoot, handoffName, storeHandoffArtifact, looksLikeProtocolFile, mailboxName, progressFileName, proofFileName, rubricFileName, proposalFileName, quarantineMailboxes, readMailbox, readVerifiedArtifact, scanForSecrets, redactSecretLines, storeEvidence, validateScreenshotBytes, imageDimensions, SCREENSHOT_BYTE_CAP, boundStreamHeadTail } from "./evidence.js";
+import { captureParkEvidence, captureTerminalDiff, captureBaseTree, evidenceRoot, handoffName, isImagePath, WORKTREE_EVIDENCE_DIR, storeHandoffArtifact, looksLikeProtocolFile, mailboxName, progressFileName, proofFileName, rubricFileName, proposalFileName, quarantineMailboxes, readMailbox, readVerifiedArtifact, scanForSecrets, redactSecretLines, storeEvidence, validateScreenshotBytes, imageDimensions, SCREENSHOT_BYTE_CAP, boundStreamHeadTail } from "./evidence.js";
 import { PROOF_LIMITS, parseProof, serializeProof, adjudicate, artifactManifestOnly, sameDiffStatFacts } from "./proof.js";
 import { captureReviewContext } from "./review-context.js";
 import { authoritySnapshotDigest, classifyRevisionAuthority, isMilestoneRegression, milestonesOf, parseExecutionPlanDocument, parsePlanRevisionProposal, parseProgressSnapshot, renderExecutionPlanDocument, PROGRESS_LIMITS, REVISION_LIMITS, } from "./plan.js";
 import { maybeSettleRepairChain } from "./dispose.js";
+import { detachShared, linkInto, linkedKey, promoteInstall, readyCopy, sharedDepsRoot, sharingFor } from "./shared-deps.js";
+/** Where this store keeps shared dependencies; null for an in-memory store, which shares nothing. */
+function sharedDepsRootOf(store) {
+    const file = store.databaseFile();
+    return file === null ? null : sharedDepsRoot(file);
+}
+/** The one line an agent needs when its node_modules is a shared copy: it is read-only, and how to get its own. */
+function sharedDepsBrief(store, worktree) {
+    const root = sharedDepsRootOf(store);
+    return root === null || linkedKey(worktree, root) === null ? "" :
+        "node_modules here links a shared, read-only install. If you change package.json or the lockfile, replace it with your own install first: `rm -rf node_modules && npm install`.\n";
+}
 /**
  * The native shell for an operator-approved repository command. There are
  * exactly two consumers: dependency setup before an agent starts, and the
@@ -668,6 +680,20 @@ export async function build(store, request) {
                     message: "runner custody lapsed before the setup spawn — the lease, the runner, or its repo binding no longer stands",
                 };
             }
+            // Shared dependencies: a checkout whose lockfile already has an installed
+            // copy links it instead of installing its own; a setup that is about to
+            // run never reaches through an old link into a shared copy.
+            const depsRoot = sharedDepsRootOf(store);
+            const sharing = depsRoot === null ? null : sharingFor({ repo: leased.repo, worktree, setup: setupWanted });
+            if (depsRoot !== null)
+                detachShared(worktree, depsRoot);
+            if (depsRoot !== null && sharing !== null) {
+                const ready = readyCopy(depsRoot, sharing.key);
+                if (ready !== null && linkInto(worktree, ready) !== null) {
+                    store.stampWorktreeSetup(worktree, setupWanted.digest);
+                    return null;
+                }
+            }
             const runSetup = request.setup ?? run;
             const shell = approvedCommandShell(setupWanted.command);
             // Setup runs under the stop watch (v52), owned by this run: an
@@ -700,6 +726,9 @@ export async function build(store, request) {
                     message: `the approved setup for ${leased.repo} ${made.timedOut ? `ran past ${Math.round(setupWanted.timeoutMs / 60_000)}m` : `exited ${made.code}`} — ${redactSecretText(firstLine(made.stderr)) || "no stderr"}; no agent spawns in a checkout whose setup failed`,
                 };
             }
+            if (depsRoot !== null && sharing !== null) {
+                promoteInstall({ root: depsRoot, repo: leased.repo, worktree, ...sharing, setupDigest: setupWanted.digest, now: (request.clock ?? (() => now))() });
+            }
             store.stampWorktreeSetup(worktree, setupWanted.digest);
         }
         return null;
@@ -1128,7 +1157,7 @@ export async function build(store, request) {
     // replacement for.
     milestones.length === 0 || planRevisionHash === null
         ? null
-        : { revision: planRevisionNumber, hash: planRevisionHash, milestones, progress, proposal }, scope === null ? [] : flowGoalCuts(store, scope.taskId, scope.goal)) + `\nCanonical signed rubric: ${rubric}. Its statement fields are exact; evidence requirements are separate fields. Do not edit this input. The lead or user reads these criteria directly; no restatement is needed.\n`;
+        : { revision: planRevisionNumber, hash: planRevisionHash, milestones, progress, proposal }, scope === null ? [] : flowGoalCuts(store, scope.taskId, scope.goal)) + `\nCanonical signed rubric: ${rubric}. Its statement fields are exact; evidence requirements are separate fields. Do not edit this input. The lead or user reads these criteria directly; no restatement is needed.\n` + sharedDepsBrief(store, worktree);
     // THE HELD BRANCH (Phase 2, v2 S0d + v6 W8): ownership transfers to the
     // coordinator at the spawn point. Everything build() armed that its
     // finally would have cleared is torn down or handed over HERE — the pulse
@@ -1786,7 +1815,7 @@ export async function settleProviderOutcome(captured, result) {
     // result is that commit, sealed below against the task's original base.
     const made = finishesKeptWork
         ? await keptWorkResult(captured, baseRevision, handoff.conclusion)
-        : await commit(git, worktree, branch, taskId, scope, handoff.conclusion, request.attended === undefined ? scope?.candidate ?? null : null);
+        : await commit(git, worktree, branch, taskId, scope, handoff.conclusion, request.attended === undefined ? scope?.candidate ?? null : null, words => store.addRunNote(request.runId, "Toolroll", words, clock()));
     if (made.ok && made.parked === undefined && made.committed) {
         const newHead = await git(GIT, ["--no-optional-locks", "rev-parse", "HEAD"], { cwd: worktree });
         if (newHead.code === 0) {
@@ -2221,8 +2250,48 @@ async function settleProof(captured, statArtifactId, sealedHead) {
             checkLog.push(attemptLog(label, configured.command, result));
             return result;
         };
-        const first = await runVerification("Project check · attempt 1");
-        if (first.notFound || first.timedOut) {
+        const ownInstallIfChanged = async () => {
+            const depsRoot = sharedDepsRootOf(store);
+            if (depsRoot === null || repo === null)
+                return null;
+            const linked = linkedKey(worktree, depsRoot);
+            const live = linked === null ? null : store.liveWorktreeSetup(repo);
+            if (linked === null || live === null)
+                return null;
+            if (sharingFor({ repo, worktree, setup: live })?.key === linked && readyCopy(depsRoot, linked) !== null)
+                return null;
+            if (!store.proveRunnerCustodyForSpawn(runId, now()))
+                return "custody-lost";
+            detachShared(worktree, depsRoot);
+            const label = "Own install · approved project setup (package.json or lockfile changed)";
+            const setupShell = approvedCommandShell(live.command);
+            const installed = await underStopWatch(store, runId, () => runWithIsolatedDatabase(witnessedRunner(store, runId, now, request.setup ?? run), setupShell.file, setupShell.args, {
+                cwd: worktree,
+                timeoutMs: live.timeoutMs,
+                processGroup: true,
+                owner: runOwnerTag(store, runId),
+                beforeSpawn: () => !stopRequestedFor(store, runId, request.shouldStop),
+                onSpawn: pid => {
+                    request.onProviderSpawn?.(pid);
+                    if (stopRequestedFor(store, runId, request.shouldStop))
+                        throw new Error("the attempt was stopped before spawn custody completed");
+                },
+                envAllowlist: SETUP_ENV_ALLOWLIST,
+                omitEnv: SETUP_ENV_DENYLIST,
+            }));
+            checkOutcomes.push(attemptOutcome(label, installed));
+            noteCheckSuite(label, installed);
+            checkLog.push(attemptLog(label, live.command, installed));
+            if (installed.notFound || installed.timedOut || installed.code !== 0)
+                return "own-install-failed";
+            return await sealedTreeState(request.git ?? run) === "clean" ? null : "setup-changed-files";
+        };
+        const ownInstall = await ownInstallIfChanged();
+        const first = ownInstall === null ? await runVerification("Project check · attempt 1") : null;
+        if (first === null) {
+            verifyCommand = { configured: true, ran: false, attemptFailed: true, failure: ownInstall ?? "own-install-failed" };
+        }
+        else if (first.notFound || first.timedOut) {
             verifyCommand = { configured: true, ran: false, attemptFailed: true, failure: first.timedOut ? "timed-out" : "spawn-failed" };
         }
         else if (!verificationExecutableMissing(first)) {
@@ -2419,7 +2488,7 @@ async function settleProof(captured, statArtifactId, sealedHead) {
                 now,
             });
             if (captureResult !== null) {
-                reviewContext = captureResult.inventory.coverage.map(one => ({ id: one.id, state: one.state, inherited: one.inherited, items: one.items, gaps: one.gaps, priorSupport: one.priorSupport }));
+                reviewContext = captureResult.inventory.coverage.map(one => ({ id: one.id, state: one.state, inherited: one.inherited, items: one.items, gaps: one.gaps, priorSupport: one.priorSupport, ...(one.assets === undefined ? {} : { assets: one.assets }) }));
             }
         }
         catch {
@@ -3230,9 +3299,12 @@ flowCuts = []) {
         "  changed-file inventory or final check results. This applies to no-change",
         "  results too. Put useful caveats in the short handoff; do not invent evidence.",
         "  Run focused checks for your edits. The machine runs the approved full check.",
+        "  Save screenshots and journey output only under evidence/ (the run's",
+        "  evidence folder). They are never committed: images added there are left",
+        "  out of the commit, so do not save them anywhere else in the repository.",
         "  If screenshots are required, capture the actual candidate and list them in",
         `  ${proof}: { "version": 1, "screenshots": [`,
-        '    { "path": "<repository-relative PNG or JPEG>", "caption": "<what it shows>" } ] }.',
+        '    { "path": "<evidence/… PNG or JPEG>", "caption": "<what it shows>" } ] }.',
         `  List at most ${PROOF_LIMITS.screenshots} screenshots, with paths/captions under ${PROOF_LIMITS.evidenceRef} UTF-8 bytes,`,
         "  on one line each; no absolute paths or dot segments. Images must be real,",
         "  at least 320 by 200 pixels. A list is optional; missing required images",
@@ -3355,7 +3427,7 @@ function fence(text) {
  * code and concluded the task needed no change has done its job, and turning
  * that into a failure would teach the loop to prefer writing something.
  */
-async function commit(git, worktree, branch, taskId, scope, summary, preparedCandidate = null) {
+async function commit(git, worktree, branch, taskId, scope, summary, preparedCandidate = null, notice) {
     const status = await git(GIT, ["--no-optional-locks", "status", "--porcelain"], { cwd: worktree });
     if (status.code !== 0) {
         return { ok: false, reason: "commit-failure", message: firstLine(status.stderr) };
@@ -3375,6 +3447,20 @@ async function commit(git, worktree, branch, taskId, scope, summary, preparedCan
     const add = await git(GIT, ["add", "-A", "--", ".", `:!${LEASE_MARKER}`, ":!STANDING-ORDERS-*", ":!NIGHTORDERS-*"], { cwd: worktree });
     if (add.code !== 0)
         return { ok: false, reason: "commit-failure", message: firstLine(add.stderr) };
+    // Screenshots belong to the run's evidence, not the branch. Images added
+    // under evidence/ are unstaged and left on disk, where the proof can still
+    // name them; an exact prepared candidate is compared whole instead.
+    if (preparedCandidate === null) {
+        const stripped = await stripEvidenceImages(git, worktree);
+        if (!stripped.ok)
+            return { ok: false, reason: "commit-failure", message: stripped.message };
+        if (stripped.notice !== null) {
+            notice?.(stripped.notice);
+            summary = `${summary}\n\n${stripped.notice}`;
+            if (!stripped.staged)
+                return { ok: true, committed: false, branch, summary };
+        }
+    }
     // Setup can create untracked files as well as edit tracked manifests.
     // Re-prove the whole staged tree after the normal path exclusions, before
     // committing, so neither can widen an exact prepared candidate.
@@ -3409,6 +3495,26 @@ async function commit(git, worktree, branch, taskId, scope, summary, preparedCan
     }
     return { ok: true, committed: true, branch, summary };
 }
+/** The plain words for images left out of a commit. */
+export function evidenceImagesNotice(paths) {
+    return `Left ${paths.length} image${paths.length === 1 ? "" : "s"} under ${WORKTREE_EVIDENCE_DIR} out of the commit: screenshots belong in the run's evidence, not the repository.`;
+}
+/** Unstage images newly added under evidence/; the files stay on disk. */
+async function stripEvidenceImages(git, worktree) {
+    const added = await git(GIT, ["--no-optional-locks", "diff", "--cached", "--name-only", "-z", "--no-renames", "--diff-filter=A", "--", WORKTREE_EVIDENCE_DIR], { cwd: worktree });
+    if (added.code !== 0)
+        return { ok: false, message: firstLine(added.stderr) };
+    const images = added.stdout.split("\0").filter(path => path !== "" && isImagePath(path));
+    if (images.length === 0)
+        return { ok: true, notice: null, staged: true };
+    for (let at = 0; at < images.length; at += 200) {
+        const removed = await git(GIT, ["rm", "--cached", "--quiet", "--", ...images.slice(at, at + 200).map(path => `:(literal)${path}`)], { cwd: worktree });
+        if (removed.code !== 0)
+            return { ok: false, message: firstLine(removed.stderr) };
+    }
+    const rest = await git(GIT, ["--no-optional-locks", "diff", "--cached", "--quiet"], { cwd: worktree });
+    return { ok: true, notice: evidenceImagesNotice(images), staged: rest.code !== 0 };
+}
 /**
  * `claude --output-format json` returns an envelope: the result is the
  * summary, and the session id is what lets a malformed park be repaired by

package/dist/chat-controls.d.ts

@@ -11,7 +11,7 @@ export declare const CHAT_CONTROLS: {
         readonly target: "task";
     };
     readonly planning: {
-        readonly label: "Review plan";
+        readonly label: "Approve plan";
         readonly target: "task";
     };
     readonly recovery: {

package/dist/chat-controls.js

@@ -4,7 +4,7 @@
 export const CHAT_CONTROLS = {
     task: { label: "Open task", target: "task" },
     approval: { label: "Review & start", target: "task" },
-    planning: { label: "Review plan", target: "task" },
+    planning: { label: "Approve plan", target: "task" },
     recovery: { label: "Review recovery options", target: "task" },
     cancel: { label: "Cancel task", target: "task" },
     result: { label: "Open result", target: "task" },

package/dist/chat-delivery-state.d.ts

@@ -76,6 +76,11 @@ export type ChatContent = {
         label: string;
         path: string;
     };
+    /** More link buttons after `link`: [Look first] beside [Merge] or [Mark complete]. */
+    also?: Array<{
+        label: string;
+        path: string;
+    }>;
     /** A flow decision's buttons ride this part (v88): minted when it is planned. */
     flow?: {
         card: number;

package/dist/chat-delivery.js

@@ -9,7 +9,8 @@ import { answerChatFlowPrompt, applyChatFlowTap, flowDecisionParts } from "./cha
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
 import { triggerConfigOf } from "./flow-triggers.js";
 import { telegramProgressCard } from "./telegram-progress.js";
-import { enqueueEveningDigests, isTaskFact, needsPerson, quietCardView, readyPingView } from "./chat-quiet.js";
+import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
+import { BATCH_MS, chatText, chatTitle } from "./chat-voice.js";
 import { phoneText, PHONE_HELP, phoneCommand, phoneStatus, phoneTaskView, phoneTaskChoices, phoneTaskListText, resolvePhoneTask, phoneFocusText, PHONE_NO_MATCH, PHONE_BACK_TO_LEAD } from "./telegram-status.js";
 import { applyRoomInbound, conversationRow, roomCardApprover, roomCommand, roomGrantAllowed, roomMessagesAfter, roomMessageText, teamDomain } from "./chat-rooms.js";
 import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
@@ -582,7 +583,7 @@ function planQuietCard(options, binding, notification, now) {
     if (notification.taskRef === null || notification.taskId === null)
         return;
     const card = store.chatCardFor(`${state.channel}:${binding.id}`, notification.taskRef, store.getTask(notification.taskId)?.createdAt ?? notification.createdAt, now);
-    const view = quietCardView(store, card.tasks, now, options.evidenceRoot);
+    const view = quietCardView(store, card.tasks, now, options.evidenceRoot, binding.approver);
     if (view === null)
         return;
     const content = { text: view.text, link: view.link, ...(card.tasks.length === 1 ? { task: notification.taskId } : {}) };
@@ -602,6 +603,37 @@ function planQuietCard(options, binding, notification, now) {
     if (part !== undefined)
         store.setChatCardMessage(card.id, String(part.id), shown);
 }
+/** Any update for this person joins their open batch (two minutes from its first), and the batch's one message
+ * is planned once, then repainted in place as more updates land. `notification`: an update that is not a finished
+ * result (null for one that is). False when nothing in the batch reads as a line, so the update goes out on its own. */
+function planFinished(options, binding, taskRef, run, now, notification = null) {
+    const { state, store, identity } = options;
+    const batch = store.chatBatchFor(`${state.channel}:${binding.id}`, taskRef, run, now, BATCH_MS, notification);
+    const view = finishedView(store, batch, now, options.evidenceRoot, binding.approver);
+    if (view === null)
+        return false;
+    // A single update keeps its task and run, so a reply to it names that work.
+    const single = batch.items.length === 1 ? batch.items[0] : null;
+    const task = single === null ? null : store.refById(single.taskRef)?.externalId ?? null;
+    const content = { text: view.text, link: view.link, ...(view.also === undefined ? {} : { also: view.also }),
+        ...(task === null ? {} : { task }), ...(single?.run == null ? {} : { run: single.run }) };
+    const shown = chatHash(JSON.stringify(content));
+    if (batch.message !== null) {
+        if (batch.digest === shown)
+            return true;
+        state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE id=? AND state!='dropped'").run(JSON.stringify(content), now.toISOString(), Number(batch.message));
+        store.setChatBatchMessage(batch.id, batch.message, shown);
+        return true;
+    }
+    const id = chatHash(`${state.channel}:batch:${binding.id}:${batch.id}`);
+    state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+        ts: "", thread: "", payload: "{}", created: now.toISOString() });
+    state.plan(id, [content], now);
+    const part = state.prepare("SELECT id FROM chat_part WHERE event=?").get(id);
+    if (part !== undefined)
+        store.setChatBatchMessage(batch.id, String(part.id), shown);
+    return true;
+}
 /** One progress card per exact result; separate urgent facts retain their own review link. */
 export async function planChatNotifications(options) {
     const state = options.state, { store, identity } = options, bindings = state.bindings(identity.installation).filter(one => state.live(one));
@@ -645,15 +677,19 @@ export async function planChatNotifications(options) {
                         if (!needsPerson(notification))
                             return;
                         if (notification.kind === "run-finished" && run) {
-                            const ping = readyPingView(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot);
-                            state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
-                                ts: "", thread: "", payload: "{}", created: now.toISOString() });
-                            state.plan(id, [{ text: ping.text, task: notification.taskId, run: run.id, link: ping.link }], now);
+                            // Finished work goes out only as the batch line; one left out on purpose (a release check, a replaced
+                            // task, the reader's own completion) stays quiet rather than falling through to another message.
+                            planFinished(options, binding, notification.taskRef, run.id, now);
                             return;
                         }
+                        // Every other update for this person within two minutes joins the same one message.
+                        else if (notification.kind !== "run-finished" && joinsBatch(notification)) {
+                            if (planFinished(options, binding, notification.taskRef, run?.id ?? null, now, notification.id))
+                                return;
+                        }
                     }
                     if (!quiet && run && notification.taskId && notification.project !== null && isTelegramProgressNotification(notification)) {
-                        const card = telegramProgressCard(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot);
+                        const card = telegramProgressCard(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot, binding.approver);
                         const content = {
                             text: card.text,
                             task: notification.taskId,
@@ -726,7 +762,8 @@ export async function planChatNotifications(options) {
                         });
                         state.plan(id, [
                             {
-                                text: phoneText(`${notification.subject}\n\n${notification.body}`, 2500),
+                                // Never the task's id or a "— revision" suffix (chat-voice.ts).
+                                text: chatText(phoneText(notification.body === "" ? notification.subject : `${notification.subject}\n\n${notification.body}`, 2500), notification.taskId === null ? [] : [{ id: notification.taskId, title: chatTitle(store, notification.taskId) }]),
                                 ...(notification.taskId ? { task: notification.taskId } : {}),
                                 ...(run ? { run: run.id } : {}),
                                 ...(notification.link

package/dist/chat-quiet.d.ts

@@ -1,10 +1,12 @@
 import { type ProgressEntity } from "./telegram-progress.js";
 import { type PhoneTaskLink } from "./telegram-status.js";
-import { type Notification, type Run, type Store } from "./store.js";
+import { type ChatBatch, type Notification, type Store } from "./store.js";
+/** `also`: more buttons after `link`, such as [Look first] beside [Merge]. */
 export type QuietView = {
     text: string;
     entities: ProgressEntity[];
     link: PhoneTaskLink;
+    also?: PhoneTaskLink[];
 };
 export declare function needsPerson(row: Pick<Notification, "dedupeKey" | "kind" | "pushClass" | "recipient">): boolean;
 /** A fact about one placed task: in quiet mode it lands on that task's card. */
@@ -14,9 +16,13 @@ export declare function isTaskFact(row: Pick<Notification, "taskRef" | "taskId"
     project: string;
 };
 /** The card's words now: one task's progress card, or one line per task when several were filed together. */
-export declare function quietCardView(store: Store, taskRefs: readonly number[], now: Date, root?: string): QuietView | null;
-/** The one ping for a Ready result: its state and title, what to do next, and a link to that exact result. */
-export declare function readyPingView(store: Store, run: Run, taskId: string, project: string, now: Date, root?: string): QuietView;
+export declare function quietCardView(store: Store, taskRefs: readonly number[], now: Date, root?: string, viewer?: string): QuietView | null;
+/** Whether this update for a person joins their two-minute batch: anything about one task that needs them,
+ * except a fact that must stand alone. */
+export declare function joinsBatch(row: Pick<Notification, "dedupeKey" | "kind" | "pushClass" | "recipient" | "taskRef">): boolean;
+/** One person's update message: one task says what happened with its next step; several updates within two
+ * minutes become "4 tasks finished: …" (or "3 updates: …") with one Open button. Null when none can be read. */
+export declare function finishedView(store: Store, batch: Pick<ChatBatch, "items">, now: Date, root?: string, viewer?: string): QuietView | null;
 /** This computer's local day and time, which is what a person means by "the evening". */
 export declare function localDay(now: Date): string;
 export declare function localTime(now: Date): string;

package/dist/chat-quiet.js

@@ -5,9 +5,10 @@
  * Delivery receipts, claims and retries stay with each transport; the
  * console's activity keeps every fact whatever a chat showed. */
 import { assignmentOf } from "./assignment.js";
-import { chatControlHref } from "./chat-controls.js";
+import { chatControlHref, chatResultHref } from "./chat-controls.js";
 import { telegramProgressCard } from "./telegram-progress.js";
-import { assignmentStatusFacts, headlineEmoji, replacedWords, taskStatusOf } from "./task-status.js";
+import { assignmentStatusFacts, headlineEmoji, taskStatusOf } from "./task-status.js";
+import { asksToFinish, batchLine, chatText, chatTitle, factLinkLabel, mentions, READY_ACTIONS } from "./chat-voice.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { isLifecycleNotification } from "./store.js";
 /** What always makes a new message, even in quiet mode: a question or approval waiting, a failure or other
@@ -49,25 +50,27 @@ const BEFORE_RUN = {
     "task-requeued": before("Queued"),
     "task-cancelled": before("Stopped"),
 };
-function taskLine(store, taskRef, now, root) {
+function taskLine(store, taskRef, now, root, viewer) {
     const ref = store.refById(taskRef);
     if (ref === null || ref.repo === null)
         return null;
     const task = store.getTask(ref.externalId);
-    const title = phoneText(task?.title ?? ref.externalId, 88);
-    // Replaced, never "Cancelled": the card names its successor and links to it.
+    // A short human title: never "— revision" or an id (chat-voice.ts).
+    const title = chatTitle(store, ref.externalId);
+    // Replaced, never "Cancelled": the card says a newer task took over and links to it, without either id.
     const successor = task?.state === "cancelled" ? store.replacementOf(ref.externalId) : null;
     if (successor !== null) {
-        const heading = `${headlineEmoji("Stopped")} ${replacedWords(successor)}`;
-        const text = [title, heading, "", `${projectLabel(ref.repo)} · ${ref.externalId}`].join("\n");
-        return { title, icon: headlineEmoji("Stopped"), status: replacedWords(successor), project: ref.repo, view: {
+        const words = "Replaced by a newer task";
+        const heading = `${headlineEmoji("Stopped")} ${words}`;
+        const text = [title, heading, "", projectLabel(ref.repo)].join("\n");
+        return { title, icon: headlineEmoji("Stopped"), status: words, project: ref.repo, view: {
                 text, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
-                link: { label: `Open ${phoneText(successor, 40)}`, path: chatControlHref("task", successor) },
+                link: { label: "Open the new task", path: chatControlHref("task", successor) },
             } };
     }
     const run = cardRun(store, taskRef);
     if (run !== null) {
-        const view = telegramProgressCard(store, run, ref.externalId, ref.repo, now, root);
+        const view = telegramProgressCard(store, run, ref.externalId, ref.repo, now, root, viewer);
         const heading = view.entities[1] === undefined ? "" : view.text.slice(view.entities[1].offset, view.entities[1].offset + view.entities[1].length);
         const split = heading.indexOf(" ");
         return { title, icon: heading.slice(0, split), status: heading.slice(split + 1), project: ref.repo, view };
@@ -75,15 +78,15 @@ function taskLine(store, taskRef, now, root) {
     const fact = store.latestTaskFact(taskRef);
     const words = task?.state === "cancelled" ? BEFORE_RUN["task-cancelled"] : BEFORE_RUN[fact?.kind ?? ""] ?? BEFORE_RUN["task-filed"];
     const heading = `${words.icon} ${words.status}`;
-    const text = [title, heading, "", `${projectLabel(ref.repo)} · ${ref.externalId}`].join("\n");
+    const text = [title, heading, "", projectLabel(ref.repo)].join("\n");
     return { title, icon: words.icon, status: words.status, project: ref.repo, view: {
             text, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
             link: { label: "Open task", path: chatControlHref("task", ref.externalId) },
         } };
 }
 /** The card's words now: one task's progress card, or one line per task when several were filed together. */
-export function quietCardView(store, taskRefs, now, root) {
-    const lines = taskRefs.map(ref => taskLine(store, ref, now, root)).filter((one) => one !== null);
+export function quietCardView(store, taskRefs, now, root, viewer) {
+    const lines = taskRefs.map(ref => taskLine(store, ref, now, root, viewer)).filter((one) => one !== null);
     if (lines.length === 0)
         return null;
     if (lines.length === 1)
@@ -93,14 +96,76 @@ export function quietCardView(store, taskRefs, now, root) {
     const text = [heading, ...lines.map(one => `${one.icon} ${phoneText(one.title, 60)} · ${one.status}`), "", projects.join(", ")].join("\n");
     return { text, entities: [{ type: "bold", offset: 0, length: heading.length }], link: { label: "Open tasks", path: "/tasks" } };
 }
-/** The one ping for a Ready result: its state and title, what to do next, and a link to that exact result. */
-export function readyPingView(store, run, taskId, project, now, root) {
-    const card = telegramProgressCard(store, run, taskId, project, now, root);
-    const [title = "", shown = ""] = card.entities.map(one => card.text.slice(one.offset, one.offset + one.length));
-    const heading = shown;
-    const next = card.next;
-    const first = `${heading} · ${title}`;
-    return { text: next === "" ? first : `${first}\n${next}`, entities: [{ type: "bold", offset: 0, length: heading.length }], link: card.link };
+/** Facts that carry their own controls or must stand alone (a security alert, a decision, a flow card, a
+ * screenshot, an acceptance packet) are never folded into a batch. */
+const OWN_MESSAGE_KINDS = new Set(["security-release", "secret-detected", "flow-decision", "flow-card", "acceptance-ready", "acceptance-evidence"]);
+/** Whether this update for a person joins their two-minute batch: anything about one task that needs them,
+ * except a fact that must stand alone. */
+export function joinsBatch(row) {
+    return row.taskRef !== null && row.recipient === null && needsPerson(row) && !OWN_MESSAGE_KINDS.has(row.kind) && !/^decision:\d+$/.test(row.dedupeKey);
+}
+/** A few words for an update in a list, and how it counts: "has a plan to review", "failed". */
+function updatePhrase(row) {
+    if (row.kind === "plan-ready")
+        return { phrase: "has a plan to review", headline: "Needs you" };
+    if (row.kind === "report-ready")
+        return { phrase: "has a report to read", headline: "Update" };
+    if (row.kind === "stale-approval" || row.kind === "approval-withdrawn")
+        return { phrase: "needs a fresh approval", headline: "Needs you" };
+    if (row.pushClass === "merge" || row.kind === "pull-request-ready")
+        return { phrase: "is ready to merge", headline: "Update" };
+    if (/fail|exhausted|stalled|fenced/.test(row.kind))
+        return { phrase: "failed", headline: "Failed" };
+    return { phrase: "needs you", headline: "Needs you" };
+}
+/** One task's line in a batch: a finished result in a person's words with its real next step, or another
+ * update in its own words with its own link. */
+function lineOf(store, item, now, root, viewer) {
+    const ref = store.refById(item.taskRef);
+    if (ref === null || ref.repo === null)
+        return null;
+    const summary = chatTitle(store, ref.externalId);
+    const row = item.notification === null ? null : store.notificationById(item.notification);
+    if (row !== null && row.kind !== "run-finished") {
+        // Never the task's id or a "— revision" suffix; the title once, in front unless the words already name it.
+        const words = chatText(phoneText(row.body === "" ? row.subject : `${row.subject}\n\n${row.body}`, 2500), [{ id: ref.externalId, title: summary }]);
+        const { phrase, headline } = updatePhrase(row);
+        return { also: [], link: row.link === null ? { label: "Open task", path: chatControlHref("task", ref.externalId) } : { label: factLinkLabel(row.link), path: row.link },
+            fact: { summary, headline, checks: null, report: false, completedBy: null, update: { words: mentions(words, summary) ? words : `${summary} · ${words}`, phrase } } };
+    }
+    const run = item.run === null ? null : store.getRun(item.run);
+    if (run === null)
+        return null;
+    const card = telegramProgressCard(store, run, ref.externalId, ref.repo, now, root, viewer);
+    const checks = card.facts.checks ?? null;
+    const pullRequest = card.facts.pullRequest?.state === "open";
+    const fact = {
+        summary,
+        headline: card.status.headline,
+        checks: checks === null ? null : checks.level === "off" && checks.status !== "passed" ? "off"
+            : checks.status === "passed" || checks.status === "failed" || checks.status === "not-run" ? checks.status : null,
+        report: card.facts.report === true,
+        completedBy: card.facts.completedBy ?? null,
+        pullRequest,
+        // The lead speaks as "I" for what it did: the work it filed or approved, or the completion it recorded.
+        lead: card.status.headline === "Complete" ? card.completedByLead : store.leadWorkOf(item.taskRef) !== null,
+    };
+    // A result ready for a person offers its real next step, then a look first.
+    if (asksToFinish(fact))
+        return { fact, also: [{ label: READY_ACTIONS.look, path: chatResultHref(ref.externalId, run.id, "changes") }],
+            link: pullRequest ? { label: READY_ACTIONS.merge, path: `/t/${encodeURIComponent(ref.externalId)}#merge` } : { label: READY_ACTIONS.complete, path: chatResultHref(ref.externalId, run.id) } };
+    return { fact, link: card.link, also: [] };
+}
+/** One person's update message: one task says what happened with its next step; several updates within two
+ * minutes become "4 tasks finished: …" (or "3 updates: …") with one Open button. Null when none can be read. */
+export function finishedView(store, batch, now, root, viewer) {
+    const lines = batch.items.map(one => lineOf(store, one, now, root, viewer)).filter((one) => one !== null);
+    if (lines.length === 0)
+        return null;
+    const text = batchLine(lines.map(one => one.fact));
+    if (lines.length > 1)
+        return { text, entities: [], link: { label: "Open", path: "/tasks" } };
+    return { text, entities: [], link: lines[0].link, ...(lines[0].also.length === 0 ? {} : { also: lines[0].also }) };
 }
 // ---- the evening digest ----------------------------------------------------------
 const FAILURE = /fail|exhausted|fenced/;
@@ -118,7 +183,7 @@ export function eveningDigestText(store, account, now, root) {
     const since = new Date(now.getTime() - 86_400_000).toISOString();
     const recent = new Date(now.getTime() - 14 * 86_400_000).toISOString();
     const visible = (row) => row.project !== null && store.accountCanAccess(account, row.project);
-    const title = (taskId) => phoneText(store.getTask(taskId)?.title ?? taskId, 80);
+    const title = (taskId) => chatTitle(store, taskId);
     const finished = new Map(), failed = new Map(), waits = new Map();
     const facts = store.taskFactsSince(recent).filter(visible);
     for (const row of facts) {