toolroll 0.9.9 → 0.9.11

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);
     }
@@ -21599,14 +21621,18 @@ export class Store {
      * under a claim that lapsed (a crash mid-turn), and not deferred past now.
      * One at a time per bot — the mate runs one turn per approver anyway.
      */
-    claimTelegramConversation(botId, owner, ttlMs, now) {
+    claimTelegramConversation(botId, owner, ttlMs, now, only) {
         return this.transact(() => {
             const stamp = now.toISOString();
+            // "turns": still needs the assistant; "replies": the reply is planned and only sending remains.
+            const planned = "EXISTS (SELECT 1 FROM telegram_conversation_part p WHERE p.conversation = telegram_conversation.id)";
+            const which = only === "turns" ? `AND NOT ${planned}` : only === "replies" ? `AND ${planned}` : "";
             const row = this.db
                 .prepare(`SELECT * FROM telegram_conversation
             WHERE bot_id = ? AND state IN ('queued','running')
               AND (claim_expires_at IS NULL OR claim_expires_at <= ?)
               AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
+              ${which}
             ORDER BY id LIMIT 1`)
                 .get(botId, stamp, stamp);
             if (row === undefined)
@@ -21664,6 +21690,31 @@ export class Store {
                 .run(result.state, result.outcome, result.replyMessageId ?? null, stamp, id, owner, stamp);
         return Number(changes) === 1;
     }
+    /**
+     * Replies the assistant wrote that still have not reached the person
+     * `since` ago or longer (status and the console show them with a Retry):
+     * the message's row, whose it is, when the oldest unsent part was
+     * written, and the last send error.
+     */
+    unsentTelegramReplies(botId, approver, since) {
+        return this.db
+            .prepare(`SELECT c.id, c.approver, MIN(p.created_at) AS since,
+           (SELECT q.last_error FROM telegram_conversation_part q WHERE q.conversation = c.id AND q.state = 'pending' ORDER BY q.ordinal LIMIT 1) AS error
+          FROM telegram_conversation c JOIN telegram_conversation_part p ON p.conversation = c.id AND p.state = 'pending'
+         WHERE c.state IN ('queued','running') AND (? IS NULL OR c.bot_id = ?) AND (? IS NULL OR c.approver = ?)
+         GROUP BY c.id HAVING MIN(p.created_at) <= ? ORDER BY c.id`)
+            .all(botId, botId, approver, approver, since.toISOString())
+            .map(row => ({ conversation: Number(row["id"]), approver: String(row["approver"]), since: String(row["since"]), error: row["error"] === null ? null : String(row["error"]) }));
+    }
+    /** Send unsent replies on the next bridge pass instead of waiting out their backoff; returns how many. */
+    retryTelegramReplies(approver, now) {
+        const { changes } = this.db
+            .prepare(`UPDATE telegram_conversation SET next_attempt_at = ?
+          WHERE state = 'queued' AND (? IS NULL OR approver = ?)
+            AND EXISTS (SELECT 1 FROM telegram_conversation_part p WHERE p.conversation = telegram_conversation.id AND p.state = 'pending')`)
+            .run(now.toISOString(), approver, approver);
+        return Number(changes);
+    }
     // ---- the outbound parts (v63) ------------------------------------------------
     /**
      * Persist the whole outbound half of a turn — every reply part and every
@@ -22197,6 +22248,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 +22258,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 +22346,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-mate.d.ts

@@ -122,6 +122,12 @@ export declare function splitParts(text: string): string[];
  * outside any SQLite transaction. The caller holds the poll lease and
  * renews it; the row's own claim is renewed here. Bounded per call so a
  * flood cannot pin one pass forever.
+ *
+ * `only` splits the work for the follower: "turns" runs the model and
+ * persists the reply but leaves the sending to the bridge's own cycle,
+ * which calls back with "replies" — so a reply goes out from the same
+ * place, in the same order and over the same connection as notifications,
+ * never beside a long poll. Absent, a row is answered and sent in one go.
  */
 export declare function processTelegramConversations(args: {
     store: Store;
@@ -134,4 +140,5 @@ export declare function processTelegramConversations(args: {
     report: ConversationReport;
     signal?: AbortSignal;
     limit?: number;
+    only?: "turns" | "replies";
 }): Promise<void>;

package/dist/telegram-mate.js

@@ -1,5 +1,5 @@
 import { CHAT_ACTIONS, sharedActionAllowsChallenge, sharedActionPayload } from "./chat-actions.js";
-import { taskInCeiling, mirrorToTaskChat, channelRepos as telegramConversationRepos, resolveChannelMate as resolveTelegramMate, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText } from "./chat-channel.js";
+import { taskInCeiling, mirrorToTaskChat, couldNotAnswerText, channelRepos as telegramConversationRepos, resolveChannelMate as resolveTelegramMate, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText } from "./chat-channel.js";
 export { channelRepos as telegramConversationRepos, resolveChannelMate as resolveTelegramMate, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText, CHAT_ACTION_PARITY as TELEGRAM_ACTION_PARITY, parityGaps } from "./chat-channel.js";
 /**
  * The paired phone as one more way to use the same assistant.
@@ -299,11 +299,17 @@ export function splitParts(text) {
  * outside any SQLite transaction. The caller holds the poll lease and
  * renews it; the row's own claim is renewed here. Bounded per call so a
  * flood cannot pin one pass forever.
+ *
+ * `only` splits the work for the follower: "turns" runs the model and
+ * persists the reply but leaves the sending to the bridge's own cycle,
+ * which calls back with "replies" — so a reply goes out from the same
+ * place, in the same order and over the same connection as notifications,
+ * never beside a long poll. Absent, a row is answered and sent in one go.
  */
 export async function processTelegramConversations(args) {
     const limit = args.limit ?? 20;
     for (let count = 0; count < limit && args.signal?.aborted !== true; count++) {
-        const row = args.store.claimTelegramConversation(args.botId, args.owner, CONVERSATION_CLAIM_MS, args.clock());
+        const row = args.store.claimTelegramConversation(args.botId, args.owner, CONVERSATION_CLAIM_MS, args.clock(), args.only);
         if (row === null)
             return;
         try {
@@ -318,6 +324,8 @@ export async function processTelegramConversations(args) {
 }
 class PlanRefused extends Error {
 }
+/** The outcome a planned reply waits under until the bridge's cycle sends it. */
+const ANSWERED_SENDING = "answered:sending";
 /**
  * One claimed message, in order of what is already known about it:
  *
@@ -334,12 +342,13 @@ class PlanRefused extends Error {
  * the ceiling the turn opened under; only a confirmed message id counts.
  */
 async function runTelegramConversation(row, args) {
-    const { store, botId, transport, owner, clock, readProjects, options, report } = args;
+    const { store, botId, transport, owner, clock, readProjects, options, report, only } = args;
     const finish = (result) => store.finishTelegramConversation(row.id, owner, result, clock());
     const held = () => store.renewTelegramConversation(row.id, owner, CONVERSATION_CLAIM_MS, clock());
     const ageMs = clock().getTime() - Date.parse(row.createdAt);
-    const requeue = (outcome) => {
+    const requeue = async (outcome) => {
         if (ageMs > CONVERSATION_MAX_AGE_MS) {
+            await notify(couldNotAnswerText(outcome === "registry-unavailable" ? "your projects couldn't be read" : "the assistant stayed busy with another message"));
             finish({ state: "failed", outcome: `${outcome}:gave-up` });
             report.refused++;
             return;
@@ -384,6 +393,7 @@ async function runTelegramConversation(row, args) {
         const bound = store.getTelegramConversation(row.id)?.session ?? null;
         const session = bound === null ? null : store.getMateSession(bound);
         if (session === null) {
+            await notify(couldNotAnswerText("the chat session for this reply is gone"));
             finish({ state: "failed", outcome: "unsent:no-session" });
             report.refused++;
             return;
@@ -407,6 +417,7 @@ async function runTelegramConversation(row, args) {
             }
             if (now.getTime() - Date.parse(row.createdAt) > DELIVERY_MAX_AGE_MS) {
                 report.problems.push(`telegram chat reply for update ${row.updateId} was not sent within a day: ${part.lastError ?? "unsent"}`);
+                await notify(couldNotAnswerText("my reply couldn't be sent for a day"));
                 finish({ state: "failed", outcome: `unsent:gave-up:${part.lastError ?? "unsent"}` });
                 report.refused++;
                 return;
@@ -512,15 +523,24 @@ async function runTelegramConversation(row, args) {
                     ...(keyboard === undefined ? {} : { reply_markup: { inline_keyboard: keyboard } }),
                 });
             }
+            // The first time the answer itself fails to go out, the person hears so once,
+            // in plain words; the reply itself keeps being retried and shows as
+            // unsent in status and the console after two minutes.
+            const firstFailure = part.kind === "reply" && store.listTelegramConversationParts(row.id).every(one => one.attempts <= (one.state === "sent" ? 1 : 0));
+            const failed = async (until, error, uncertain) => {
+                if (!store.settleTelegramConversationPart(row.id, part.ordinal, owner, { ok: false, error, uncertain, retryAt: until.toISOString() }, clock()))
+                    return;
+                if (firstFailure)
+                    await notify(couldNotAnswerText(uncertain ? "my reply may not have reached Telegram" : "Telegram didn't accept my reply"));
+                defer(until, error);
+            };
             let answer;
             try {
                 answer = await send();
             }
             catch {
                 // The answer was lost: Telegram may or may not have the message. Said so, retried, counted.
-                const error = "Telegram transport failed; delivery may be uncertain";
-                if (store.settleTelegramConversationPart(row.id, part.ordinal, owner, { ok: false, error, uncertain: true, retryAt: backoff.toISOString() }, clock()))
-                    defer(backoff, error);
+                await failed(backoff, "Telegram transport failed; delivery may be uncertain", true);
                 return;
             }
             if (!answer.ok) {
@@ -535,15 +555,12 @@ async function runTelegramConversation(row, args) {
                     if (paused > until)
                         until = paused;
                 }
-                if (store.settleTelegramConversationPart(row.id, part.ordinal, owner, { ok: false, error, uncertain, retryAt: until.toISOString() }, clock()))
-                    defer(until, error);
+                await failed(until, error, uncertain);
                 return;
             }
             const id = answer.result?.message_id;
             if (!Number.isSafeInteger(id) || id <= 0) {
-                const error = "Telegram returned no confirmed message identity";
-                if (store.settleTelegramConversationPart(row.id, part.ordinal, owner, { ok: false, error, uncertain: true, retryAt: backoff.toISOString() }, clock()))
-                    defer(backoff, error);
+                await failed(backoff, "Telegram returned no confirmed message identity", true);
                 return;
             }
             const messageId = String(id);
@@ -596,11 +613,11 @@ async function runTelegramConversation(row, args) {
         }
         store.bindTelegramConversationTurn(row.id, owner, session, turnId);
         if (turn.state === "queued" || turn.state === "running") {
-            requeue("replayed:running");
+            await requeue("replayed:running");
             return;
         }
         if (turn.state !== "answered") {
-            await notify(`Your earlier message was received, but the assistant's reply did not complete (${phoneText(turn.failureReason ?? "unknown", 40)}). Nothing was changed. Send it again if you still want it.`);
+            await notify(couldNotAnswerText(`the assistant's reply did not complete (${phoneText(turn.failureReason ?? "unknown", 40)})`));
             finish({ state: "failed", outcome: `replayed:${turn.failureReason ?? "failed"}` });
             report.refused++;
             return;
@@ -609,11 +626,19 @@ async function runTelegramConversation(row, args) {
         const proposals = store.listMateProposals(turn.thread, ["pending"]).filter(one => one.turn === turn.id);
         if (!plan(session, turnId, reply, proposals, repos) && store.listTelegramConversationParts(row.id).length === 0)
             return;
-        await deliver("replayed");
+        await sendOrHandOff("replayed");
+    };
+    /** Send now, or — for the follower's turn worker — leave it to the bridge's cycle, which sends it next. */
+    const sendOrHandOff = async (outcomeWord) => {
+        if (only !== "turns") {
+            await deliver(outcomeWord);
+            return;
+        }
+        finish({ state: "queued", outcome: outcomeWord === "answered" ? ANSWERED_SENDING : "delivering", nextAttemptAt: clock().toISOString() });
     };
     // 2. Parts already planned: the turn answered; only the sending remains.
     if (store.listTelegramConversationParts(row.id).length > 0) {
-        await deliver("replayed");
+        await deliver(row.outcome === ANSWERED_SENDING ? "answered" : "replayed");
         return;
     }
     // 3. The ceiling, reloaded now.
@@ -623,7 +648,7 @@ async function runTelegramConversation(row, args) {
     }
     catch {
         report.problems.push("telegram chat could not read the current project records");
-        requeue("registry-unavailable");
+        await requeue("registry-unavailable");
         return;
     }
     const repos = telegramConversationRepos(store, binding.approver, registry);
@@ -638,6 +663,10 @@ async function runTelegramConversation(row, args) {
     }
     // 5. The session and thread — shared with the console and the CLI.
     const resolved = resolveTelegramMate(store, binding, repos, clock());
+    if (!resolved.ok && resolved.reason === "busy") {
+        await requeue("busy");
+        return;
+    }
     if (!resolved.ok) {
         if (resolved.said !== null)
             await notify(resolved.said);
@@ -676,10 +705,10 @@ async function runTelegramConversation(row, args) {
         store.bindTelegramConversationTurn(row.id, owner, session.id, receipt.turn);
     if (!outcome.ok && "refused" in outcome) {
         if (outcome.refused === "concurrent") {
-            requeue("busy");
+            await requeue("busy");
             return;
         }
-        await notify(`${outcome.message.charAt(0).toUpperCase()}${outcome.message.slice(1)}. Nothing was changed.`);
+        await notify(phoneText(couldNotAnswerText(outcome.message), 1_000));
         finish({ state: "failed", outcome: `refused:${outcome.refused}` });
         report.refused++;
         return;
@@ -687,7 +716,7 @@ async function runTelegramConversation(row, args) {
     if (!outcome.ok) {
         // Truthful: what failed, that nothing was kept, and that a new message
         // is a new turn. A failed turn's drafts are already gone.
-        const words = outcome.failed === "revoked" ? `${outcome.message.charAt(0).toUpperCase()}${outcome.message.slice(1)}.` : `The assistant's reply did not complete: ${outcome.message}. Nothing it proposed was kept. Send your message again if you still want it.`;
+        const words = outcome.failed === "revoked" ? `${outcome.message.charAt(0).toUpperCase()}${outcome.message.slice(1)}.` : couldNotAnswerText(`the assistant's reply did not complete (${outcome.message})`);
         await notify(phoneText(words, 1_000));
         finish({ state: "failed", outcome: `failed:${outcome.failed}` });
         report.refused++;
@@ -703,5 +732,5 @@ async function runTelegramConversation(row, args) {
     const proposals = store.listMateProposals(thread.id, ["pending"]).filter(one => one.turn === outcome.turn);
     if (!plan(session.id, outcome.turn, outcome.reply, proposals, who.repos) && store.listTelegramConversationParts(row.id).length === 0)
         return;
-    await deliver("answered");
+    await sendOrHandOff("answered");
 }

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-settings.d.ts

@@ -3,7 +3,10 @@
  * the settings page; this card only mints or revokes the signed-in person's
  * pairing, never anyone else's. */
 import type { Store } from "./store.js";
+/** How long a written reply may wait to be sent before it shows here with a Retry. */
+export declare const UNSENT_REPLY_MS: number;
 export declare function telegramSettingsHtml(store: Store, botId: string | null, who: string, csrf: string, options?: {
     code?: string;
     problem?: string;
+    now?: Date;
 }): string;

package/dist/telegram-settings.js

@@ -1,3 +1,5 @@
+/** How long a written reply may wait to be sent before it shows here with a Retry. */
+export const UNSENT_REPLY_MS = 2 * 60_000;
 const escape = (text) => text
     .replaceAll("&", "&")
     .replaceAll("<", "&lt;")
@@ -17,6 +19,15 @@ export function telegramSettingsHtml(store, botId, who, csrf, options = {}) {
         const mine = bindings.filter(binding => binding.approver === who);
         const others = bindings.length - mine.length;
         content = `<p><strong>${mine.length > 0 ? "Your phone is paired." : "Your phone is not paired."}</strong> ${others === 0 ? "No teammates are paired yet." : `${others} teammate${others === 1 ? " is" : "s are"} paired.`}</p>`;
+        // A reply the assistant wrote that has not reached this person's phone for two minutes.
+        const unsent = store.unsentTelegramReplies(botId, who, new Date((options.now ?? new Date()).getTime() - UNSENT_REPLY_MS));
+        if (unsent.length > 0) {
+            const oldest = unsent[0];
+            content +=
+                `<div class="card" role="status" data-unsent-replies><p><strong>${unsent.length === 1 ? "A reply hasn't reached your phone" : `${unsent.length} replies haven't reached your phone`}</strong></p>` +
+                    `<p class="meta">Trying since ${escape(oldest.since.slice(11, 16))} UTC${oldest.error === null ? "" : `: ${escape(oldest.error)}`}</p>` +
+                    `<form method="post" action="/settings/telegram/retry">${hidden}<button type="submit">Retry</button></form></div>`;
+        }
         if (options.code !== undefined) {
             content +=
                 "<h2>Pair your phone</h2><p>Send this to the bot in a private Telegram chat within 10 minutes:</p>" +

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

@@ -98,6 +98,20 @@ export type TelegramUpload = {
     bytes: Buffer;
 };
 export declare function createTransport(token: string, timeoutMs?: number): TelegramTransport;
+/**
+ * Why this process can't reach Telegram the way the service does, or null.
+ * A coding agent's sandbox fences the network: Codex says so in its own
+ * variables, and Claude Code's sandbox routes traffic through a proxy on
+ * this computer, which curl uses and Node's fetch does not — so sends fail
+ * "fetch failed" while curl works (Oct 2). Builds, checks and agents also
+ * get a database of their own, so none of them can hold the live bridge;
+ * this keeps an agent-launched `watch` or `bridge` from holding it either.
+ */
+export declare function networkFence(env: Record<string, string | undefined>): string | null;
+/** The plain line a fenced process says instead of polling or sending. */
+export declare function networkFenceLine(reason: string): string;
+/** fetch's own message ("fetch failed") with the reason under it, e.g. "fetch failed (EMFILE: too many open files)". */
+export declare function transportError(error: unknown): string;
 /** The multipart body: every param a field (objects as JSON), the file last. Exported for the adapter's own test only. */
 export declare function multipartOf(params: Record<string, unknown>, upload: TelegramUpload): FormData;
 export declare function hashPairingCode(code: string): string;
@@ -227,4 +241,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;