toolroll 0.9.9 → 0.9.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.9.10 — 2026-10-02
+
+- **Chat reads like a teammate.** Short messages, outcome first, with real
+  choices: Merge or Mark complete, and Look first. Updates within two minutes
+  arrive as one message. You're never told about your own actions, release
+  checks and replaced tasks stay quiet, and a release sends one "is live" line.
+  The Telegram bot is named Toolroll.
+
 ## 0.9.9 — 2026-10-02
 
 - **Faster, lighter tests.** The unit suite runs about three times faster

package/dist/assignment.js

@@ -409,8 +409,10 @@ function acknowledgeCurrent(store, current, receiptDigest, actor, now, root, acc
         store.recordAction({ at: now.toISOString(), actor, repo: current.repo,
             taskId: current.rootId, runId: receipt.runId, action: CHECK_ACTION, outcome: receiptDigest, source: "work" });
         const ref = store.lookupRef(current.rootId);
+        // Whose act this is, even outside a command that named its person: the operator who marked it.
+        const by = currentActor() ?? (actor.startsWith("operator:") ? { account: actor.slice("operator:".length), lead: false } : null);
         if (ref !== null)
-            store.noteTaskAct(ref.id, "completed", now);
+            store.noteTaskAct(ref.id, "completed", now, undefined, by);
         store.bumpWake();
     }
     const assignment = assignmentOf(store, current.rootId, now, access, root);

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) {

package/dist/chat-voice.d.ts

@@ -0,0 +1,68 @@
+/** How chat sounds: a teammate talking. One or two short sentences, outcome
+ * first, plain words, one action at most. Every chat (Telegram, Slack,
+ * Discord, Teams) takes its titles and its finished-work lines from here, so a
+ * task id, a "— revision" suffix or a person's own act never reaches a chat.
+ * The console keeps every exact name and fact. */
+import type { TelegramTransport } from "./telegram.js";
+import type { Store } from "./store.js";
+/** The bot's display name in every chat app. */
+export declare const BOT_NAME = "Toolroll";
+/** Updates for one person landing within this window become one message, edited in place as it grows. */
+export declare const BATCH_MS: number;
+export declare const SHORT_TITLE_MAX = 60;
+/** A short human summary of a task's title, at most 60 characters: no "— revision", and no task ids. Only the
+ * task's own id and tokens `isTaskId` names as real tasks are dropped; `node-20` and `utf-8` stay. */
+export declare function shortTitle(title: string | null | undefined, taskId?: string | null, isTaskId?: (token: string) => boolean): string;
+/** A task's title as every chat says it: short, with its own id and any other real task's id dropped. */
+export declare function chatTitle(store: Pick<Store, "getTask">, taskId: string): string;
+/** A title inside a sentence or list: "faster tests", but "API keys" and "iOS" keep their capitals. */
+export declare function inSentence(summary: string): string;
+/** The facts one line of a chat update is made of, read from the shared task status. */
+export type FinishedFact = {
+    summary: string;
+    headline: string;
+    checks: "passed" | "failed" | "not-run" | "off" | null;
+    report: boolean;
+    completedBy: string | null;
+    /** An open pull request carries this result: the ask is "Merge it?" rather than "Mark it complete?". */
+    pullRequest?: boolean;
+    /** The lead did this (built it, or marked it complete), so the lead says "I". */
+    lead?: boolean;
+    /** Not a finished result but another update about the task: its own words when it stands alone, and a few
+     * words for a list ("has a plan to review"). */
+    update?: {
+        words: string;
+        phrase: string;
+    } | null;
+};
+/** The two buttons under a result ready for a person: the real next step, then a look first. */
+export declare const READY_ACTIONS: {
+    readonly merge: "Merge";
+    readonly complete: "Mark complete";
+    readonly look: "Look first";
+};
+/** Whether this line asks for the result's next step, so it carries [Merge] or [Mark complete] and [Look first]. */
+export declare function asksToFinish(fact: FinishedFact): boolean;
+/** One update, said plainly: what happened, then what happens next. The lead says "I" for what it did. */
+export declare function finishedLine(fact: FinishedFact): string;
+/** Several updates in one message: "4 tasks finished: faster tests, cleanup, …" (or "3 updates: …" when not all of
+ * them are finished work), then what broke and what happens next. */
+export declare function batchLine(facts: readonly FinishedFact[]): string;
+/**
+ * Name the Telegram bot Toolroll. On pairing it always becomes Toolroll; on upgrade only a bot still called
+ * StandingOrders is renamed, so a name a person chose later is kept. Best effort: a refused or failed call
+ * leaves the old name and never blocks pairing or delivery. Returns whether a rename was sent and accepted.
+ */
+export declare function nameTelegramBot(transport: TelegramTransport, when: "pairing" | "upgrade"): Promise<boolean>;
+/** The last word on any pushed chat text: a task's own id (bare or in brackets), a "— revision" suffix and a
+ * "Replaced by <id>" never reach a chat, whatever words the fact was recorded with. A bare id reads as the
+ * task's short title when one is given, else "this task". */
+export declare function chatText(text: string, tasks?: readonly (string | null | undefined | {
+    id: string;
+    title?: string;
+})[]): string;
+/** The one button a plain fact may carry: its label names where its machine-minted console path goes; nothing in
+ * it comes from the fact's text. */
+export declare function factLinkLabel(path: string): string;
+/** Whether the words already name this title as a whole phrase (so it need not be said twice). */
+export declare function mentions(text: string, title: string): boolean;

package/dist/chat-voice.js

@@ -0,0 +1,175 @@
+import { phoneText } from "./telegram-status.js";
+/** The bot's display name in every chat app. */
+export const BOT_NAME = "Toolroll";
+/** Updates for one person landing within this window become one message, edited in place as it grows. */
+export const BATCH_MS = 2 * 60_000;
+export const SHORT_TITLE_MAX = 60;
+/** A token that could be an id: letters and digits joined by `-` or `_`, or with a digit in it (`release-099b`,
+ * `t42`). Words such as `node-20` and `utf-8` look the same, so a token goes only when it names a real task. */
+const ID_SHAPED = /\(?(?<![\p{L}\p{N}._/-])[\p{L}\p{N}]+(?:[-_.][\p{L}\p{N}]+)*(?![\p{L}\p{N}_/-]|\.[\p{L}\p{N}])\)?/gu;
+/** An id that could be mistaken for nothing else (`release-099b`, `fix_tax`, `t42`). A one-word id such as `tidy`
+ * is also a word, and prose keeps its words. */
+const idLike = (id) => /[-_\d]/.test(id);
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** A short human summary of a task's title, at most 60 characters: no "— revision", and no task ids. Only the
+ * task's own id and tokens `isTaskId` names as real tasks are dropped; `node-20` and `utf-8` stay. */
+export function shortTitle(title, taskId, isTaskId) {
+    let text = phoneText(title ?? "", 400);
+    // "— revision", "- revision 2", "(revision)": a revision is the same work to a person.
+    text = text.replace(/(?:(?:\s*[—–]+|\s+-+)\s*revision\b(?:\s*#?\d+)?|\s*[([]\s*revision(?:\s*#?\d+)?\s*[)\]])/giu, "");
+    text = text.replace(ID_SHAPED, token => {
+        const bare = token.replace(/^\(|\)$/g, "");
+        return idLike(bare) && (bare === taskId || isTaskId?.(bare) === true) ? " " : token;
+    });
+    text = text.replace(/\(\s*\)/g, " ").replace(/\s+/g, " ").replace(/^[\s·:,;—–-]+|[\s·:,;—–-]+$/gu, "").trim();
+    if (text === "") {
+        // A task filed with only its id as a title: the words, never the slug.
+        const words = (taskId ?? "").replace(/[-_]+/g, " ").trim();
+        return words === "" ? "A task" : shortTitle(words[0].toUpperCase() + words.slice(1));
+    }
+    if (text.length <= SHORT_TITLE_MAX)
+        return text;
+    const cut = text.slice(0, SHORT_TITLE_MAX - 1);
+    const space = cut.lastIndexOf(" ");
+    return `${(space > 20 ? cut.slice(0, space) : cut).replace(/[\s·:,;—–-]+$/u, "")}…`;
+}
+/** A task's title as every chat says it: short, with its own id and any other real task's id dropped. */
+export function chatTitle(store, taskId) {
+    return shortTitle(store.getTask(taskId)?.title, taskId, token => token !== taskId && store.getTask(token) !== null);
+}
+/** A title inside a sentence or list: "faster tests", but "API keys" and "iOS" keep their capitals. */
+export function inSentence(summary) {
+    return /^\p{Lu}\p{Ll}/u.test(summary) ? summary[0].toLowerCase() + summary.slice(1) : summary;
+}
+/** The two buttons under a result ready for a person: the real next step, then a look first. */
+export const READY_ACTIONS = { merge: "Merge", complete: "Mark complete", look: "Look first" };
+/** Whether this line asks for the result's next step, so it carries [Merge] or [Mark complete] and [Look first]. */
+export function asksToFinish(fact) {
+    return fact.update == null && fact.headline === "Ready for review" && !fact.report;
+}
+/** One update, said plainly: what happened, then what happens next. The lead says "I" for what it did. */
+export function finishedLine(fact) {
+    if (fact.update != null)
+        return fact.update.words;
+    const name = fact.summary, lower = inSentence(fact.summary);
+    const ready = fact.lead === true ? `I finished ${lower}` : `${name} is ready`;
+    switch (fact.headline) {
+        case "Ready for review":
+            if (fact.report)
+                return fact.lead === true ? `I wrote up ${lower}. The report is ready to read.` : `${name}: the report is ready to read.`;
+            if (fact.checks === "passed")
+                return `${ready}. Your tests passed. ${fact.pullRequest === true ? "Merge it?" : "Mark it complete?"}`;
+            if (fact.checks === "off")
+                return `${ready}. Checks are off for this project, so look it over first.`;
+            return `${ready}, but no tests ran. Look it over first.`;
+        case "Failed":
+            if (fact.checks === "failed")
+                return fact.lead === true
+                    ? `I built ${lower}, but its tests failed. It waits for you: retry or ask for changes.`
+                    : `${name} is built, but its tests failed. It waits for you: retry or ask for changes.`;
+            return fact.lead === true
+                ? `I couldn't finish ${lower}. The work so far is kept; retry when you're ready.`
+                : `${name} stopped before it finished. The work so far is kept; retry when you're ready.`;
+        case "Complete":
+            if (fact.lead === true && fact.completedBy)
+                return `I marked ${lower} complete.`;
+            return fact.completedBy ? `${name} is done. ${fact.completedBy} marked it complete.` : `${name} is done.`;
+        case "Needs you":
+            return fact.lead === true ? `I need your decision on ${lower} before I can go on.` : `${name} needs your decision before it can continue.`;
+        default:
+            return `${name}: ${fact.headline.toLowerCase()}.`;
+    }
+}
+/** One task in a list of updates: "faster tests is ready", "cleanup failed". */
+function phraseOf(fact) {
+    const name = inSentence(fact.summary);
+    if (fact.update != null)
+        return `${name} ${fact.update.phrase}`;
+    switch (fact.headline) {
+        case "Ready for review": return `${name} is ready`;
+        case "Failed": return `${name} failed`;
+        case "Complete": return `${name} is done`;
+        case "Needs you": return `${name} needs you`;
+        default: return `${name}: ${fact.headline.toLowerCase()}`;
+    }
+}
+/** Several updates in one message: "4 tasks finished: faster tests, cleanup, …" (or "3 updates: …" when not all of
+ * them are finished work), then what broke and what happens next. */
+export function batchLine(facts) {
+    if (facts.length === 1)
+        return finishedLine(facts[0]);
+    const finishedOnly = facts.every(one => one.update == null);
+    const names = finishedOnly ? facts.map(one => inSentence(one.summary)) : facts.map(phraseOf);
+    const shown = names.slice(0, 3).join(", ");
+    const first = `${facts.length} ${finishedOnly ? "tasks finished" : "updates"}: ${shown}${names.length > 3 ? ", …" : "."}`;
+    // What happens next: anything that broke or needs a decision waits for the person.
+    const failed = facts.filter(one => one.headline === "Failed");
+    const needs = facts.filter(one => one.headline === "Needs you").length;
+    const broke = failed.length !== 1 ? `${failed.length} failed`
+        : failed[0].checks === "failed" ? `tests failed on ${inSentence(failed[0].summary)}` : `${inSentence(failed[0].summary)} stopped before it finished`;
+    const waits = [
+        ...(failed.length === 0 ? [] : [broke]),
+        ...(needs === 0 ? [] : [needs === facts.length ? "each needs your decision" : `${needs} ${needs === 1 ? "needs" : "need"} your decision`]),
+    ];
+    if (waits.length === 0)
+        return first;
+    const said = waits.join(", and ");
+    return `${first}\n${said[0].toUpperCase()}${said.slice(1)}; ${failed.length + needs === 1 ? "it waits" : "they wait"} for you.`;
+}
+/** The old product name a bot may still wear from before the rename. */
+const OLD_NAME = /standing\s*-?\s*orders/i;
+/**
+ * Name the Telegram bot Toolroll. On pairing it always becomes Toolroll; on upgrade only a bot still called
+ * StandingOrders is renamed, so a name a person chose later is kept. Best effort: a refused or failed call
+ * leaves the old name and never blocks pairing or delivery. Returns whether a rename was sent and accepted.
+ */
+export async function nameTelegramBot(transport, when) {
+    try {
+        const current = await transport("getMyName", {});
+        const name = current.ok ? current.result?.name : undefined;
+        const shown = typeof name === "string" ? name : null;
+        if (shown === BOT_NAME)
+            return false;
+        if (when === "upgrade" && (shown === null || !OLD_NAME.test(shown)))
+            return false;
+        const set = await transport("setMyName", { name: BOT_NAME });
+        return set.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** The last word on any pushed chat text: a task's own id (bare or in brackets), a "— revision" suffix and a
+ * "Replaced by <id>" never reach a chat, whatever words the fact was recorded with. A bare id reads as the
+ * task's short title when one is given, else "this task". */
+export function chatText(text, tasks = []) {
+    let out = text.replace(/(?:(?:[ \t]*[—–]+|[ \t]+-+)[ \t]*revision\b(?:[ \t]*#?\d+)?|[ \t]*[([][ \t]*revision(?:[ \t]*#?\d+)?[ \t]*[)\]])/giu, "");
+    out = out.replace(/\bReplaced by (?!a newer task)[^\s.,;:!?)]+/gu, "Replaced by a newer task");
+    for (const task of tasks) {
+        const id = typeof task === "string" ? task : task?.id;
+        if (!id || !idLike(id))
+            continue;
+        const title = typeof task === "object" && task !== null ? task.title : undefined;
+        out = out.replace(new RegExp(`[ \\t]*\\(${escape(id)}\\)|(?<![\\p{L}\\p{N}_/=-])${escape(id)}(?![\\p{L}\\p{N}_-])`, "gu"), match => match.trimStart().startsWith("(") ? "" : title ?? "this task");
+    }
+    return out;
+}
+/** The one button a plain fact may carry: its label names where its machine-minted console path goes; nothing in
+ * it comes from the fact's text. */
+export function factLinkLabel(path) {
+    if (/^\/review\?result=[^&]+&run=\d+&tab=checks$/.test(path))
+        return "Inspect result";
+    if (/^\/t\/[^?#]+#merge$/.test(path))
+        return "Merge";
+    if (/^\/chat\?task=[^&]+&result=/.test(path))
+        return "Open result";
+    if (/^\/(?:chat\?task=|t\/)/.test(path))
+        return "Open task";
+    if (/^\/d\//.test(path))
+        return "Open decision";
+    return "Open console";
+}
+/** Whether the words already name this title as a whole phrase (so it need not be said twice). */
+export function mentions(text, title) {
+    return new RegExp(`(?<![\\p{L}\\p{N}_-])${escape(title)}(?![\\p{L}\\p{N}_-])`, "u").test(text);
+}

package/dist/discord-chat.js

@@ -273,6 +273,7 @@ export async function deliverDiscordPart(options) {
                     }))
                     : []),
                 ...link(options.origin(), content.link),
+                ...(content.also ?? []).flatMap(one => link(options.origin(), one)),
             ];
         let target = content.edit ?? row.message;
         if (target && content.image && row.uploaded) {

package/dist/operate.js

@@ -198,7 +198,7 @@ import { updateAdmissionPaused, UPDATE_PAUSED } from "./desktop-update-gate.js";
 import { beads } from "./beads.js";
 import { githubIssues } from "./issues.js";
 import { installationStatus, renderInstallationStatus, renderTaskWait, repairStaleStatuses, taskWaitSnapshot } from "./lead-status.js";
-import { latestRelease, newerRelease, notifySecurityRelease, recordRunnerVersion, startUpdateChecks, updateLine } from "./releases.js";
+import { latestRelease, newerRelease, notifySecurityRelease, notifyVersionLive, recordRunnerVersion, startUpdateChecks, updateLine } from "./releases.js";
 import { installMethod } from "./install-method.js";
 import { PACKAGE_VERSION } from "./version.js";
 /**
@@ -7324,6 +7324,11 @@ async function runWatchLoop(args) {
     // attributes to this episode by runner and window, and `brief
     // --latest-watch` bounds itself to exactly it.
     store.startWatchEpisode({ repo, runner, incarnation }, new Date());
+    // A deploy's one chat line, "Toolroll <version> is live.", when this worker last ran an older version.
+    try {
+        notifyVersionLive(store, dirname(context.databaseFile), PACKAGE_VERSION, new Date());
+    }
+    catch { /* A display fact; never blocks the worker. */ }
     recordRunnerVersion(dirname(context.databaseFile), runner, PACKAGE_VERSION, new Date());
     args.onReady?.();
     // Once per worker start, before any pass: statuses an older build left
@@ -8613,6 +8618,10 @@ async function upCommand(flags, context) {
         });
     };
     observeReadiness();
+    try {
+        notifyVersionLive(context.store, dirname(context.databaseFile), PACKAGE_VERSION, clock());
+    }
+    catch { /* A display fact; never blocks the worker. */ }
     recordRunnerVersion(dirname(context.databaseFile), runnerName, PACKAGE_VERSION, clock());
     const runnerHeartbeat = setInterval(() => {
         const beat = heartbeatRunner(store, runnerName, runnerToken, clock());

package/dist/project-delete.js

@@ -232,6 +232,7 @@ function deleteRows(store, repo, d, now) {
     del("telegram_conversation", IN("id"), conversations);
     del("telegram_outbound_message", `project = ? OR ${IN("notification")} OR ${IN("task_ref")} OR ${IN("source_run")}`, repo, notifications, T, R);
     del("chat_card_task", IN("task_ref"), T);
+    del("chat_batch_item", IN("task_ref"), T);
     del("push_delivery", IN("notification"), notifications);
     del("notification_actor", IN("notification"), notifications);
     del("notification_delivery", IN("notification"), notifications);

package/dist/releases.d.ts

@@ -83,3 +83,12 @@ export declare function latestVersionNow(io?: {
 }): Promise<{
     version: string;
 }>;
+/** What a release says about itself in one line ("Release 0.9.9: lighter tests, cleaner status"), when its notes
+ * have such a line; null otherwise. */
+export declare function releaseSummary(notes: string, version: string): string | null;
+/**
+ * A deploy says one thing in chat: "Toolroll 0.9.9 is live." (with the release's own one-line summary when its
+ * notes have one). Once per version, addressed to each instance operator, and only when a worker on this
+ * computer last ran an older version: a fresh install is not news. Call before recording this runner's version.
+ */
+export declare function notifyVersionLive(store: Store, dir: string, version: string, now: Date): number;

package/dist/releases.js

@@ -236,3 +236,33 @@ export async function latestVersionNow(io = {}) {
         throw new Error("npm did not name a version");
     return { version };
 }
+/** What a release says about itself in one line ("Release 0.9.9: lighter tests, cleaner status"), when its notes
+ * have such a line; null otherwise. */
+export function releaseSummary(notes, version) {
+    const escaped = version.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const line = new RegExp(`^\\s*(?:#{1,6}\\s*)?(?:Toolroll\\s+)?(?:Release\\s+)?v?${escaped}\\s*[:—–-]\\s*(.+?)\\s*$`, "im").exec(notes);
+    const summary = line?.[1]?.replace(/[*_`]/g, "").replace(/\s+/g, " ").replace(/[.\s]+$/, "").trim() ?? "";
+    if (summary === "")
+        return null;
+    return summary.length <= 80 ? summary : `${summary.slice(0, 79).replace(/[\s,;:]+\S*$/, "")}…`;
+}
+/**
+ * A deploy says one thing in chat: "Toolroll 0.9.9 is live." (with the release's own one-line summary when its
+ * notes have one). Once per version, addressed to each instance operator, and only when a worker on this
+ * computer last ran an older version: a fresh install is not news. Call before recording this runner's version.
+ */
+export function notifyVersionLive(store, dir, version, now) {
+    const before = runnerVersions(dir);
+    if (!VERSION.test(version) || !before.some(one => isNewer(version, one.version)) || before.some(one => isNewer(one.version, version)))
+        return 0;
+    const cached = cachedRelease(dir);
+    const summary = cached?.version === version ? releaseSummary(cached.notes, version) : null;
+    const line = summary === null ? `Toolroll ${version} is live.` : `Toolroll ${version} is live: ${summary}.`;
+    let queued = 0;
+    for (const recipient of store.accountFacts().map(one => one.name).filter(name => store.isInstanceOperator(name))) {
+        if (store.enqueueNotification({ dedupeKey: `release:live:${version}:${recipient}`, kind: "version-live", subject: line, body: "",
+            recipient, source: { installation: true } }, now))
+            queued++;
+    }
+    return queued;
+}

package/dist/slack-chat.js

@@ -360,6 +360,8 @@ export async function deliverSlackPart(options) {
                     }))
                     : []),
                 ...linkButton(options.origin(), content.link),
+                // [Look first] beside [Merge] or [Mark complete]: each button's own action id.
+                ...(content.also ?? []).flatMap((one, index) => linkButton(options.origin(), one).map(button => ({ ...button, action_id: `toolroll_link_${index + 2}` }))),
             ];
         const target = content.edit ?? row.message;
         const args = {

package/dist/store.d.ts

@@ -990,6 +990,18 @@ export type ChatCard = {
     digest: string | null;
     tasks: number[];
 };
+export type ChatBatch = {
+    id: number;
+    destination: string;
+    openedAt: string;
+    message: string | null;
+    digest: string | null;
+    items: {
+        taskRef: number;
+        run: number | null;
+        notification: number | null;
+    }[];
+};
 /**
  * What one recovery walk over a gone runner's work settled (P0.1a): the run
  * ids it finished as failed/interrupted and the built-in task ids it returned
@@ -4609,6 +4621,7 @@ export declare class Store {
     enqueueEpisode(prefix: string, notification: Omit<NotificationInput, "dedupeKey">, suffix: string, now: Date): boolean;
     /** Close every open episode under a prefix — the fault is provably gone. */
     resolveEpisodes(prefix: string, now: Date): number;
+    notificationById(id: number): Notification | null;
     notificationsAfter(id: number, limit?: number): Notification[];
     listNotifications(only?: "pending" | "all"): Notification[];
     recordDelivery(id: number, outcome: {
@@ -7477,6 +7490,12 @@ export declare class Store {
      * and the evening digest keep every fact either way.
      */
     pingAllowed(row: Pick<Notification, "id" | "kind" | "recipient" | "project" | "taskRef">, account: string): boolean;
+    /** Who last completed or cancelled this task, when that is still its latest act: null otherwise. A revision's
+     * completion is recorded on its root, so an act on a task it revises counts too, but only one made after this
+     * revision was filed: settling older work never silences a newer revision, whose failures still reach people. */
+    settledBy(taskRef: number): string | null;
+    /** A release check, a replaced task, or one a revision superseded: its facts stay in the console. */
+    neverPings(taskRef: number): boolean;
     /** The lead's work, which messages nobody: unless it is a security alert or a failure with nothing left for the lead. */
     leadQuiet(row: Pick<Notification, "id" | "kind" | "taskRef">, actor?: Actor | null): boolean;
     /** A failure with nothing left for the lead to do: its attempts are spent, or the task has failed for good. */
@@ -7492,6 +7511,11 @@ export declare class Store {
     } | null;
     /** Task-bound facts recorded since an instant, newest last (bounded): what an evening digest reads. */
     taskFactsSince(since: string, limit?: number): Notification[];
+    /** The one message this update joins: the destination's batch opened within `windowMs`, or a new one. A task
+     * has one line in it, saying its newest update (`notification`; null for a finished result). */
+    chatBatchFor(destination: string, taskRef: number, run: number | null, now: Date, windowMs: number, notification?: number | null): ChatBatch;
+    chatBatch(id: number): ChatBatch | null;
+    setChatBatchMessage(id: number, message: string, digest: string): void;
     /** The message now showing this card, and what it shows. */
     setChatCardMessage(id: number, message: string, digest: string): void;
     markTelegramDigestSent(now: Date): void;

package/dist/store.js

@@ -139,7 +139,8 @@ CREATE TABLE IF NOT EXISTS monitoring_status (
  * every step, and an optional evening digest at a local HH:MM. `digest_on` is the local day the last evening
  * digest was considered, so each day is judged once. A task's card is the one chat message a destination keeps
  * for it (or for several tasks filed within a minute): `message` is the Telegram message id or the chat app's
- * part id, `digest` the text last shown, so an unchanged card is never re-sent. */
+ * part id, `digest` the text last shown, so an unchanged card is never re-sent. A `chat_batch` is one person's
+ * finished-work message: every result that lands within two minutes of its first joins it, edited in place. */
 const QUIET_CHAT_SCHEMA = `
 CREATE TABLE IF NOT EXISTS notification_preference (
   account    TEXT PRIMARY KEY,
@@ -166,6 +167,21 @@ CREATE TABLE IF NOT EXISTS chat_card_task (
   PRIMARY KEY (destination, task_ref)
 );
 CREATE INDEX IF NOT EXISTS chat_card_task_card ON chat_card_task(card);
+CREATE TABLE IF NOT EXISTS chat_batch (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  destination TEXT NOT NULL,
+  opened_at   TEXT NOT NULL,
+  message     TEXT,
+  digest      TEXT
+);
+CREATE INDEX IF NOT EXISTS chat_batch_destination ON chat_batch(destination, opened_at);
+CREATE TABLE IF NOT EXISTS chat_batch_item (
+  batch     INTEGER NOT NULL REFERENCES chat_batch(id),
+  task_ref  INTEGER NOT NULL,
+  run       INTEGER,
+  joined_at TEXT NOT NULL,
+  PRIMARY KEY (batch, task_ref)
+);
 `;
 /** Pings follow responsibility (no version bump: additive only). `lead_credential` is a lead token: an agent acting
  * for `owner`, only its hash kept. `task_act` is who filed, approved, cancelled, completed or handed on a task
@@ -3826,6 +3842,8 @@ function initializeStore(db, file) {
     db.exec(POLICY_SCHEMA);
     db.exec(RUN_CHECK_SCHEMA);
     db.exec(QUIET_CHAT_SCHEMA);
+    // The update a batch line speaks for: its newest fact about that task (null: a finished result).
+    addColumn(db, "chat_batch_item", "notification", "INTEGER");
     db.exec(LEAD_QUIET_SCHEMA);
     mergeCheckTables(db);
     addColumn(db, "monitoring_status", "target", "TEXT");
@@ -15092,6 +15110,10 @@ export class Store {
             .run(now.toISOString(), head.length, head);
         return Number(changes);
     }
+    notificationById(id) {
+        const row = this.db.prepare("SELECT * FROM notification WHERE id = ?").get(id);
+        return row === undefined ? null : readNotification(row);
+    }
     notificationsAfter(id, limit = 100) {
         return this.db.prepare("SELECT * FROM notification WHERE id>? ORDER BY id LIMIT ?").all(id, Math.max(1, Math.min(100, limit))).map(readNotification);
     }
@@ -22197,6 +22219,7 @@ export class Store {
      * and the evening digest keep every fact either way.
      */
     pingAllowed(row, account) {
+        // A security alert always pings, ahead of every rule below: own acts, settled, replaced or release-check tasks.
         if (SECURITY_KINDS.has(row.kind) || row.kind === "evening-digest")
             return true;
         if (row.recipient !== null && row.kind === "task-ask")
@@ -22206,10 +22229,42 @@ export class Store {
             return false;
         if (row.recipient !== null)
             return true;
+        // A task this person (or their lead) completed or cancelled is settled for them: nothing more about it.
+        // Release checks and replaced or superseded tasks never ping anyone; a deploy says "is live" instead.
+        if (row.taskRef !== null && (this.settledBy(row.taskRef) === account || this.neverPings(row.taskRef)))
+            return false;
         if (this.leadQuiet(row, actor))
             return false;
         return row.project === null || this.db.prepare("SELECT 1 AS hit FROM project_mute WHERE account = ? AND repo = ?").get(account, row.project) === undefined;
     }
+    /** Who last completed or cancelled this task, when that is still its latest act: null otherwise. A revision's
+     * completion is recorded on its root, so an act on a task it revises counts too, but only one made after this
+     * revision was filed: settling older work never silences a newer revision, whose failures still reach people. */
+    settledBy(taskRef) {
+        const ancestors = [];
+        for (let at = 0, from = taskRef; at < 20; at++) {
+            const parent = this.db.prepare(`SELECT p.id FROM task_ref c JOIN task_ref p ON p.backend = c.backend AND p.external_id = c.revision_of AND p.repo IS c.repo
+        WHERE c.id = ?`).get(from);
+            if (parent === undefined || from === Number(parent["id"]) || ancestors.includes(Number(parent["id"])))
+                break;
+            from = Number(parent["id"]);
+            ancestors.push(from);
+        }
+        const filed = this.db.prepare("SELECT t.created_at FROM task_ref r JOIN task t ON t.id = r.external_id AND r.backend = ? WHERE r.id = ?").get(BUILT_IN, taskRef);
+        const since = filed === undefined || ancestors.length === 0 ? null : String(filed["created_at"]);
+        const last = since === null
+            ? this.db.prepare("SELECT act, account FROM task_act WHERE task_ref = ? ORDER BY id DESC LIMIT 1").get(taskRef)
+            : this.db.prepare(`SELECT act, account FROM task_act WHERE task_ref = ? OR (task_ref IN (${ancestors.map(() => "?").join(", ")}) AND at >= ?)
+          ORDER BY id DESC LIMIT 1`).get(taskRef, ...ancestors, since);
+        return last !== undefined && (last["act"] === "completed" || last["act"] === "cancelled") ? String(last["account"]) : null;
+    }
+    /** A release check, a replaced task, or one a revision superseded: its facts stay in the console. */
+    neverPings(taskRef) {
+        return this.db.prepare(`SELECT 1 AS hit FROM task_ref r WHERE r.id = ? AND (
+        EXISTS (SELECT 1 FROM run JOIN run_check rc ON rc.run = run.id WHERE run.task_ref = r.id AND rc.release = 1)
+        OR EXISTS (SELECT 1 FROM task_replacement x WHERE x.task_ref = r.id)
+        OR EXISTS (SELECT 1 FROM task_ref c WHERE c.backend = r.backend AND c.revision_of = r.external_id AND c.repo IS r.repo))`).get(taskRef) !== undefined;
+    }
     /** The lead's work, which messages nobody: unless it is a security alert or a failure with nothing left for the lead. */
     leadQuiet(row, actor = this.notificationActor(row.id)) {
         if (SECURITY_KINDS.has(row.kind))
@@ -22262,6 +22317,32 @@ export class Store {
         return this.db.prepare("SELECT * FROM notification WHERE created_at >= ? AND task_ref IS NOT NULL AND project IS NOT NULL ORDER BY id DESC LIMIT ?")
             .all(since, limit).map(readNotification).reverse();
     }
+    /** The one message this update joins: the destination's batch opened within `windowMs`, or a new one. A task
+     * has one line in it, saying its newest update (`notification`; null for a finished result). */
+    chatBatchFor(destination, taskRef, run, now, windowMs, notification = null) {
+        return this.transact(() => {
+            const open = this.db.prepare("SELECT id FROM chat_batch WHERE destination = ? AND opened_at > ? AND opened_at <= ? ORDER BY id DESC LIMIT 1")
+                .get(destination, new Date(now.getTime() - windowMs).toISOString(), now.toISOString());
+            const batch = open !== undefined ? Number(open["id"])
+                : Number(this.db.prepare("INSERT INTO chat_batch (destination, opened_at) VALUES (?, ?)").run(destination, now.toISOString()).lastInsertRowid);
+            this.db.prepare(`INSERT INTO chat_batch_item (batch, task_ref, run, joined_at, notification) VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT (batch, task_ref) DO UPDATE SET run = excluded.run, notification = excluded.notification`).run(batch, taskRef, run, now.toISOString(), notification);
+            return this.chatBatch(batch);
+        });
+    }
+    chatBatch(id) {
+        const row = this.db.prepare("SELECT * FROM chat_batch WHERE id = ?").get(id);
+        if (row === undefined)
+            return null;
+        const items = this.db.prepare("SELECT task_ref, run, notification FROM chat_batch_item WHERE batch = ? ORDER BY joined_at, task_ref").all(id)
+            .map(one => ({ taskRef: Number(one["task_ref"]), run: one["run"] == null ? null : Number(one["run"]),
+            notification: one["notification"] == null ? null : Number(one["notification"]) }));
+        return { id, destination: String(row["destination"]), openedAt: String(row["opened_at"]), message: row["message"] == null ? null : String(row["message"]),
+            digest: row["digest"] == null ? null : String(row["digest"]), items };
+    }
+    setChatBatchMessage(id, message, digest) {
+        this.db.prepare("UPDATE chat_batch SET message = ?, digest = ? WHERE id = ?").run(message, digest, id);
+    }
     /** The message now showing this card, and what it shows. */
     setChatCardMessage(id, message, digest) {
         this.db.prepare("UPDATE chat_card SET message = ?, digest = ? WHERE id = ?").run(message, digest, id);

package/dist/teams-chat.js

@@ -195,7 +195,7 @@ export async function deliverTeamsPart(options) {
             const flow = content.flow ? chatFlowButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label, data: { so: one.token }, ...(one.action === "approve" ? { style: "positive" } : {}) })) : [];
             // A teammate's question (v93): its options, then "Answer in words".
             const asked = content.question ? chatQuestionButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label.slice(0, 80), data: { so: one.token } })) : [];
-            actions = [...flow, ...asked, ...openUrlAction(options.origin(), content.link)];
+            actions = [...flow, ...asked, ...openUrlAction(options.origin(), content.link), ...(content.also ?? []).flatMap(one => openUrlAction(options.origin(), one))];
         }
         const target = content.edit ?? row.message;
         const body = actions.length || content.proposal ? teamsCard(text, actions) : { type: "message", text, textFormat: "plain" };

package/dist/telegram-progress.d.ts

@@ -1,5 +1,6 @@
 import { type PhoneTaskLink } from "./telegram-status.js";
 import type { Run, Store } from "./store.js";
+import { type TaskStatus, type TaskStatusFacts } from "./task-status.js";
 /** Offsets are UTF-16, as required by Telegram. Only our two headings are bold;
  * user text stays literal, including angle brackets and Markdown characters. */
 export type ProgressEntity = {
@@ -7,9 +8,13 @@ export type ProgressEntity = {
     offset: number;
     length: number;
 };
-export declare function telegramProgressCard(store: Store, run: Run, taskId: string, project: string, now?: Date, root?: string): {
+/** `viewer`: the person whose chat shows the card. Their own act is never told back to them. */
+export declare function telegramProgressCard(store: Store, run: Run, taskId: string, project: string, now?: Date, root?: string, viewer?: string): {
     text: string;
     entities: ProgressEntity[];
     link: PhoneTaskLink;
     next: string;
+    status: TaskStatus;
+    facts: TaskStatusFacts;
+    completedByLead: boolean;
 };

package/dist/telegram-progress.js

@@ -8,6 +8,7 @@ import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, taskStatusOf } from "./task-status.js";
+import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
 /** The saved assignment for this exact result, or null when the run is not
@@ -21,7 +22,8 @@ function assignmentFor(store, run, taskId, project, now, root) {
         return null;
     }
 }
-export function telegramProgressCard(store, run, taskId, project, now = new Date(), root) {
+/** `viewer`: the person whose chat shows the card. Their own act is never told back to them. */
+export function telegramProgressCard(store, run, taskId, project, now = new Date(), root, viewer) {
     const built = run.finishedAt !== null && (run.outcome === "built" || run.outcome === "no-change");
     const assignment = built ? assignmentFor(store, run, taskId, project, now, root) : null;
     const publication = store.publicationForRun(run.id);
@@ -72,20 +74,25 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     else {
         facts = { stage: "failed", reason: "The build stopped before it finished. Inspect the blocker, then retry." };
     }
+    // "Marked complete by <you>" (or by your lead, which signs in as you) is never told back to you.
+    const completer = assignment?.completion?.actor.replace(/^(?:operator|coordinator|lead):/, "") ?? null;
+    if (viewer !== undefined && facts.completedBy != null && (completer === viewer || facts.completedBy === viewer))
+        facts = { ...facts, completedBy: null };
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
     const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];
-    const title = phoneText(store.getTask(taskId)?.title ?? taskId, 88);
+    // A short human title: never "— revision" or an id (chat-voice.ts).
+    const title = chatTitle(store, taskId);
     const heading = `${headlineEmoji(status.headline)} ${status.headline}`;
     const next = phoneText(status.sentence, 200);
     // A person's acceptance is its own recorded decision; it never changes a check.
     const acceptance = store.proofAcceptance(run.id) === null ? [] : [manualReviewOnly(store.proofVerdictFor(run.id))
             ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged"];
     const rows = [...statusDetailLines(status), ...progress, ...acceptance];
-    const text = [title, heading, next, ...(rows.length === 0 ? [] : ["", ...rows]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
+    const text = [title, heading, next, ...(rows.length === 0 ? [] : ["", ...rows]), "", projectLabel(project)].join("\n");
     const failedChecks = status.details.some(one => one.key === "checks" && (one.mark === "failed" || one.mark === "note"));
     const recovery = operatorHold !== undefined || accessBlocked || (!built && run.outcome !== null);
-    return { text, next, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
+    return { text, next, status, facts, completedByLead: assignment?.completion?.lead === true, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
         // Needs you: the button names the action that resolves it.
         link: { label: status.need != null && status.need.key !== "other" && status.need.key !== "review-result" ? status.need.action.label : built ? "Open result" : "Open task", path: recovery
                 ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, failedChecks ? "checks" : "summary") : chatControlHref("task", taskId) } };

package/dist/telegram-status.d.ts

@@ -72,4 +72,5 @@ export declare function phoneTaskView(store: Store, repos: readonly string[], id
     run: number | null;
 };
 /** Concise display only: authorization uses the stored full project identity. */
-export declare function notificationIdentity(row: Pick<Notification, "project" | "taskId">): string;
+/** Where a fact belongs: its project and, given one, the task's short title — never the task's id. */
+export declare function notificationIdentity(row: Pick<Notification, "project" | "taskId">, title?: string): string;

package/dist/telegram-status.js

@@ -271,8 +271,9 @@ export function phoneTaskView(store, repos, id, now) {
     });
 }
 /** Concise display only: authorization uses the stored full project identity. */
-export function notificationIdentity(row) {
+/** Where a fact belongs: its project and, given one, the task's short title — never the task's id. */
+export function notificationIdentity(row, title) {
     if (row.project === null)
         return "";
-    return `${projectLabel(row.project)}${row.taskId === null ? "" : ` / ${plain(row.taskId, 64)}`} · `;
+    return `${projectLabel(row.project)}${row.taskId === null || title === undefined ? "" : ` / ${plain(title, 64)}`} · `;
 }

package/dist/telegram.d.ts

@@ -227,4 +227,4 @@ export declare function followBridge(store: Store, options: {
 /** The digest text: a header with the count and the window, then one
  * fact per entry — its subject, then its body's first line, indented.
  * Plain text, no buttons: nothing in a digest is tappable. */
-export declare function digestText(rows: readonly Notification[], since: string | null, now: Date): string;
+export declare function digestText(rows: readonly Notification[], since: string | null, now: Date, titleOf?: (taskId: string) => string): string;

package/dist/telegram.js

@@ -29,7 +29,8 @@ import { join } from "node:path";
 import { validateNote } from "./decision.js";
 import { isLifecycleNotification, isTelegramProgressNotification, TELEGRAM_HOLD_REASONS } from "./store.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, factLinkLabel, mentions, nameTelegramBot } from "./chat-voice.js";
 import { applyTeamInbound, deliverTeamChats, teamCommand } from "./telegram-team.js";
 import { applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowDecisionAt } from "./telegram-flow.js";
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
@@ -438,6 +439,8 @@ export async function followBridge(store, options) {
                     await transport("setMyCommands", { commands: TELEGRAM_COMMANDS });
                 }
                 catch { /* typed commands still work */ }
+                // After an upgrade, a bot still called StandingOrders becomes Toolroll, once per start; any other name is kept.
+                await nameTelegramBot(transport, "upgrade");
             }
             const startedAt = Date.now();
             const report = { sent: 0, answered: 0, paired: 0, ignored: 0, backlog: false, problems: [] };
@@ -514,21 +517,25 @@ async function processConversations(store, botId, transport, owner, clock, repor
         report.chatRefused = (report.chatRefused ?? 0) + chat.refused;
     report.problems.push(...chat.problems);
 }
-/** The one button a plain fact may carry: its machine-minted console path
- * under the trusted origin read now — the same road `/task` uses. The label
- * names where the path goes; nothing in it comes from the fact's text. */
-function factLinkLabel(path) {
-    if (/^\/review\?result=[^&]+&run=\d+&tab=checks$/.test(path))
-        return "Inspect result";
-    if (/^\/t\/[^?#]+#merge$/.test(path))
-        return "Merge";
-    if (/^\/chat\?task=[^&]+&result=/.test(path))
-        return "Open result";
-    if (/^\/(?:chat\?task=|t\/)/.test(path))
-        return "Open task";
-    if (/^\/d\//.test(path))
-        return "Open decision";
-    return "Open console";
+/** A fact's own next-action button row under the trusted origin read now; none without one. */
+function factButton(phoneOrigin, link) {
+    try {
+        return phoneLinkButton(phoneOrigin?.() ?? null, { label: factLinkLabel(link), path: link });
+    }
+    catch {
+        return null;
+    }
+}
+/** A view's buttons on one row: its link, then any others ([Merge] [Look first]); none without a trusted origin. */
+function viewKeyboard(phoneOrigin, view) {
+    try {
+        const origin = phoneOrigin?.() ?? null;
+        const row = [view.link, ...(view.also ?? [])].flatMap(link => phoneLinkButton(origin, link) ?? []);
+        return row.length === 0 ? [] : [row];
+    }
+    catch {
+        return [];
+    }
 }
 /** Team-conversation traffic to the chats that follow one — after the outbox, under the same delivery switch, never a problem to raise when nothing follows anything. */
 async function deliverTeam(store, botId, transport, clock, report, readProjects, canDeliver, phoneOrigin) {
@@ -720,7 +727,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             const messageId = store.telegramProgressMessage(binding, progressRun);
             if (messageId === null && onlyExisting)
                 return null;
-            const card = telegramProgressCard(store, store.getRun(progressRun.id), row.taskId, row.project, clock(), evidenceRoot);
+            const card = telegramProgressCard(store, store.getRun(progressRun.id), row.taskId, row.project, clock(), evidenceRoot, binding.approver);
             let button = null;
             try {
                 button = phoneLinkButton(phoneOrigin?.() ?? null, card.link);
@@ -750,7 +757,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             if (problem !== null)
                 return { ok: false, error: problem };
             const card = store.chatCardFor(fact.destination, fact.taskRef, store.getTask(fact.taskId)?.createdAt ?? fact.createdAt, clock());
-            const view = quietCardView(store, card.tasks, clock(), evidenceRoot);
+            const view = quietCardView(store, card.tasks, clock(), evidenceRoot, binding.approver);
             if (view === null)
                 return { ok: true, messageId: card.message };
             let button = null;
@@ -792,14 +799,55 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             if (!needsPerson(fact))
                 return { ok: true, receipt: receiptFor(botId, binding.chatId, card.messageId) };
             const readyRun = fact.kind === "run-finished" ? store.telegramProgressRun(fact) : null;
-            if (readyRun !== null) {
-                const ping = readyPingView(store, store.getRun(readyRun.id), fact.taskId, fact.project, clock(), evidenceRoot);
-                let button = null;
-                try {
-                    button = phoneLinkButton(phoneOrigin?.() ?? null, ping.link);
+            if (readyRun !== null || (fact.kind !== "run-finished" && joinsBatch(fact))) {
+                // Any update for this person joins their open batch: one message, edited in place while it grows.
+                const batch = store.chatBatchFor(fact.destination, fact.taskRef, readyRun?.id ?? store.telegramProgressRun(fact)?.id ?? null, clock(), BATCH_MS, readyRun !== null ? null : fact.id);
+                // A lone update that is not finished work goes out exactly as it always has; a later one edits it in place.
+                const lone = batch.items.length === 1 && batch.items[0].notification !== null;
+                if (batch.message === null && lone) {
+                    const sent = await deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
+                    const placed = store.telegramMessageOf(fact.id, fact.destination);
+                    if (placed !== null)
+                        store.setChatBatchMessage(batch.id, placed, "");
+                    return sent;
                 }
-                catch { /* No trusted origin. */ }
-                const sent = await sender(ping.text, button === null ? undefined : [button], [fact], ping.entities);
+                const view = finishedView(store, batch, clock(), evidenceRoot, binding.approver);
+                // Nothing in the batch reads as a line. Finished work left out on purpose (a release check, a replaced task,
+                // the reader's own completion) stays quiet; any other update that needs this person still reaches them alone.
+                if (view === null) {
+                    if (readyRun !== null)
+                        return { ok: true, receipt: receiptFor(botId, binding.chatId, card.messageId) };
+                    return deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
+                }
+                // While a lone update is still the only item, its edit keeps that update's own action button.
+                const own = lone && fact.link !== null ? factButton(phoneOrigin, fact.link) : null;
+                const keyboard = own !== null ? [own] : viewKeyboard(phoneOrigin, view);
+                const shown = createHash("sha256").update(JSON.stringify([view.text, keyboard])).digest("hex");
+                if (batch.message !== null) {
+                    if (batch.digest === shown) {
+                        store.recordTelegramMessage(fact, binding, batch.message, clock());
+                        return { ok: true, receipt: receiptFor(botId, binding.chatId, batch.message) };
+                    }
+                    const problem = (await readAccess()) ?? fence();
+                    if (problem !== null)
+                        return { ok: false, error: problem };
+                    const edited = await editProgress(transport, binding.chatId, batch.message, view.text, keyboard);
+                    if (edited.ok) {
+                        store.setChatBatchMessage(batch.id, batch.message, shown);
+                        store.recordTelegramMessage(fact, binding, batch.message, clock());
+                        const after = (await readAccess()) ?? fence();
+                        return after === null ? { ok: true, receipt: receiptFor(botId, binding.chatId, batch.message) } : { ok: false, error: after };
+                    }
+                    if (edited.retryAfter !== undefined)
+                        store.deferTelegram(botId, new Date(clock().getTime() + edited.retryAfter * 1000).toISOString());
+                    // Only Telegram's definitive missing/uneditable answer permits a new message.
+                    if (!edited.replace)
+                        return edited;
+                }
+                const sent = await sender(view.text, keyboard.length === 0 ? undefined : keyboard, [fact]);
+                const placed = sent.ok ? sent.messageId : store.telegramMessageOf(fact.id, fact.destination);
+                if (placed !== null)
+                    store.setChatBatchMessage(batch.id, placed, shown);
                 return sent.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, sent.messageId) } : sent;
             }
             return fact.kind === "acceptance-evidence" ? imageSender(fact) : deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
@@ -815,7 +863,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             const updated = progress ? await updateProgress(false) : null;
             outcome = updated !== null ? updated.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, updated.messageId) } : updated
                 : rows[0].kind === "acceptance-evidence" ? await imageSender(rows[0]) : batched
-                    ? await deliverDigest(botId, binding, sender, rows, digest.lastSentAt, clock)
+                    ? await deliverDigest(botId, binding, sender, rows, digest.lastSentAt, clock, taskId => chatTitle(store, taskId))
                     : await deliverOne(store, botId, binding, sender, rows[0], clock, phoneOrigin, evidenceRoot, projects);
         }
         const finalProblem = outcome.ok ? (await readAccess()) ?? fence() : null;
@@ -850,26 +898,29 @@ function isUrgent(notification) {
 /** The digest text: a header with the count and the window, then one
  * fact per entry — its subject, then its body's first line, indented.
  * Plain text, no buttons: nothing in a digest is tappable. */
-export function digestText(rows, since, now) {
+export function digestText(rows, since, now, titleOf) {
     const window = since === null ? "" : ` since ${since.slice(0, 16).replace("T", " ")}`;
     const lines = [`digest — ${rows.length} routine fact(s)${window} (as of ${now.toISOString().slice(0, 16).replace("T", " ")})`, ""];
     for (const row of rows) {
-        lines.push(digestEntry(row));
+        lines.push(digestEntry(row, titleOf));
     }
     return lines.join("\n");
 }
-function digestEntry(row) {
+function digestEntry(row, titleOf) {
+    const title = row.taskId === null ? undefined : titleOf?.(row.taskId);
+    const task = row.taskId === null ? [] : [{ id: row.taskId, ...(title === undefined ? {} : { title }) }];
+    const subject = chatText(row.subject, task);
     const first = row.body.split("\n").map(one => one.trim()).find(one => one !== "");
     const body = first === undefined ? "" : `\n    ${first.length > 200 ? `${first.slice(0, 200).replace(/[\uD800-\uDBFF]$/, "")}…` : first}`;
-    return `• ${notificationIdentity(row)}${row.subject}${body}`;
+    return `• ${notificationIdentity(row, title !== undefined && mentions(subject, title) ? undefined : title)}${subject}${chatText(body, task)}`;
 }
-async function deliverDigest(botId, binding, sender, rows, since, clock) {
-    const text = digestText(rows, since, clock());
+async function deliverDigest(botId, binding, sender, rows, since, clock, titleOf) {
+    const text = digestText(rows, since, clock(), titleOf);
     // Track the exact rows represented by each text part. A split row may bind
     // several messages; a digest message may bind several rows.
     let offset = text.indexOf("\n\n") + 2;
     const spans = rows.map(row => {
-        const length = digestEntry(row).length;
+        const length = digestEntry(row, titleOf).length;
         const span = { row, start: offset, end: offset + length };
         offset += length + 1;
         return span;
@@ -917,16 +968,13 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
             else
                 body = `${packet.text}\n\n${notification.body}`;
         }
-        const parts = split(`${notificationIdentity(notification)}${alreadyAccepted ? "Acceptance recorded" : notification.subject}\n\n${body}`);
-        let button = null;
-        if (notification.link !== null && !alreadyAccepted && current) {
-            try {
-                button = phoneLinkButton(phoneOrigin?.() ?? null, { label: factLinkLabel(notification.link), path: notification.link });
-            }
-            catch {
-                button = null;
-            }
-        }
+        // A short title, never the task's id or a "— revision" suffix (chat-voice.ts).
+        const title = notification.taskId === null ? undefined : chatTitle(store, notification.taskId);
+        const task = notification.taskId === null ? [] : [{ id: notification.taskId, ...(title === undefined ? {} : { title }) }];
+        const words = chatText(`${alreadyAccepted ? "Acceptance recorded" : notification.subject}${body === "" ? "" : `\n\n${body}`}`, task);
+        // The task's title once: in front, unless the words already name it.
+        const parts = split(`${notificationIdentity(notification, title !== undefined && mentions(words, title) ? undefined : title)}${words}`);
+        const button = notification.link !== null && !alreadyAccepted && current ? factButton(phoneOrigin, notification.link) : null;
         // A flow card waiting on a decision (v86): Approve, Edit, Send back on the last part, for this visit only.
         const visit = FLOW_DECIDE_KEY.exec(notification.dedupeKey);
         const waiting = visit === null ? null : flowDecisionAt(store, Number(visit[1]), Number(visit[2]));
@@ -1403,6 +1451,8 @@ function applyMessage(context, update, effects) {
             text: `paired: this chat now answers as ${approver}\n\nSend /status to check recent work, /task <id> for one task, or /help for your options.`,
             link_preview_options: { is_disabled: true },
         });
+        // The bot is Toolroll in every chat list from here on (best effort; pairing never waits on it).
+        await nameTelegramBot(transport, "pairing");
     });
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"