toolroll 0.9.42 → 0.9.43

package/dist/telegram-flow.js

@@ -22,12 +22,13 @@
 import { randomBytes } from "node:crypto";
 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 { decideFlowCard, draftFor, flowCardHref, flowDefinitionOf } from "./flow-engine.js";
+import { chooseFlowCard, flowChoiceAt, flowPersonOf, flowSendPaths, readFlowSend } from "./flow-send.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})$/;
+/** A flow decision's notice: one per visit, and again (`:ask:<ms>`) when the owner asks the lead to approve it. */
+export const FLOW_DECIDE_KEY = /^flow-decide:([1-9][0-9]{0,14}):([1-9][0-9]{0,9})(?::ask:[0-9]{1,15})?$/;
 const DRAFT_LIMIT = 4000;
 /** The card, if it is still at that visit, waiting at a decision. */
 export function flowDecisionAt(store, cardId, entry) {
@@ -126,24 +127,66 @@ export function applyFlowChoiceTap(store, binding, choice, message, repos, now)
     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 card's own fresh buttons, as a repaint carries them. */
+function freshButtons(store, binding, waiting, now) {
+    const minted = flowButtons(store, binding, waiting, now);
+    return { keyboard: minted.keyboard.map(row => row.flatMap(one => "callback_data" in one && typeof one.callback_data === "string" ? [{ label: one.text, token: one.callback_data }] : [])), place: minted.tokens };
+}
+const CONFIRM_TTL_MS = 10 * 60_000;
+const FLOW_QUESTION = /\n\nApprove “[^\n]*”\? [^\n]*$/;
+/** Where a card is now, for a message whose buttons no longer act: named and linked only when it is in one of the
+ * viewer's projects, and linked only while it still waits on someone. Never a live button. */
+export function flowWhereNow(store, cardId, repos) {
+    const card = store.getFlowCard(cardId);
+    const flow = card === null ? null : store.getFlow(card.flow);
+    if (card === null || flow === null || repos === null || !repos.includes(flow.repo))
+        return { said: "This card has moved on since.", keyboard: [] };
+    if (card.state !== "active")
+        return { said: card.state === "done" ? "This card is done." : "This card was closed.", keyboard: [] };
+    const definition = flowDefinitionOf(flow);
+    const stage = definition?.stages.find(one => one.id === card.stage);
+    const where = stage?.title ?? card.stage;
+    const open = { label: "Open it in Flows", path: flowCardHref(flow.id, card.id) };
+    if (stage?.kind === "approval" || stage?.kind === "choose") {
+        const person = stage.kind === "approval" ? deciderOf(stage, flow) ?? "an approver" : flowPersonOf(card, flow);
+        return { said: `It's waiting for ${person} in ${where} (${flow.name}).`, keyboard: [[{ label: open.label, link: open }]] };
+    }
+    if (card.waiting !== null)
+        return { said: `It's in ${where} now (${flow.name}): ${card.waiting.replace(/\.$/, "")}.`, keyboard: [[{ label: open.label, link: open }]] };
+    return { said: `It moved on to ${where} (${flow.name}).`, keyboard: [] };
+}
 /** A tapped flow button, applied inside the update's transaction. */
 export function applyFlowTap(store, binding, action, message, repos, now) {
-    if (action.consumedAt !== null || action.expiresAt <= now.toISOString())
-        return [{ kind: "ack", text: "That was already decided, or these buttons are too old." }];
+    if (action.consumedAt !== null || action.expiresAt <= now.toISOString()) {
+        // Spent or too old: say where the card is now, with a way to it while it still waits. The old button never acts again.
+        const now_ = flowWhereNow(store, action.card, repos);
+        return [{ kind: "ack", text: "These buttons were already used, or are too old." }, { kind: "edit", text: `${message.text.replace(FLOW_QUESTION, "")}\n\nThese buttons were already used, or are too old. ${now_.said}`.slice(0, 4000), keyboard: now_.keyboard }];
+    }
     const waiting = flowDecisionAt(store, action.card, action.entry);
-    if (waiting === null)
-        return [{ kind: "ack", text: "That card has moved on since; nothing was changed." }];
+    if (waiting === null) {
+        const now_ = flowWhereNow(store, action.card, repos);
+        store.retireTelegramFlowVisit(action.card, action.entry, now);
+        return [{ kind: "ack", text: "That card has moved on since; nothing was changed." }, { kind: "edit", text: `${message.text}\n\nNothing was changed. ${now_.said}`.slice(0, 4000), keyboard: now_.keyboard }];
+    }
     const decider = deciderOf(waiting.stage, waiting.flow);
     if (decider !== null && decider !== binding.approver)
         return [{ kind: "ack", text: `Only ${decider} decides here.` }];
     if (action.action === "approve") {
+        // The first tap asks; only the Yes decides, bound to exactly this visit of this card, on this message.
         if (repos === null)
             return [{ kind: "ack", text: "Couldn't check your projects just now. Try again in a moment." }];
-        const decided = decideFlowCard(store, { card: waiting.card.id, decision: "approve", note: null, actor: binding.approver, repos, entry: action.entry }, now);
-        if (!decided.ok)
-            return [{ kind: "ack", text: decided.message.slice(0, 190) }];
+        if (!repos.includes(waiting.flow.repo))
+            return [{ kind: "ack", text: "That card isn't in one of your projects now." }];
         store.retireTelegramFlowVisit(action.card, action.entry, now);
-        return [{ kind: "ack", text: "Approved" }, { kind: "edit", text: `${message.text}\n\n✅ ${decided.said}`.slice(0, 4000) }];
+        const mint = (phase) => {
+            const token = randomBytes(16).toString("hex");
+            store.handle.prepare("INSERT INTO telegram_flow_confirm (token, binding, chat_id, message_id, card, entry, phase, created_at, expires_at) VALUES (?,?,?,?,?,?,?,?,?)")
+                .run(token, binding.id, binding.chatId, message.messageId, action.card, action.entry, phase, now.toISOString(), new Date(now.getTime() + CONFIRM_TTL_MS).toISOString());
+            return token;
+        };
+        const where = waiting.stage.next === null ? "The card is then done." : `It moves to ${titleOf(waiting, waiting.stage.next)}.`;
+        return [{ kind: "ack", text: "Confirm below." }, { kind: "edit", text: `${message.text}\n\nApprove “${waiting.card.title}”? ${where}`.slice(0, 4000),
+                keyboard: [[{ label: "Yes", token: mint("yes") }, { label: "Cancel", token: mint("cancel") }]] }];
     }
     const prompt = { chatId: binding.chatId, binding: binding.id, card: action.card, entry: action.entry, mode: action.action };
     if (action.action === "edit") {
@@ -154,6 +197,47 @@ export function applyFlowTap(store, binding, action, message, repos, now) {
     return [{ kind: "ack", text: "What should change?" }, { kind: "prompt", prompt, placeholder: "What should change",
             text: `What should change on “${waiting.card.title}”? Reply to this message and it goes back to ${back} with your note.` }];
 }
+/** A Yes or Cancel this module armed, or null when the token isn't one. */
+export function flowConfirmOf(store, token) {
+    if (!/^[0-9a-f]{32}$/.test(token))
+        return null;
+    const row = store.handle.prepare("SELECT * FROM telegram_flow_confirm WHERE token = ?").get(token);
+    if (row === undefined)
+        return null;
+    return { token: String(row["token"]), binding: Number(row["binding"]), chatId: String(row["chat_id"]), messageId: String(row["message_id"]), card: Number(row["card"]), entry: Number(row["entry"]),
+        phase: String(row["phase"]) === "cancel" ? "cancel" : "yes", expiresAt: String(row["expires_at"]), consumedAt: row["consumed_at"] == null ? null : String(row["consumed_at"]) };
+}
+/** The second tap, inside the update's transaction: Yes decides the card through the console's door, once; Cancel puts
+ * the card's own buttons back. The caller has proved the binding, chat and message are the ones it was armed on. */
+export function applyFlowConfirm(store, binding, confirm, message, repos, now) {
+    const body = message.text.replace(FLOW_QUESTION, "");
+    const spend = () => store.handle.prepare("UPDATE telegram_flow_confirm SET consumed_at = ? WHERE card = ? AND entry = ? AND message_id = ? AND consumed_at IS NULL").run(now.toISOString(), confirm.card, confirm.entry, confirm.messageId);
+    if (confirm.consumedAt !== null || confirm.expiresAt <= now.toISOString()) {
+        spend();
+        const now_ = flowWhereNow(store, confirm.card, repos);
+        const waiting = flowDecisionAt(store, confirm.card, confirm.entry);
+        // Too old, but the same visit still waits: fresh buttons, never the old Yes.
+        if (waiting !== null && repos !== null && repos.includes(waiting.flow.repo)) {
+            return [{ kind: "ack", text: "That Yes expired. Nothing was done." }, { kind: "edit", text: body, ...freshButtons(store, binding, waiting, now) }];
+        }
+        return [{ kind: "ack", text: "That Yes expired. Nothing was done." }, { kind: "edit", text: `${body}\n\nNothing was done. ${now_.said}`.slice(0, 4000), keyboard: now_.keyboard }];
+    }
+    spend();
+    const waiting = flowDecisionAt(store, confirm.card, confirm.entry);
+    if (waiting === null || repos === null) {
+        const now_ = flowWhereNow(store, confirm.card, repos);
+        return [{ kind: "ack", text: repos === null ? "Couldn't check your projects just now. Try again in a moment." : "That card has moved on since; nothing was changed." },
+            { kind: "edit", text: `${body}\n\nNothing was changed. ${now_.said}`.slice(0, 4000), keyboard: now_.keyboard }];
+    }
+    if (confirm.phase === "cancel") {
+        return [{ kind: "ack", text: "Cancelled." }, { kind: "edit", text: body, ...freshButtons(store, binding, waiting, now) }];
+    }
+    const decided = decideFlowCard(store, { card: waiting.card.id, decision: "approve", note: null, actor: binding.approver, repos, entry: confirm.entry, where: "Telegram" }, now);
+    if (!decided.ok)
+        return [{ kind: "ack", text: "Not done." }, { kind: "edit", text: `${body}\n\n✗ Not done: ${decided.message}`.slice(0, 4000), keyboard: flowWhereNow(store, confirm.card, repos).keyboard }];
+    store.retireTelegramFlowVisit(confirm.card, confirm.entry, now);
+    return [{ kind: "ack", text: "Approved" }, { kind: "edit", text: `${body}\n\n✅ ${decided.said}`.slice(0, 4000) }];
+}
 const titleOf = (waiting, id) => flowDefinitionOf(waiting.flow)?.stages.find(one => one.id === id)?.title ?? id;
 /** A reply to an Edit or Send back prompt, applied inside the update's transaction. */
 export function applyFlowReply(store, binding, prompt, text, repos, now) {
@@ -200,7 +284,7 @@ export function applyFlowReply(store, binding, prompt, text, repos, now) {
         return [{ kind: "say", text: `That's ${said.length.toLocaleString("en-US")} characters. Keep the note to ${LIMITS.note.toLocaleString("en-US")}, or send it back in Toolroll.` }];
     if (repos === null)
         return [{ kind: "say", text: "Couldn't check your projects just now. Reply again in a moment." }];
-    const decided = decideFlowCard(store, { card: waiting.card.id, decision: "send-back", note: said, actor: binding.approver, repos, entry: prompt.entry }, now);
+    const decided = decideFlowCard(store, { card: waiting.card.id, decision: "send-back", note: said, actor: binding.approver, repos, entry: prompt.entry, where: "Telegram" }, now);
     if (!decided.ok)
         return [{ kind: "say", text: decided.message }];
     store.retireTelegramFlowVisit(prompt.card, prompt.entry, now);

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, flowChoiceHead, flowDecisionAt, flowDecisionText, flowSendKeyboardRow, flowSentContent } from "./telegram-flow.js";
+import { applyFlowChoiceTap, applyFlowConfirm, applyFlowReply, applyFlowTap, flowConfirmOf, 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";
@@ -1523,7 +1523,8 @@ async function enrolledForMessage(context, update) {
 async function projectsForTap(context, update) {
     const callback = update.callback_query;
     // Flow decision buttons (v86) work with or without the lead's conversation on this phone.
-    const flowTap = callback !== undefined && (context.store.getTelegramFlowAction(callback.data ?? "") !== null || context.store.getTelegramFlowChoice(callback.data ?? "") !== null);
+    const flowTap = callback !== undefined && (context.store.getTelegramFlowAction(callback.data ?? "") !== null || context.store.getTelegramFlowChoice(callback.data ?? "") !== null
+        || flowConfirmOf(context.store, callback.data ?? "") !== null);
     // So do a result's, plan's or pull request's own buttons (chat-decide.ts).
     const decideTap = callback !== undefined && isDecideToken(context.store, callback.data ?? "");
     if (callback === undefined || context.readProjects === undefined || (context.conversation === undefined && !flowTap && !decideTap))
@@ -2172,6 +2173,29 @@ function applyCallback(context, update, effects) {
         }
         return;
     }
+    // A flow decision's repaint: its buttons (fresh ones stamped on this message) or links under the console.
+    const flowEdit = (effect) => {
+        if (effect.place !== undefined && effect.place.length > 0)
+            store.placeTelegramFlowActions(effect.place, String(message.message_id));
+        editText(effect.text, decideKeyboard(context.conversation?.phoneOrigin, effect.keyboard ?? []));
+    };
+    // The Yes or Cancel a flow Approve armed (telegram-flow.ts): on the message it was armed on, by the person it was armed for.
+    const flowConfirm = flowConfirmOf(store, token);
+    if (flowConfirm !== null) {
+        if (flowConfirm.binding !== binding.id || flowConfirm.chatId !== tapChat || flowConfirm.messageId !== String(message.message_id)) {
+            report.ignored++;
+            ack("That button isn't for this chat. Nothing was done.");
+            return;
+        }
+        const repos = context.projects === null ? null : telegramConversationRepos(store, binding.approver, context.projects);
+        for (const effect of applyFlowConfirm(store, binding, flowConfirm, { text: message.text ?? "" }, repos, clock())) {
+            if (effect.kind === "ack")
+                ack(effect.text);
+            else if (effect.kind === "edit")
+                flowEdit(effect);
+        }
+        return;
+    }
     const flowAction = store.getTelegramFlowAction(token);
     if (flowAction !== null) {
         if (flowAction.binding !== binding.id || flowAction.chatId !== tapChat || (flowAction.messageId !== null && flowAction.messageId !== String(message.message_id))) {
@@ -2184,7 +2208,7 @@ function applyCallback(context, update, effects) {
             if (effect.kind === "ack")
                 ack(effect.text);
             else if (effect.kind === "edit")
-                editText(effect.text);
+                flowEdit(effect);
             else
                 effects.push(async () => {
                     // A reply box: whatever they send back as a reply to this prompt is the new draft, or the note.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.42",
+  "version": "0.9.43",
   "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"