toolroll 0.9.10 → 0.9.12

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/store.d.ts

@@ -7294,7 +7294,7 @@ export declare 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: string, owner: string, ttlMs: number, now: Date): TelegramConversation | null;
+    claimTelegramConversation(botId: string, owner: string, ttlMs: number, now: Date, only?: "turns" | "replies"): TelegramConversation | null;
     /** Extend a held claim; false means it lapsed and somebody else may hold the row. */
     renewTelegramConversation(id: number, owner: string, ttlMs: number, now: Date): boolean;
     /**
@@ -7321,6 +7321,20 @@ export declare class Store {
         outcome: string;
         nextAttemptAt: string;
     }, now: Date): boolean;
+    /**
+     * 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: string | null, approver: string | null, since: Date): {
+        conversation: number;
+        approver: string;
+        since: string;
+        error: string | null;
+    }[];
+    /** Send unsent replies on the next bridge pass instead of waiting out their backoff; returns how many. */
+    retryTelegramReplies(approver: string | null, now: Date): number;
     /**
      * Persist the whole outbound half of a turn — every reply part and every
      * card, with the cards' tokens already minted — in one transaction, BEFORE

package/dist/store.js

@@ -657,6 +657,9 @@ export function isTelegramProgressNotification(row) {
         return false;
     if (row.kind === "build-failed" && row.run !== null && row.dedupeKey === `run:${row.run}:failed`)
         return true;
+    // The owner's lead took the attempt on, or let it lapse (lead-voice.ts): its card repaints in place.
+    if ((row.kind === "lead-on-it" || row.kind === "lead-lapsed") && row.run !== null)
+        return true;
     return isLifecycleNotification(row) &&
         ["run-started", "run-phase", "run-finished", "review-requested", "review-finished", "run-stopping", "run-stopped", "run-resumed", "task-held", "task-released"].includes(row.kind);
 }
@@ -21621,14 +21624,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)
@@ -21686,6 +21693,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
@@ -22224,7 +22256,12 @@ export class Store {
             return true;
         if (row.recipient !== null && row.kind === "task-ask")
             return true;
+        // The lead's own words reach the person it speaks for, and its claim repaints only that person's card (lead-voice.ts).
+        if (row.kind === "lead-say")
+            return row.recipient === account;
         const actor = this.notificationActor(row.id);
+        if (row.kind === "lead-on-it" || row.kind === "lead-lapsed")
+            return actor?.lead === true && actor.account === account;
         if (actor !== null && actor.account === account)
             return false;
         if (row.recipient !== null)

package/dist/surface.js

@@ -194,7 +194,7 @@ export const COMMAND_GUIDE = [
         invocation: `assignment ${action}`,
         synopsis: action === "show" ? "read the root, current work, owner and exact receipt"
             : action === "updates" ? "read durable updates after a cursor; save nextCursor after processing"
-                : action === "claim" ? "record coordinator lead ownership; grants no approval or execution authority"
+                : action === "claim" ? "record lead ownership; with the lead token the task reads \"Your lead is on it\" and leaves Needs you until done, handed over, or 2 hours idle; grants no approval or execution authority"
                     : action === "brief" ? "catch up from current assignments and project knowledge in the local database"
                         : action === "inbox" ? "receive or replay a saved batch of lead status updates"
                             : action === "ack" ? "acknowledge delivery of an inbox batch; leaves task completion unchanged"
@@ -215,6 +215,13 @@ export const COMMAND_GUIDE = [
     })),
     operator("task state", "set a task's state by hand — an operator correction, not a workflow step (--replaced-by <id> with cancelled)"),
     operator("lead token", "mint the lead's credential behind your password (--revoke ends it): its own work pings nobody"),
+    { invocation: "lead say", synopsis: "as the lead: one short message in its person's chat from \"Your lead\"; several within two minutes are one message",
+        audience: "agent", agentMayInvoke: true, mutation: "unkeyed",
+        positionals: [{ name: "text", required: true, meaning: "one short line in plain words" }],
+        flags: [jsonFlag, dbFlag,
+            { name: "task", takesValue: true, meaning: "the task it is about" },
+            { name: "token", takesValue: true, meaning: "the lead token (or TOOLROLL_LEAD_TOKEN)" }],
+        notableReasons: ["usage", "unknown-task", "unauthenticated"] },
     { invocation: "task block", synopsis: "make one task wait for another", audience: "agent", agentMayInvoke: true, mutation: "keyed",
         positionals: [{ name: "id", required: true, meaning: "the waiting task" }],
         flags: [jsonFlag, dbFlag, keyFlag, { name: "on", takesValue: true, meaning: "the blocker's id" }],

package/dist/task-status.d.ts

@@ -107,8 +107,14 @@ export type TaskStatusFacts = {
     };
     /** Exact technical reasons, shown only on request. */
     why?: readonly string[];
