toolroll 0.9.20 → 0.9.22

package/dist/store.js

@@ -310,6 +310,35 @@ CREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);
 `;
 /** Decisions in the chat app (chat-decide.ts; no version bump: additive only). A token names one act on one card (the chat and message it rides); `digest` is
  * what the card showed — a receipt, a revision source, a task stamp, a plan or a commit. */
+/** A flow's "Send to me" and "Person chooses" zones (no version bump: additive only). flow_send keeps what one visit sent its
+ * person (shown on the card, and read again by every chat app that delivers it); telegram_flow_choice is one opaque button
+ * per option for one visit of one card, placed on the message it rides. A reply to that message is the note
+ * (telegram_flow_prompt, mode send-back). The chat apps keep their buttons beside their messages (chat-delivery-state.ts). */
+export const FLOW_SEND_SCHEMA = `
+CREATE TABLE IF NOT EXISTS flow_send (
+  card         INTEGER NOT NULL REFERENCES flow_card(id),
+  entry        INTEGER NOT NULL,
+  stage        TEXT NOT NULL,
+  person       TEXT NOT NULL,
+  content_json TEXT NOT NULL,
+  created_at   TEXT NOT NULL,
+  PRIMARY KEY (card, entry)
+);
+CREATE TABLE IF NOT EXISTS telegram_flow_choice (
+  token       TEXT PRIMARY KEY,
+  binding     INTEGER NOT NULL REFERENCES telegram_binding(id) ON DELETE RESTRICT,
+  card        INTEGER NOT NULL REFERENCES flow_card(id),
+  entry       INTEGER NOT NULL,
+  choice      INTEGER NOT NULL,
+  label       TEXT NOT NULL,
+  chat_id     TEXT NOT NULL,
+  message_id  TEXT,
+  created_at  TEXT NOT NULL,
+  expires_at  TEXT NOT NULL,
+  consumed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS telegram_flow_choice_visit ON telegram_flow_choice (card, entry);
+`;
 export const CHAT_DECIDE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_decide_action (
   token       TEXT PRIMARY KEY,
@@ -821,6 +850,9 @@ const LIFECYCLE_HOLD_WORDS = {
 export const RESULT_SCREENSHOTS = ["off", "first", "all"];
 /** One person's saved screenshots following a result message: its own outbox row, addressed to them (result-shots.ts). */
 export const RESULT_SHOTS_KIND = "result-screenshots";
+/** The screenshots a flow's "Send to me" or "Person chooses" visit sends its person (flow-send.ts): up to four, whatever
+ * their result-screenshots choice, since the flow asked for them. */
+export const FLOW_SHOTS_KIND = "flow-screenshots";
 /** Tasks filed this close together share one chat message. */
 export const QUIET_GROUP_MS = 60_000;
 export function isDigestTime(value) {
@@ -3938,6 +3970,8 @@ function initializeStore(db, file) {
     db.exec(MATE_ASK_SCHEMA);
     // Decisions in the chat app (no version bump: additive only): result, plan and merge buttons, and Request changes.
     db.exec(CHAT_DECIDE_SCHEMA);
+    // A flow's "Send to me" and "Person chooses" zones (no version bump: additive only).
+    db.exec(FLOW_SEND_SCHEMA);
     db.exec(SPEND_SCHEMA);
     // Sign-in pauses: one row per incident of a provider's sign-in no longer working.
     db.exec(PROVIDER_AUTH_SCHEMA);
@@ -18328,6 +18362,56 @@ export class Store {
             return null;
         return { chatId: String(row["chat_id"]), messageId: String(row["message_id"]), binding: Number(row["binding"]), card: Number(row["card"]), entry: Number(row["entry"]), mode: String(row["mode"]) };
     }
+    // ---- "Send to me" and "Person chooses" (flow-send.ts) ------------------------------------------
+    /** What one visit sent: recorded once, the first time (a later pass finds it kept). */
+    recordFlowSend(row, now) {
+        return Number(this.db.prepare("INSERT OR IGNORE INTO flow_send (card, entry, stage, person, content_json, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(row.card, row.entry, row.stage, row.person, row.contentJson, now.toISOString()).changes) === 1;
+    }
+    flowSend(card, entry) {
+        const row = this.db.prepare("SELECT * FROM flow_send WHERE card = ? AND entry = ?").get(card, entry);
+        return row === undefined ? null : { card: Number(row["card"]), entry: Number(row["entry"]), stage: String(row["stage"]), person: String(row["person"]), contentJson: String(row["content_json"]), createdAt: String(row["created_at"]) };
+    }
+    /** Every visit's send for a card, newest first: what the card shows it sent. */
+    flowSends(card) {
+        return this.db.prepare("SELECT * FROM flow_send WHERE card = ? ORDER BY entry DESC").all(card).map(row => ({ card: Number(row["card"]), entry: Number(row["entry"]), stage: String(row["stage"]),
+            person: String(row["person"]), contentJson: String(row["content_json"]), createdAt: String(row["created_at"]) }));
+    }
+    createTelegramFlowChoices(at, choices, now, days = 7) {
+        const stamp = now.toISOString(), expires = new Date(now.getTime() + days * 86_400_000).toISOString();
+        const insert = this.db.prepare("INSERT INTO telegram_flow_choice (token, binding, card, entry, choice, label, chat_id, message_id, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)");
+        for (const one of choices)
+            insert.run(one.token, at.binding, at.card, at.entry, one.choice, one.label, at.chatId, stamp, expires);
+    }
+    getTelegramFlowChoice(token) {
+        if (!/^[0-9a-f]{32}$/.test(token))
+            return null;
+        const row = this.db.prepare("SELECT * FROM telegram_flow_choice WHERE token = ?").get(token);
+        if (row === undefined)
+            return null;
+        return { token: String(row["token"]), binding: Number(row["binding"]), card: Number(row["card"]), entry: Number(row["entry"]), choice: Number(row["choice"]), label: String(row["label"]),
+            chatId: String(row["chat_id"]), messageId: row["message_id"] === null ? null : String(row["message_id"]), expiresAt: String(row["expires_at"]), consumedAt: row["consumed_at"] === null ? null : String(row["consumed_at"]) };
+    }
+    placeTelegramFlowChoices(tokens, messageId) {
+        const place = this.db.prepare("UPDATE telegram_flow_choice SET message_id = ? WHERE token = ?");
+        for (const token of tokens)
+            place.run(messageId, token);
+    }
+    /** Retire every choice button for one visit of a card (and its reply prompt): it was chosen, or the card moved on. */
+    /** A choice was made (or the card moved on): every option button, reply prompt and "Use this as your note?" for that
+     * visit is spent, in Telegram and in every other chat app, whichever place it was made in. */
+    retireFlowChoices(card, entry, now) {
+        const stamp = now.toISOString();
+        this.db.prepare("UPDATE telegram_flow_choice SET consumed_at = ? WHERE card = ? AND entry = ? AND consumed_at IS NULL").run(stamp, card, entry);
+        this.retireTelegramFlowVisit(card, entry, now);
+        // A chat app's flow tables exist only once that app's chat state created them; an install without it has none.
+        const names = ["slack", "discord", "teams"].flatMap(app => ["flow_choice", "flow_note", "flow_prompt", "flow_action"].map(table => `${app}_${table}`));
+        const present = new Set(this.db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${names.map(() => "?").join(", ")})`).all(...names).map(row => String(row["name"])));
+        for (const app of ["slack", "discord", "teams"])
+            for (const table of ["flow_choice", "flow_note", "flow_prompt", "flow_action"])
+                if (present.has(`${app}_${table}`))
+                    this.db.prepare(`UPDATE ${app}_${table} SET consumed = ?${table === "flow_note" ? ", words = NULL" : ""} WHERE card = ? AND entry = ? AND consumed IS NULL`).run(stamp, card, entry);
+    }
     // ---- v93: a teammate's question on Telegram ------------------------------------------
     createTelegramQuestionActions(at, choices, now, days = 7) {
         const stamp = now.toISOString(), expires = new Date(now.getTime() + days * 86_400_000).toISOString();
@@ -21730,6 +21814,10 @@ export class Store {
     recordProjectConcurrency(by, repo, before, after, now) {
         this.recordPolicy(by, repo, "builds at once", String(before), String(after), now);
     }
+    /** Review 827: a project's demo URL changed (`off` when it has none). */
+    recordProjectDemo(by, repo, before, after, now) {
+        this.recordPolicy(by, repo, "demo URL", before ?? "off", after ?? "off", now);
+    }
     /** Forward only, and only under the live generation. A stale poller moves nothing. */
     /** v98: an update Telegram pushed, kept until the bridge applies it; false when it's already kept or applied. */
     queueTelegramUpdate(botId, updateId, payload, now) {
@@ -22335,11 +22423,14 @@ export class Store {
     enqueueResultShots(source, now) {
         if (source.run === null || source.taskRef === null || source.project === null || source.recipient !== null)
             return;
-        const ready = isLifecycleNotification(source) && source.kind === "run-finished";
-        if (!ready && !/fail/.test(source.kind))
-            return;
         const run = this.getRun(source.run);
-        if (run === null || !["builder", "repair"].includes(run.role) || run.contestant !== null)
+        if (run === null || run.contestant !== null)
+            return;
+        // One path per role (review 826): a scout's report is its result, so only its "report ready" carries the
+        // screenshots it saved; a build's are carried by its finished or failed message.
+        const carries = run.role === "scout" ? source.kind === "report-ready"
+            : ["builder", "repair"].includes(run.role) && ((isLifecycleNotification(source) && source.kind === "run-finished") || /fail/.test(source.kind));
+        if (!carries)
             return;
         if (!this.artifactsFor(run.id).some(one => one.kind === "screenshot"))
             return;

package/dist/teams-chat.js

@@ -207,7 +207,7 @@ export async function deliverTeamsPart(options) {
         }
         else if (!content.image) {
             // A flow decision (v88): Approve / Edit / Send back, then the link.
-            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" } : {}) })) : [];
+            const flow = content.flow || content.choose || content.note ? 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 } })) : [];
             // The lead's question to its owner: its options, then "Something else".

package/dist/telegram-flow.d.ts

@@ -1,6 +1,7 @@
+import { type FlowChoiceVisit, type FlowSendContent } from "./flow-send.js";
 import { type FlowStage } from "./flows.js";
-import type { InlineButton } from "./telegram-mate.js";
-import type { FlowCardRow, FlowRow, Store, TelegramBinding, TelegramFlowAction, TelegramFlowPrompt } from "./store.js";
+import { type InlineButton } from "./telegram-mate.js";
+import type { FlowCardRow, FlowRow, Store, TelegramBinding, TelegramFlowAction, TelegramFlowChoice, TelegramFlowPrompt } from "./store.js";
 export declare const FLOW_DECIDE_KEY: RegExp;
 type Waiting = {
     card: FlowCardRow;
@@ -15,6 +16,19 @@ export declare function flowButtons(store: Store, binding: TelegramBinding, wait
     keyboard: InlineButton[][];
     tokens: string[];
 };
+/** What a "Send to me" or "Person chooses" visit sent, read back for its message. */
+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'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[][];
+    tokens: string[];
+};
+/** A tapped option, applied inside the update's transaction. */
+export declare function applyFlowChoiceTap(store: Store, binding: TelegramBinding, choice: TelegramFlowChoice, message: {
+    text: string;
+}, repos: readonly string[] | null, now: Date): FlowTapEffect[];
 export type FlowTapEffect = {
     kind: "ack";
     text: string;

package/dist/telegram-flow.js

@@ -14,11 +14,17 @@
  * Every button is one opaque token for one visit of one card, placed on the
  * message it rides. A card that moved on answers so; a tap from anyone but
  * the paired person and chat never reaches here (telegram.ts checks it).
+ *
+ * A "Person chooses" visit (flow-send.ts) has one button per option the flow
+ * names; a reply to that message instead of a tap is the note for where
+ * replies go. Both go through chooseFlowCard, for exactly that visit.
  */
 import { randomBytes } from "node:crypto";
 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 { phoneLinkButton } from "./telegram-mate.js";
 export const FLOW_DECIDE_KEY = /^flow-decide:([1-9][0-9]{0,14}):([1-9][0-9]{0,9})$/;
 const DRAFT_LIMIT = 4000;
 /** The card, if it is still at that visit, waiting at a decision. */
@@ -45,6 +51,43 @@ export function flowButtons(store, binding, waiting, now) {
         .filter((one) => one !== null);
     return { keyboard: [[{ text: "✅ Approve", callback_data: approve.token }], ...(second.length === 0 ? [] : [second])], tokens: all.map(one => one.token) };
 }
+/** What a "Send to me" or "Person chooses" visit sent, read back for its message. */
+export function flowSentContent(store, card, entry) {
+    const kept = store.flowSend(card, entry);
+    return kept === null ? null : readFlowSend(kept.contentJson);
+}
+/** A sent visit's links as one row of buttons: Toolroll's pages under the trusted origin, and its pull request. */
+export function flowSendKeyboardRow(origin, content) {
+    const pages = origin === null ? [] : flowSendPaths(content).flatMap(one => phoneLinkButton(origin, one) ?? []);
+    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'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.
+    const options = (content.options ?? []).filter(one => visit.stage.options?.[one.choice]?.label === one.label).map(one => ({ ...one, token: randomBytes(16).toString("hex") }));
+    store.createTelegramFlowChoices({ binding: binding.id, chatId: binding.chatId, card: visit.card.id, entry: visit.card.entry }, options, now);
+    return { keyboard: options.map(one => [{ text: one.label, callback_data: one.token }]), tokens: options.map(one => one.token) };
+}
+/** A tapped option, applied inside the update's transaction. */
+export function applyFlowChoiceTap(store, binding, choice, message, repos, now) {
+    if (choice.consumedAt !== null || choice.expiresAt <= now.toISOString())
+        return [{ kind: "ack", text: "That was already chosen, or these buttons are too old." }];
+    const visit = flowChoiceAt(store, choice.card, choice.entry);
+    if (visit === null) {
+        store.retireFlowChoices(choice.card, choice.entry, now);
+        return [{ kind: "ack", text: "That card has moved on since; nothing was changed." }, { kind: "edit", text: `${message.text}\n\nThis card has moved on since; nothing was changed.`.slice(0, 4000) }];
+    }
+    if (visit.person !== binding.approver)
+        return [{ kind: "ack", text: `Only ${visit.person} chooses here.` }];
+    if (repos === null)
+        return [{ kind: "ack", text: "Couldn't check your projects just now. Try again in a moment." }];
+    const chosen = chooseFlowCard(store, { card: choice.card, entry: choice.entry, choice: choice.choice, label: choice.label, note: null, actor: binding.approver, where: "Telegram", 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) }];
+}
 /** 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())
@@ -78,6 +121,21 @@ const titleOf = (waiting, id) => flowDefinitionOf(waiting.flow)?.stages.find(one
 export function applyFlowReply(store, binding, prompt, text, repos, now) {
     if (prompt.binding !== binding.id)
         return [];
+    // A reply to a choice's message (flow-send.ts): the note for where replies go.
+    const choosing = flowChoiceAt(store, prompt.card, prompt.entry);
+    if (choosing !== null) {
+        if (choosing.person !== binding.approver)
+            return [{ kind: "say", text: `Only ${choosing.person} chooses here.` }];
+        if (text.trim() === "")
+            return [{ kind: "say", text: "Say what you'd change." }];
+        if (repos === null)
+            return [{ kind: "say", text: "Couldn't check your projects just now. Reply again in a moment." }];
+        const chosen = chooseFlowCard(store, { card: prompt.card, entry: prompt.entry, choice: null, note: text.trim(), actor: binding.approver, where: "Telegram", repos }, now);
+        if (!chosen.ok)
+            return [{ kind: "say", text: chosen.message }];
+        store.retireFlowChoices(prompt.card, prompt.entry, now);
+        return [{ kind: "say", text: `↩️ ${chosen.said}` }];
+    }
     const waiting = flowDecisionAt(store, prompt.card, prompt.entry);
     if (waiting === null) {
         store.retireTelegramFlowVisit(prompt.card, prompt.entry, now);

package/dist/telegram.js

@@ -27,14 +27,15 @@ import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import { chmodSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { validateNote } from "./decision.js";
-import { resultShotsFor } from "./result-shots.js";
+import { isShotsKind, resultShotsFor } from "./result-shots.js";
 import { isLifecycleNotification, isTelegramProgressNotification, RESULT_SHOTS_KIND, TELEGRAM_HOLD_REASONS } from "./store.js";
 import { telegramProgressCard } from "./telegram-progress.js";
 import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
 import { BATCH_MS, chatText, chatTitle, factLinkLabel, mentions, nameTelegramBot } from "./chat-voice.js";
 import { LEAD_SAY_KIND, enqueueLeadLapses, leadSayEarlier, leadSayText, leadSubjectOf } from "./lead-voice.js";
 import { applyTeamInbound, deliverTeamChats, teamCommand } from "./telegram-team.js";
-import { applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowDecisionAt } from "./telegram-flow.js";
+import { applyFlowChoiceTap, applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowChoiceButtons, flowDecisionAt, flowSendKeyboardRow, flowSentContent } from "./telegram-flow.js";
+import { flowChoiceAt, FLOW_CHOOSE_KEY, FLOW_SEND_KEY } from "./flow-send.js";
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
 import { focusContextFor, taskInCeiling } from "./chat-channel.js";
 import { answersPrompt, applyDecideFeedback, applyDecideTap, decideFallbackLink, dropDecideTokens, hasLiveDecideTokens, linksFor, placeDecidePrompt, decideOffer, decideTargetOf, isDecideToken, mergedText, mintDecideButtons, offerFingerprint, openPromptFor, placeDecideTokens, recordChatMerge, retireDecideTokens } from "./chat-decide.js";
@@ -658,7 +659,7 @@ async function deliverOutbox(store, botId, transport, owner, clock, report, read
         // Routine progress facts are not a problem to fix: a first pairing
         // starts from now and settles them as history. Anything else pending
         // is named, once per pass, as before.
-        if (store.listNotifications("pending").some(row => !isLifecycleNotification(row) && row.kind !== RESULT_SHOTS_KIND))
+        if (store.listNotifications("pending").some(row => !isLifecycleNotification(row) && !isShotsKind(row.kind)))
             report.problems.push("outbox rows are pending but no chat is paired — `toolroll bridge telegram pair`");
         return;
     }
@@ -1058,7 +1059,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             return sent.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, sent.messageId) } : sent;
         };
         let outcome;
-        if (rows.length === 1 && row.kind === RESULT_SHOTS_KIND)
+        if (rows.length === 1 && isShotsKind(row.kind))
             outcome = await shotsSender(row);
         else if (rows.length === 1 && row.kind === LEAD_SAY_KIND)
             outcome = await leadSayOutcome(row);
@@ -1107,7 +1108,7 @@ function isUrgent(notification) {
 /** A routine fact the digest may carry. Screenshots are never urgent (they follow their result message, which the
  * task's order fence holds them behind) and never a digest line: they go as their own photos once it has gone. */
 function joinsDigest(notification) {
-    return !isUrgent(notification) && notification.kind !== RESULT_SHOTS_KIND;
+    return !isUrgent(notification) && !isShotsKind(notification.kind);
 }
 /** 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.
@@ -1193,7 +1194,7 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         const decided = offer === null ? null : mintDecideButtons(store, decideSeat(binding), target, offer, clock());
         const parts = split(offer?.text ?? `${notificationIdentity(notification, title !== undefined && mentions(words, title) ? undefined : title)}${words}`);
         const fallback = offer === null ? decideFallbackLink(target) : null;
-        const button = fallback !== null ? (() => { try {
+        let button = fallback !== null ? (() => { try {
             return phoneLinkButton(phoneOrigin?.() ?? null, fallback);
         }
         catch {
@@ -1204,10 +1205,23 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         const visit = FLOW_DECIDE_KEY.exec(notification.dedupeKey);
         const waiting = visit === null ? null : flowDecisionAt(store, Number(visit[1]), Number(visit[2]));
         const flowKeys = waiting === null ? null : flowButtons(store, binding, waiting, clock());
+        // A flow's "Send to me" or "Person chooses" (flow-send.ts): its links as buttons, and a choice's options above them.
+        const sentVisit = FLOW_SEND_KEY.exec(notification.dedupeKey) ?? FLOW_CHOOSE_KEY.exec(notification.dedupeKey);
+        const sent = sentVisit === null ? null : flowSentContent(store, Number(sentVisit[1]), Number(sentVisit[2]));
+        const choosing = sent === null || !FLOW_CHOOSE_KEY.test(notification.dedupeKey) || notification.recipient !== binding.approver ? null : flowChoiceAt(store, Number(sentVisit[1]), Number(sentVisit[2]));
+        const choiceKeys = choosing === null || sent === null ? null : flowChoiceButtons(store, binding, choosing, sent, clock());
+        const sentRow = sent === null ? null : (() => { try {
+            return flowSendKeyboardRow(phoneOrigin?.() ?? null, sent);
+        }
+        catch {
+            return [];
+        } })();
+        if (sentRow !== null)
+            button = sentRow.length === 0 ? null : sentRow;
         // A teammate's question (v93): its options and "Answer in words", for the person it asks.
-        const asked = flowKeys === null ? openQuestionOf(store, notification.dedupeKey) : null;
+        const asked = flowKeys === null && choiceKeys === null ? openQuestionOf(store, notification.dedupeKey) : null;
         const questionKeys = asked === null ? null : telegramQuestionButtons(store, binding, asked, clock());
-        const keys = flowKeys ?? questionKeys;
+        const keys = flowKeys ?? choiceKeys ?? questionKeys;
         let last = null;
         for (const [index, part] of parts.entries()) {
             const final = index === parts.length - 1;
@@ -1223,6 +1237,12 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         }
         if (flowKeys !== null && last !== null)
             store.placeTelegramFlowActions(flowKeys.tokens, last);
+        if (choiceKeys !== null && last !== null) {
+            store.placeTelegramFlowChoices(choiceKeys.tokens, last);
+            // A reply to this message, instead of a tap, is the person's note (applyFlowReply).
+            if (sent?.reply === true)
+                store.recordTelegramFlowPrompt({ chatId: binding.chatId, messageId: last, binding: binding.id, card: choosing.card.id, entry: choosing.card.entry, mode: "send-back" }, clock(), 7 * 24);
+        }
         if (questionKeys !== null && last !== null)
             store.placeTelegramQuestionActions(questionKeys.tokens, last);
         if (decided !== null && last !== null)
@@ -1472,7 +1492,7 @@ 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;
+    const flowTap = callback !== undefined && (context.store.getTelegramFlowAction(callback.data ?? "") !== null || context.store.getTelegramFlowChoice(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))
@@ -1481,7 +1501,7 @@ async function projectsForTap(context, update) {
     if (binding === null || callback.from === undefined ||
         callback.message?.chat === undefined ||
         // Proposal cards and task picks read the chat's project ceiling.
-        (context.store.getTelegramProposalAction(callback.data ?? "") === null && context.store.getTelegramFlowAction(callback.data ?? "") === null && !decideTap && !(callback.data ?? "").startsWith("pick:")))
+        (context.store.getTelegramProposalAction(callback.data ?? "") === null && !flowTap && !decideTap && !(callback.data ?? "").startsWith("pick:")))
         return null;
     const chat = callback.message.chat;
     const chatId = String(chat.id);
@@ -2138,6 +2158,22 @@ function applyCallback(context, update, effects) {
         }
         return;
     }
+    // A "Person chooses" option (flow-send.ts): the card goes where it leads, or is ignored.
+    const choiceAction = store.getTelegramFlowChoice(token);
+    if (choiceAction !== null) {
+        if (choiceAction.binding !== binding.id || choiceAction.chatId !== tapChat || (choiceAction.messageId !== null && choiceAction.messageId !== String(message.message_id))) {
+            report.ignored++;
+            return;
+        }
+        const repos = context.projects === null ? null : telegramConversationRepos(store, binding.approver, context.projects);
+        for (const effect of applyFlowChoiceTap(store, binding, choiceAction, { text: message.text ?? "" }, repos, clock())) {
+            if (effect.kind === "ack")
+                ack(effect.text);
+            else if (effect.kind === "edit")
+                editText(effect.text);
+        }
+        return;
+    }
     // The lead's question to its owner: an option is sent as their next message; "Something else" asks them to type it.
     const askTap = /^ask:([1-9][0-9]{0,14}):([0-3]|x)$/.exec(token);
     if (askTap !== null) {

package/package.json

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