toolroll 0.9.37 → 0.9.38

package/dist/browser-crew.js

@@ -38,6 +38,10 @@ export function browserCrewFromIndex(page, conversationId) {
     const link = (href) => conversationId && href.startsWith('/chat?') ? href + '&conversation=' + encodeURIComponent(conversationId) : href;
     const rows = page.items.map(summary => {
         const status = summary.status;
+        // Keep the server's sentence intact; ignore only empty or repeated badge words.
+        const words = (text) => text.trim().replace(/\s+/g, ' ').replace(/[.!?]+$/, '').toLowerCase();
+        const detail = ['Waiting', 'Failed', 'Needs you'].includes(status.label)
+            && words(status.detail) !== '' && words(status.detail) !== words(status.label) ? status.detail : undefined;
         const resultHref = summary.resultRunId === null || summary.resultTaskId === null || (summary.resultOutcome !== 'built' && summary.resultOutcome !== 'no-change')
             ? null : chatResultHref(summary.resultTaskId, summary.resultRunId);
         const href = chatControlHref('task', summary.rootId);
@@ -48,6 +52,7 @@ export function browserCrewFromIndex(page, conversationId) {
             state: summary.assignmentState, label: status.label, tone: status.tone, href: link(href), resultHref: resultHref === null ? null : link(resultHref),
             action: action === null || actionHref === null ? null : { label: action.label, href: link(actionHref) },
             updatedAt: summary.updatedAt,
+            ...(detail === undefined ? {} : { detail }),
             ...(summary.lead === undefined ? {} : { lead: summary.lead }),
         };
         return { item, rank: status.rank };

package/dist/browser-workspace.d.ts

@@ -49,6 +49,8 @@ export type BrowserCrewItem = {
     } | null;
     /** When the task family last changed (the index's own sort time), shown as the row's age. */
     updatedAt: string;
+    /** The server's status detail, when Waiting, Failed or Needs you adds to its badge. */
+    detail?: string;
     /** "<name> is on it.": the person's own lead took it on, by the name they gave it. */
     lead?: string;
 };

package/dist/chat-channel.js

@@ -273,16 +273,27 @@ export function proposalPreview(store, proposal, repos, channel = null) {
             : undefined;
         return path === undefined ? id : projectLabel(path);
     })();
+    // Telegram's card leads with the action and what confirming does, then the exact terms; its buttons say the rest.
+    const phone = channel === "telegram";
     const card = (headline, body = [], consequence = null) => ({
-        text: [
-            headline,
-            ...body,
-            ...(consequence === null ? [] : ["", consequence]),
-            "",
-            "Confirm or Dismiss below. Nothing changes until you confirm.",
-        ].join("\n"),
+        text: (phone
+            ? [
+                headline,
+                ...(consequence === null ? [] : [consequence]),
+                ...(body.length === 0 ? [] : ["", ...body]),
+                "",
+                "Nothing changes until you confirm.",
+            ]
+            : [
+                headline,
+                ...body,
+                ...(consequence === null ? [] : ["", consequence]),
+                "",
+                "Confirm or Dismiss below. Nothing changes until you confirm.",
+            ]).join("\n"),
         buttons: true,
     });
+    const lasting = phone ? " ⚠ can't be undone" : " — IRREVERSIBLE";
     // A handoff's text is origin-free on purpose: it is persisted before the
     // send, and the button or the missing-setup line joins it at send time.
     const handoff = (headline, body = []) => ({
@@ -361,11 +372,11 @@ export function proposalPreview(store, proposal, repos, channel = null) {
                 ? ["(the decision is gone)"]
                 : [
                     `Q: ${phoneText(decision.question, 400)}`,
-                    ...decision.options.map((one) => `${one.id === pick ? "→" : " "} ${phoneText(one.label, 120)}${one.reversible ? "" : " — IRREVERSIBLE"}${one.id === decision.recommendation ? " (the builder recommends this)" : ""}: ${phoneText(one.consequence, 300)}`),
+                    ...decision.options.map((one) => `${one.id === pick ? "→" : " "} ${phoneText(one.label, 120)}${one.reversible ? "" : lasting}${one.id === decision.recommendation ? " (the builder recommends this)" : ""}: ${phoneText(one.consequence, 300)}`),
                     ...(t("rationale") === "" ? [] : [`Why: ${t("rationale", 300)}`]),
                 ];
             return card(`Answer decision #${String(id ?? "?")} on ${taskName} with "${t("optionLabel", 120) || pick}"`, body, irreversible
-                ? "⚠ This choice is irreversible. Confirming asks you once more."
+                ? phone ? "⚠ This choice can't be undone. Confirming asks you once more." : "⚠ This choice is irreversible. Confirming asks you once more."
                 : null);
         }
         case "task_action": {

package/dist/chat-decide.d.ts

@@ -108,11 +108,12 @@ export declare function mergeInChat(store: Store, taskId: string, run: number, a
     ok: false;
     why: string;
 };
-/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. */
-export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string): string;
+/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
+ * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
+export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string, channel?: DecideChannel): string;
 /** The acts a card about this target can take in chat right now, or null when none can (the card keeps its own
  * link). Reads only; nothing is minted. */
-export declare function decideOffer(store: Store, target: DecideTarget, who: VerifiedApprover, now: Date, root?: string): DecideOffer | null;
+export declare function decideOffer(store: Store, target: DecideTarget, who: VerifiedApprover, now: Date, root?: string, channel?: DecideChannel): DecideOffer | null;
 /** One fingerprint of what the card offers, without its tokens: a repaint with the same offer keeps its buttons. */
 export declare function offerFingerprint(offer: DecideOffer): string;
 /** The card's buttons, minted now (message unknown until it is sent: `placeDecideTokens` puts them on it). */

package/dist/chat-decide.js

@@ -155,8 +155,9 @@ export function mergeInChat(store, taskId, run, approver, now) {
         return mode;
     return { ok: true, modeDigest: mode.digest, head: publication.headSha };
 }
-/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. */
-export function planCardText(store, taskId, scope, root) {
+/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
+ * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
+export function planCardText(store, taskId, scope, root, channel) {
     const ref = store.lookupRef(taskId);
     const artifact = ref === null ? null : store.latestPlanArtifact(ref.id);
     let milestones = [];
@@ -176,6 +177,19 @@ export function planCardText(store, taskId, scope, root) {
     const goal = scope.goal.split("\n").filter(one => one.trim() !== "").slice(0, 2).map(one => phoneText(one, 160));
     const allowing = [permissionPlainWords(scope.profile), scope.budgetMicrousd === null ? "no attempt limit" : `up to ${money(scope.budgetMicrousd)} per attempt`]
         .filter((one) => one !== null);
+    if (channel === "telegram") {
+        return [
+            `Plan ready: ${title(store, taskId)}`,
+            `Starting allows: ${allowing.join(" · ")}`,
+            "",
+            ...goal,
+            ...(scope.touches.length > 0 ? [`Only in: ${scope.touches.slice(0, 6).map(one => phoneText(one, 80)).join(", ")}${scope.touches.length > 6 ? ", …" : ""}`] : ["Any file in the project."]),
+            "",
+            "Done when:",
+            ...(scope.acceptance.length > 0 ? bullets(scope.acceptance.map(one => one.statement), 5) : ["You decide when you review the result."]),
+            ...(milestones.length > 0 ? ["", "Steps:", ...bullets(milestones, 3)] : []),
+        ].join("\n");
+    }
     return [
         `Plan ready: ${title(store, taskId)}`,
         "",
@@ -194,7 +208,7 @@ export function planCardText(store, taskId, scope, root) {
 // ---- what a card offers ---------------------------------------------------------------
 /** The acts a card about this target can take in chat right now, or null when none can (the card keeps its own
  * link). Reads only; nothing is minted. */
-export function decideOffer(store, target, who, now, root) {
+export function decideOffer(store, target, who, now, root, channel) {
     const ref = store.lookupRef(target.taskId);
     if (ref === null || ref.repo === null || !who.repos.includes(ref.repo))
         return null;
@@ -222,7 +236,7 @@ export function decideOffer(store, target, who, now, root) {
             const plan = planInChat(store, target.taskId, who.name, now, root);
             if (!plan.ok)
                 return null;
-            return { text: planCardText(store, target.taskId, plan.scope, root),
+            return { text: planCardText(store, target.taskId, plan.scope, root, channel),
                 rows: [[{ act: "approve", run: null, digest: plan.digest }], [{ label: DECIDE_LABELS.edit, path: chatControlHref("approval", target.taskId) }, { act: "not-now", run: null, digest: plan.digest }]] };
         }
         case "merge": {
@@ -414,7 +428,7 @@ export function applyDecideTap(store, seat, input) {
     }
     if (row.phase === "cancel") {
         spend();
-        const offer = decideOffer(store, target, who, now, input.root);
+        const offer = decideOffer(store, target, who, now, input.root, seat.channel);
         if (offer === null)
             return { ack: "Cancelled.", edit: { text: body, rows: linksFor(target), tokens: [] } };
         const minted = mintDecideButtons(store, seat, target, offer, now, input.message);

package/dist/desktop-update.d.ts

@@ -125,13 +125,13 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
-    error?: never;
     active: boolean;
     phase: string;
     detail: string;
     running: boolean;
     canResume: boolean;
     canCancel: boolean;
+    error?: never;
     automaticRecovery?: never;
     recoveryAttempts?: never;
     recoveryRepairs?: never;

package/dist/mate-progress.d.ts

@@ -12,14 +12,40 @@ export type MateProgress = {
     kind: "tool";
     turn: number;
     step: number;
+    id: string;
     label: string;
+} | {
+    kind: "tool-result";
+    turn: number;
+    step: number;
+    id: string;
+    outcome: MateToolOutcome;
 } | {
     kind: "text";
     turn: number;
     step: number;
     text: string;
 };
+export type MateToolOutcome = {
+    state: "succeeded";
+} | {
+    state: "failed";
+    reason: string;
+};
+export type MateLiveTool = {
+    id: string;
+    label: string;
+} & ({
+    state: "running";
+} | MateToolOutcome);
+/** Keep tools as labels for older clients; toolCalls adds per-call outcomes. */
+export type MateLiveStep = {
+    tools: string[];
+    toolCalls: MateLiveTool[];
+    text: string;
+};
 export declare function mateToolLabel(name: string): string;
+export declare function mateToolFailureReason(name: string, message: string): string;
 /** The `text` of a structured answer still being written, when the answer
  * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
  * an escape cut off at the end is left for the next chunk. */

package/dist/mate-progress.js

@@ -43,6 +43,30 @@ export function mateToolLabel(name) {
         return TOOL_LABELS[name];
     return name.startsWith("propose_") ? "Preparing a card for you to confirm" : "Working";
 }
+/** Tool errors instruct the model how to retry. Only known, fixed copy belongs
+ * in the live UI; never echo arguments, redaction placeholders or exceptions. */
+const TOOL_FAILURE_REASONS = new Map([
+    ["Choose a project from list_repos.", "That project isn't available."],
+    ["Choose an available project from list_repos.", "That project isn't available."],
+    ["repo must be one of the ids from list_repos", "That project isn't available."],
+    ["not-found: no such task in your projects", "That task isn't available in your projects."],
+    ["That task is not in your projects.", "That task isn't available in your projects."],
+    ["not-found: no such decision in your projects", "That decision isn't available in your projects."],
+    ["that decision is no longer open", "That decision is already closed."],
+    ["No such flow in your projects.", "No such flow in your projects."],
+    ["That action is outside your access.", "You don't have access to that action."],
+    ["Read the current task version before proposing this action.", "The task needs to be checked again before this action."],
+    ["That file is not in these changes. Call get_diff without file for the list.", "That file isn't in the saved changes."],
+    ["The saved changes could not be verified.", "The saved changes could not be verified."],
+    ["The saved check log could not be verified.", "The saved check log could not be verified."],
+    ["Saved results are unavailable here.", "Saved results are unavailable here."],
+    ["There is no finished result for that version yet.", "There is no finished result for that version yet."],
+    ["Task text cannot contain credentials.", "The task text contains a password or secret key."],
+    ["that tool refused — the plane could not answer it right now", "Toolroll couldn't finish that step right now."],
+]);
+export function mateToolFailureReason(name, message) {
+    return TOOL_FAILURE_REASONS.get(message) ?? `That step didn't work (${mateToolLabel(name)}).`;
+}
 /** The `text` of a structured answer still being written, when the answer
  * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
  * an escape cut off at the end is left for the next chunk. */

package/dist/mate.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { mateToolLabel } from "./mate-progress.js";
+import { mateToolFailureReason, mateToolLabel } from "./mate-progress.js";
 import { createHash } from "node:crypto";
 import { mateTimeoutNotice } from "./store.js";
 import { RESULT_IMAGES_PER_TURN_CAP } from "./chat-evidence.js";
@@ -499,8 +499,17 @@ export async function runMateTurn(input) {
                 if (changed !== null)
                     return changed;
             }
-            progress({ kind: "tool", turn: turnId, step: steps, label: mateToolLabel(call.name) });
+            // Position within this turn is unique even if a provider reuses call ids.
+            const progressId = `${turnId}:${steps}:${index}`;
+            progress({ kind: "tool", turn: turnId, step: steps, id: progressId, label: mateToolLabel(call.name) });
             const outcome = executeMateTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, ask, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
+            let displayOutcome = { state: "succeeded" };
+            if (!outcome.ok) {
+                const reason = mateToolFailureReason(call.name, outcome.message);
+                displayOutcome = { state: "failed", reason: scanForSecrets(reason).length === 0
+                        ? reason : `That step didn't work (${mateToolLabel(call.name)}).` };
+            }
+            progress({ kind: "tool-result", turn: turnId, step: steps, id: progressId, outcome: displayOutcome });
             if (READ_TOOLS.has(call.name))
                 reads++;
             if (call.name === "show_control" && outcome.ok)

package/dist/serve.js

@@ -4540,14 +4540,25 @@ export function createDecisionServer(options) {
             clearTimeout(previous.expiry);
         const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set() };
         liveTurns.set(thread, live);
-        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], text: "" }), live.steps.at(-1));
+        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], toolCalls: [], text: "" }), live.steps.at(-1));
         return event => {
             if (live.done)
                 return;
             if (event.kind === "step")
-                live.steps.push({ tools: [], text: "" });
-            else if (event.kind === "tool")
+                live.steps.push({ tools: [], toolCalls: [], text: "" });
+            else if (event.kind === "tool") {
                 current().tools.push(event.label);
+                current().toolCalls.push({ id: event.id, label: event.label, state: "running" });
+            }
+            else if (event.kind === "tool-result") {
+                for (const step of live.steps) {
+                    const index = step.toolCalls.findIndex(tool => tool.id === event.id);
+                    if (index !== -1) {
+                        step.toolCalls[index] = { ...step.toolCalls[index], ...event.outcome };
+                        break;
+                    }
+                }
+            }
             else if (event.kind === "text")
                 current().text = event.text;
             for (const listener of live.listeners)

package/dist/telegram-flow.d.ts

@@ -11,6 +11,12 @@ type Waiting = {
 };
 /** The card, if it is still at that visit, waiting at a decision. */
 export declare function flowDecisionAt(store: Store, cardId: number, entry: number): Waiting | null;
+/**
+ * A flow decision as Telegram shows it: the action and where each button takes the card first, then the draft (as
+ * the card holds it now, so what is approved is what is read) and why a teammate handed it over, then the flow and
+ * zone. `said` is the saved notice's body: the words before its instruction are the teammate's handoff.
+ */
+export declare function flowDecisionText(waiting: Waiting, said: string | null, head?: string): string;
 /** Buttons for one visit, minted before the send; `place` stamps the message they landed on. */
 export declare function flowButtons(store: Store, binding: TelegramBinding, waiting: Waiting, now: Date): {
     keyboard: InlineButton[][];
@@ -20,6 +26,9 @@ export declare function flowButtons(store: Store, binding: TelegramBinding, wait
 export declare function flowSentContent(store: Store, card: number, entry: number): FlowSendContent | null;
 /** A sent visit's links as one row of buttons: Toolroll's pages under the trusted origin, and its pull request. */
 export declare function flowSendKeyboardRow(origin: string | null, content: FlowSendContent): InlineButton[];
+/** A choice as Telegram shows it, first: what to choose, then where each option (and a reply) takes the card. The
+ * options are the ones its buttons carry: offered when sent, and still offered. */
+export declare function flowChoiceHead(visit: FlowChoiceVisit, content: FlowSendContent): string[];
 /** A choice's buttons for one visit, one option to a row, minted before the send; `place` stamps the message they landed on. */
 export declare function flowChoiceButtons(store: Store, binding: TelegramBinding, visit: FlowChoiceVisit, content: FlowSendContent, now: Date): {
     keyboard: InlineButton[][];

package/dist/telegram-flow.js

@@ -24,7 +24,7 @@ import { LIMITS } from "./decision.js";
 import { keptDraft } from "./flow-draft.js";
 import { decideFlowCard, draftFor, flowDefinitionOf } from "./flow-engine.js";
 import { chooseFlowCard, flowChoiceAt, flowSendPaths, readFlowSend } from "./flow-send.js";
-import { deciderOf } from "./flows.js";
+import { deciderOf, FLOW_END, replyTarget } from "./flows.js";
 import { phoneLinkButton } from "./telegram-mate.js";
 import { telegramButton } from "./contracts/telegram-callback.js";
 export const FLOW_DECIDE_KEY = /^flow-decide:([1-9][0-9]{0,14}):([1-9][0-9]{0,9})$/;
@@ -41,6 +41,29 @@ export function flowDecisionAt(store, cardId, entry) {
         return null;
     return { card, flow, stage, draft: draftFor(definition, stage) };
 }
+/** Where Approve and Send back take the card, on one line. */
+function decisionTerms(waiting) {
+    const approve = waiting.stage.next === null ? "Approve → done" : `Approve → ${titleOf(waiting, waiting.stage.next)}`;
+    return [approve, ...(waiting.stage.onFail === null ? [] : [`Send back → ${titleOf(waiting, waiting.stage.onFail)}, with your note`])].join(" · ");
+}
+/**
+ * A flow decision as Telegram shows it: the action and where each button takes the card first, then the draft (as
+ * the card holds it now, so what is approved is what is read) and why a teammate handed it over, then the flow and
+ * zone. `said` is the saved notice's body: the words before its instruction are the teammate's handoff.
+ */
+export function flowDecisionText(waiting, said, head = `Approve “${waiting.card.title}”`) {
+    const at = said === null ? -1 : said.indexOf(`${waiting.stage.title}: approve`);
+    const handoff = at > 0 ? said.slice(0, at).trim() : "";
+    const draft = waiting.draft === null ? undefined : waiting.card.outputs[waiting.draft.id]?.trim();
+    return [
+        head,
+        decisionTerms(waiting),
+        ...(handoff === "" ? [] : ["", handoff]),
+        ...(draft === undefined || draft === "" ? [] : ["", "Draft:", draft]),
+        "",
+        `${waiting.flow.name} · ${waiting.stage.title}`,
+    ].join("\n");
+}
 /** Buttons for one visit, minted before the send; `place` stamps the message they landed on. */
 export function flowButtons(store, binding, waiting, now) {
     const mint = (action) => ({ action, token: randomBytes(16).toString("hex") });
@@ -64,6 +87,17 @@ export function flowSendKeyboardRow(origin, content) {
     const pull = content.links.flatMap(one => "url" in one ? [{ text: one.label, url: one.url }] : []);
     return [...pages.slice(0, 1), ...pull, ...pages.slice(1)].slice(0, 3);
 }
+/** A choice as Telegram shows it, first: what to choose, then where each option (and a reply) takes the card. The
+ * options are the ones its buttons carry: offered when sent, and still offered. */
+export function flowChoiceHead(visit, content) {
+    const titleIn = (id) => visit.definition.stages.find(one => one.id === id)?.title ?? id;
+    const options = (content.options ?? []).flatMap(one => {
+        const option = visit.stage.options?.[one.choice];
+        return option === undefined || option.label !== one.label ? [] : [`${one.label} → ${option.to === FLOW_END ? "closes the card" : titleIn(option.to)}`];
+    });
+    const reply = content.reply === true ? replyTarget(visit.stage) : null;
+    return [`Choose what happens to “${visit.card.title}”`, [...options, ...(reply === null ? [] : [`or reply → ${titleIn(reply)}, with your note`])].join(" · ")];
+}
 /** A choice's buttons for one visit, one option to a row, minted before the send; `place` stamps the message they landed on. */
 export function flowChoiceButtons(store, binding, visit, content, now) {
     // Only the options the zone still offers as they were sent: a flow changed since sends no stale button.
@@ -88,7 +122,9 @@ export function applyFlowChoiceTap(store, binding, choice, message, repos, now)
     if (!chosen.ok)
         return [{ kind: "ack", text: chosen.message.slice(0, 190) }];
     store.retireFlowChoices(choice.card, choice.entry, now);
-    return [{ kind: "ack", text: choice.label.slice(0, 190) }, { kind: "edit", text: `${message.text}\n\n✅ You chose “${choice.label}”. ${chosen.said}`.slice(0, 4000) }];
+    // The door's words name the option already ("Ship it. Moved to Ship."); an ending says what happened instead.
+    const said = chosen.said.startsWith(`${choice.label}.`) ? chosen.said : `You chose “${choice.label}”. ${chosen.said}`;
+    return [{ kind: "ack", text: choice.label.slice(0, 190) }, { kind: "edit", text: `${message.text}\n\n✅ ${said}`.slice(0, 4000) }];
 }
 /** A tapped flow button, applied inside the update's transaction. */
 export function applyFlowTap(store, binding, action, message, repos, now) {
@@ -107,7 +143,7 @@ export function applyFlowTap(store, binding, action, message, repos, now) {
         if (!decided.ok)
             return [{ kind: "ack", text: decided.message.slice(0, 190) }];
         store.retireTelegramFlowVisit(action.card, action.entry, now);
-        return [{ kind: "ack", text: "Approved" }, { kind: "edit", text: `${message.text}\n\n✅ You approved it. ${decided.said}`.slice(0, 4000) }];
+        return [{ kind: "ack", text: "Approved" }, { kind: "edit", text: `${message.text}\n\n✅ ${decided.said}`.slice(0, 4000) }];
     }
     const prompt = { chatId: binding.chatId, binding: binding.id, card: action.card, entry: action.entry, mode: action.action };
     if (action.action === "edit") {
@@ -157,8 +193,7 @@ export function applyFlowReply(store, binding, prompt, text, repos, now) {
         store.retireTelegramFlowVisit(prompt.card, prompt.entry, now);
         const fresh = flowDecisionAt(store, prompt.card, prompt.entry);
         const buttons = flowButtons(store, binding, fresh, now);
-        return [{ kind: "decide", keyboard: buttons.keyboard, tokens: buttons.tokens,
-                text: `${waiting.flow.name}: your version of the draft for “${waiting.card.title}”\n\n${kept}\n\nApprove to send it as written.` }];
+        return [{ kind: "decide", keyboard: buttons.keyboard, tokens: buttons.tokens, text: flowDecisionText(fresh, null, `Approve your version of “${waiting.card.title}”`) }];
     }
     // A note over its limit is refused with the limit, never cut.
     if (said.length > LIMITS.note)

package/dist/telegram-mate.js

@@ -256,7 +256,7 @@ export function applyProposalTap(store, binding, token, message, repos, options,
             return;
         }
         ack("irreversible — confirm it");
-        edit(`⚠ This answer is IRREVERSIBLE.\n\n${body}\n\nConfirm?`, [
+        edit(`${body}\n\n⚠ Last step: this answer can't be undone. Confirm?`, [
             [telegramButton("⚠ Yes, answer it", yes)],
             [telegramButton("Cancel", cancel)],
         ]);

package/dist/telegram.js

@@ -34,7 +34,7 @@ import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerso
 import { BATCH_MS, chatText, chatTitle, factLinkLabel, mentions, nameTelegramBot } from "./chat-voice.js";
 import { LEAD_SAY_KIND, enqueueLeadLapses, leadSayEarlier, leadSayText, leadSubjectOf } from "./lead-voice.js";
 import { applyTeamInbound, deliverTeamChats, teamCommand } from "./telegram-team.js";
-import { applyFlowChoiceTap, applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowChoiceButtons, flowDecisionAt, flowSendKeyboardRow, flowSentContent } from "./telegram-flow.js";
+import { applyFlowChoiceTap, applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowChoiceButtons, flowChoiceHead, flowDecisionAt, flowDecisionText, flowSendKeyboardRow, flowSentContent } from "./telegram-flow.js";
 import { flowChoiceAt, flowSendTail, FLOW_CHOOSE_KEY, FLOW_SEND_KEY } from "./flow-send.js";
 import { cleanFlowMessage, fitFlowMessage } from "./flow-items.js";
 import { telegramReply } from "./reply-shape.js";
@@ -634,7 +634,7 @@ function decideOfferFor(store, binding, target, projects, now, root) {
     if (target === null || target === undefined)
         return null;
     const principal = verifyApproverStanding(store, binding.approver, binding.approverGeneration, telegramConversationRepos(store, binding.approver, projects));
-    return principal.ok ? decideOffer(store, target, principal.who, now, root) : null;
+    return principal.ok ? decideOffer(store, target, principal.who, now, root, "telegram") : null;
 }
 /** 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) {
@@ -1225,13 +1225,23 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         } })();
         if (sentRow !== null)
             button = sentRow.length === 0 ? null : sentRow;
+        // A flow decision or choice for this person leads with what to do and where each button takes the card
+        // (telegram-flow.ts); the flow and zone close it. The saved notice keeps its own words for every other place.
+        const pull = sent === null ? [] : sent.links.flatMap(one => "url" in one ? [`${one.label}: ${one.url}`] : []).slice(0, 1);
+        const choiceHead = choosing === null || sent === null ? null : flowChoiceHead(choosing, sent);
+        const choiceTail = choosing === null ? [] : [...pull, `${choosing.flow.name}${sent?.from === undefined ? "" : ` · after ${sent.from}`}`];
+        if (offer === null && flowKeys !== null && waiting !== null)
+            parts = split(`${notificationIdentity(notification)}${chatText(flowDecisionText(waiting, notification.body), task)}`);
+        else if (offer === null && choiceHead !== null && sent !== null)
+            parts = split(`${notificationIdentity(notification)}${chatText([...choiceHead, "", sent.summary, "", ...choiceTail.flatMap((line, index) => index === 0 ? [line] : ["", line])].join("\n"), task)}`);
         // After research (flow-items.ts): each item numbered under the summary, its words cleaned as the rest of the message's
         // are, within Telegram's limit with every link kept — one message, unless head, links and tail alone overflow it.
         let entities = [];
         if (sent?.items !== undefined && sent.items.length > 0 && offer === null) {
             const subject = chatText(leadSubjectOf(store, notification, binding.approver), task);
-            const head = `${notificationIdentity(notification, title !== undefined && mentions(subject, title) ? undefined : title)}${subject}`;
-            const message = cleanFlowMessage({ head, summary: sent.summary, items: sent.items, tail: flowSendTail(sent) }, words => chatText(words, task));
+            const head = choiceHead !== null ? `${notificationIdentity(notification)}${choiceHead.join("\n")}`
+                : `${notificationIdentity(notification, title !== undefined && mentions(subject, title) ? undefined : title)}${subject}`;
+            const message = cleanFlowMessage({ head, summary: sent.summary, items: sent.items, tail: choiceHead !== null ? choiceTail : flowSendTail(sent) }, words => chatText(words, task));
             const voiced = fitFlowMessage(message, TELEGRAM_TEXT_MAX, shaped => telegramReply(shaped).text.length).map(telegramReply);
             parts = voiced.map(one => one.text);
             entities = voiced.map(one => one.entities);
@@ -1268,24 +1278,11 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         return { ok: true, receipt: receiptFor(botId, binding.chatId, last) };
     }
     // A decision. Every safety-bearing word goes out before anything tappable
-    // exists: recap, question, and every option's consequence, split across as
-    // many plain messages as they need — a button whose warning was truncated
-    // away is a trap, so the keyboard rides the LAST part only, and only if
-    // every earlier part arrived.
-    const lines = [
-        `${notificationIdentity(notification)}Decision needed`,
-        "",
-        decision.recap,
-        "",
-        `Q: ${decision.question}`,
-        "",
-        ...decision.options.flatMap(option => [
-            `[${option.id}] ${option.label}${option.id === decision.recommendation ? "  (recommended)" : ""}${option.reversible ? "" : "  — IRREVERSIBLE"}`,
-            `    ${option.consequence}`,
-        ]),
-        ...(decision.deadline === null ? [] : ["", `deadline: ${decision.deadline}`]),
-    ];
-    const parts = split(lines.join("\n"));
+    // exists: the question and every option's consequence first, then the
+    // recap, split across as many plain messages as they need — a button whose
+    // warning was truncated away is a trap, so the keyboard rides the LAST part
+    // only, and only if every earlier part arrived.
+    const parts = split([`${notificationIdentity(notification)}${decisionAsk(decision)}`, "", `Background: ${decision.recap}`].join("\n"));
     for (const part of parts.slice(0, -1)) {
         const sent = await sender(part);
         if (!sent.ok)
@@ -2382,7 +2379,7 @@ function applyCallback(context, update, effects) {
             store.createTelegramAction({ token: confirm, binding: binding.id, decision: decision.id, optionId: option.id, phase: "confirm", chatId: binding.chatId, messageId: placedOn, ttlMs: CONFIRM_TTL_MS, ...(digest === undefined ? {} : { noteDigest: digest }) }, clock());
             store.createTelegramAction({ token: cancel, binding: binding.id, decision: decision.id, optionId: option.id, phase: "cancel", chatId: binding.chatId, messageId: placedOn, ttlMs: CONFIRM_TTL_MS }, clock());
             ack("irreversible — confirm it");
-            editText(`⚠ ${option.label} is IRREVERSIBLE.\n${option.consequence}\n${draft === null ? "" : `\nWith your note:\n${draft.note.split("\n").map(line => `| ${line}`).join("\n")}\n`}\nConfirm?`, [
+            editText(armedDecisionText(option, draft?.note ?? null), [
                 [telegramButton(`⚠ Yes, ${option.label}`, confirm)],
                 [telegramButton("Cancel", cancel)],
             ]);
@@ -2430,7 +2427,9 @@ function applyCallback(context, update, effects) {
         store.createTelegramAction({ token: choose, binding: binding.id, decision: decision.id, optionId: option.id, phase: "choose", chatId: binding.chatId, messageId: String(message.message_id) }, clock());
     }
     ack("cancelled");
-    editText(`Q: ${decision.question}`, fresh.map(({ option, token: choose }) => [
+    // The card again, within one message; a decision too long for one keeps the consequences its earlier parts show.
+    const ask = decisionAsk(decision);
+    editText(ask.length <= PART_CAP ? ask : `Decide: ${decision.question}`, fresh.map(({ option, token: choose }) => [
         telegramButton(`${option.label}${option.id === decision.recommendation ? " ✓" : ""}${option.reversible ? "" : " ⚠"}`, choose),
     ]));
 }
@@ -2460,10 +2459,27 @@ function answerNow(context, decision, choice, binding, ack, editText) {
     }
     ack(`could not answer: ${answered.reason}`);
 }
+/** A decision's card, action first: the question, then each option with what it does, then its deadline. */
+function decisionAsk(decision) {
+    return [
+        `Decide: ${decision.question}`,
+        ...decision.options.map(option => `• ${option.label}${option.id === decision.recommendation ? " (recommended)" : ""}${option.reversible ? "" : " ⚠ can't be undone"}: ${option.consequence}`),
+        ...(decision.deadline === null ? [] : [`Decide by ${decision.deadline.slice(0, 16).replace("T", " ")} UTC`]),
+    ].join("\n");
+}
+/** The armed confirm of an option that can't be undone: what it is and what it does, then the note that travels. */
+function armedDecisionText(option, note) {
+    return [
+        `${option.label}? ⚠ This can't be undone.`,
+        option.consequence,
+        ...(note === null ? [] : ["", "With your note:", ...note.split("\n").map(line => `| ${line}`)]),
+    ].join("\n");
+}
 function answeredText(store, decision) {
+    const chosen = decision.options.find(one => one.id === decision.choice)?.label ?? decision.choice ?? "?";
     return [
-        `✓ ${taskOf(store, decision)} — answered: ${decision.choice ?? "?"}`,
-        `by ${decision.answeredBy ?? "?"} via ${decision.answeredVia ?? "?"}`,
+        `✓ Answered: ${chosen}`,
+        `${taskOf(store, decision)} · by ${decision.answeredBy ?? "?"} via ${decision.answeredVia ?? "?"}`,
         // Line-prefixed, never inline: a multiline note must not be able to
         // draw fake status lines (Codex free-text review, finding 7).
         ...(decision.note === null ? [] : ["with note:", ...decision.note.split("\n").map(line => `| ${line}`)]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.37",
+  "version": "0.9.38",
   "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"
@@ -64,18 +64,18 @@
   },
   "devDependencies": {
     "@tailwindcss/cli": "4.3.3",
-    "@types/mailparser": "3.4.6",
-    "@types/node": "26.2.0",
+    "@types/mailparser": "3.9.0",
+    "@types/node": "26.6.4",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
     "esbuild": "0.28.2",
-    "happy-dom": "20.12.0",
+    "happy-dom": "20.14.5",
     "paper": "0.12.18",
     "simple-icons": "16.34.0",
     "tailwindcss": "4.3.3",
-    "tsx": "4.23.12",
+    "tsx": "4.23.15",
     "typescript": "7.0.2",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "files": [
     "dist",
@@ -93,6 +93,11 @@
     "scripts/fixtures/restart-service.mjs",
     "THIRD_PARTY_NOTICES.md"
   ],
+  "overrides": {
+    "@tailwindcss/cli@4.3.3": {
+      "@parcel/watcher": "2.6.0"
+    }
+  },
   "dependencies": {
     "@radix-ui/react-collapsible": "1.1.20",
     "@radix-ui/react-dialog": "1.1.23",
@@ -105,15 +110,15 @@
     "@radix-ui/react-switch": "1.3.7",
     "@radix-ui/react-tabs": "1.1.21",
     "@radix-ui/react-tooltip": "1.2.16",
-    "@slack/socket-mode": "3.0.1",
-    "@xyflow/react": "12.11.6",
+    "@slack/socket-mode": "3.1.0",
+    "@xyflow/react": "12.12.0",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "discord.js": "14.27.0",
-    "imapflow": "2.0.6",
-    "lucide-react": "1.47.0",
-    "mailparser": "3.9.28",
-    "nodemailer": "10.0.10",
+    "imapflow": "2.2.5",
+    "lucide-react": "1.52.0",
+    "mailparser": "3.9.36",
+    "nodemailer": "10.0.15",
     "react": "19.3.0",
     "react-dom": "19.3.0",
     "sonner": "2.0.8",