+    /** The person's lead took this on (lead-voice.ts): "on-it" reads "Your lead is on it" and needs nobody; "lapsed"
+     * (two hours without a lead act) is back with the person, and says so. */
+    lead?: "on-it" | "lapsed" | null;
 };
 export declare function headlineOf(facts: Pick<TaskStatusFacts, "stage" | "checks" | "report">): Headline;
+/** What the lead's claim says, in place of "waits for you" (lead-voice.ts). */
+export declare const LEAD_ON_IT = "Your lead is on it.";
+export declare const LEAD_LAPSED = "Your lead hasn't acted on this for 2 hours, so it's back with you.";
 export declare function taskStatusOf(facts: TaskStatusFacts): TaskStatus;
 export declare function plainReasonOf(stage: TaskStage, code: string, detail: string | null | undefined): string | null;
 export declare function stageOfCode(code: string, options?: {

package/dist/task-status.js

@@ -133,13 +133,29 @@ function detailsOf(headline, facts) {
     }
     return rows;
 }
+/** What the lead's claim says, in place of "waits for you" (lead-voice.ts). */
+export const LEAD_ON_IT = "Your lead is on it.";
+export const LEAD_LAPSED = "Your lead hasn't acted on this for 2 hours, so it's back with you.";
+/** The headlines a lead's claim speaks for: the ones that would otherwise wait on a person. */
+const LEAD_HEADLINES = new Set(["Needs you", "Failed", "Ready for review", "Stopped"]);
+function leadSentence(headline, facts) {
+    const sha = short(facts.checks?.head ?? null);
+    // A failed check stays said: the claim changes who acts next, never the result.
+    if (headline === "Failed" && facts.checks?.status === "failed")
+        return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. ${LEAD_ON_IT}`;
+    return LEAD_ON_IT;
+}
 export function taskStatusOf(facts) {
-    const headline = headlineOf(facts);
+    const read = headlineOf(facts);
+    const lead = facts.lead != null && LEAD_HEADLINES.has(read) ? facts.lead : null;
+    // The lead has it: nothing waits on the person, so a Needs you reads Waiting.
+    const headline = lead === "on-it" && read === "Needs you" ? "Waiting" : read;
     // Every Needs you carries the one action that resolves it, worded the same everywhere.
     const need = headline === "Needs you" ? { key: facts.need ?? "other", action: NEEDS[facts.need ?? "other"].action } : null;
     const ownWords = need !== null && (need.key === "other" || need.key === "review-result") && facts.action != null;
     const primaryAction = need === null || ownWords ? facts.action ?? null : { label: need.action.label, href: facts.action?.href ?? null };
-    return { headline, tone: HEADLINE_TONE[headline], sentence: sentenceOf(headline, facts), details: detailsOf(headline, facts),
+    const sentence = lead === "on-it" ? leadSentence(headline, facts) : lead === "lapsed" ? `${LEAD_LAPSED} ${sentenceOf(headline, facts)}` : sentenceOf(headline, facts);
+    return { headline, tone: HEADLINE_TONE[headline], sentence, details: detailsOf(headline, facts),
         primaryAction, why: [...new Set(facts.why ?? [])].filter(one => one.trim() !== ""), need };
 }
 // ---- reading the existing projections ----------------------------------------
@@ -287,6 +303,7 @@ export function assignmentStatusFacts(assignment, options = {}) {
         action: options.action ?? null,
         ...(options.links === undefined ? {} : { links: options.links }),
         why: options.why ?? [],
+        ...(assignment.lead == null ? {} : { lead: assignment.lead.state }),
     };
 }
 // ---- rendering helpers shared by the server pages and chat cards ------------

package/dist/team-cli.js

@@ -306,7 +306,7 @@ function render(reply, listing) {
 export async function maybeRunTeamCommand(argv, write, options = {}) {
     const command = argv[0];
     // `lead token` is local: the credential a lead agent acts with on this computer.
-    if (command === 'lead' && argv[1] === 'token')
+    if (command === 'lead' && (argv[1] === 'token' || argv[1] === 'say'))
         return null;
     if (!['connect', 'lead', 'conversation', 'chat', 'brief'].includes(command ?? '') && !argv.includes('--profile'))
         return null;

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.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 { leadClaimOf } from "./lead-voice.js";
 import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
@@ -78,6 +79,12 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     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 };
+    // The person's lead took it on: "Your lead is on it" rather than waiting for them (lead-voice.ts).
+    if (facts.lead === undefined) {
+        const lead = leadClaimOf(store, taskId, now, viewer);
+        if (lead !== null)
+            facts = { ...facts, lead: lead.state };
+    }
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
     const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];

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.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;