toolroll 0.9.19 → 0.9.21

package/dist/browser-workspace.d.ts

@@ -725,7 +725,7 @@ export type BrowserRunChecks = {
 export type BrowserFlowStage = {
     id: string;
     title: string;
-    kind: "inbox" | "task" | "report" | "approval" | "check" | "pull-request" | "update" | "notify" | "sort" | "draft" | "request" | "email" | "tool" | "wait" | "teammate" | "done";
+    kind: "inbox" | "task" | "report" | "approval" | "check" | "pull-request" | "update" | "notify" | "sort" | "draft" | "request" | "email" | "tool" | "wait" | "teammate" | "send" | "choose" | "done";
     zone: {
         x: number;
         y: number;
@@ -799,6 +799,13 @@ export type BrowserFlowStage = {
     teammate?: string | undefined;
     /** v96: a teammate zone sends what the teammate writes back to whoever asked. */
     reply?: boolean | undefined;
+    /** A "Person chooses" zone's buttons: each one's words and the zone it leads to ("end" ignores the card). */
+    options?: {
+        label: string;
+        to: string;
+    }[] | undefined;
+    /** A Build zone in another project: its path. */
+    repo?: string | undefined;
     next: string | null;
     onFail: string | null;
 };
@@ -884,6 +891,34 @@ export type BrowserFlowCard = {
         from: string;
         note: string;
     } | null;
+    /** Waiting at a "Person chooses" zone: what was sent, its options and whether the viewer is the one who chooses. */
+    choose?: {
+        entry: number;
+        title: string;
+        summary: string;
+        links: {
+            label: string;
+            href: string;
+        }[];
+        person: string;
+        mine: boolean;
+        options: {
+            choice: number;
+            label: string;
+        }[];
+        reply: boolean;
+    } | null;
+    /** What a "Send to me" (or an earlier choice) last sent the card's person. */
+    sent?: {
+        title: string;
+        summary: string;
+        links: {
+            label: string;
+            href: string;
+        }[];
+        person: string;
+        at: string;
+    } | null;
     /** v94: every tool call teammates made or asked to make on this card, oldest first: the receipts. */
     calls?: {
         id: number;
@@ -912,6 +947,8 @@ export type BrowserFlowTrigger = {
     status: string | null;
     statusAt: string | null;
     failing: boolean;
+    /** Where the status points a person (a plane review's long waits: Needs you). */
+    statusLink: BrowserLink | null;
     button: {
         label: string;
         questions: string[];
@@ -1013,6 +1050,11 @@ export type BrowserFlowView = {
     live: string | null;
     canEdit: boolean;
     approvers: string[];
+    /** The projects a Build zone may work in: the flow's own first, then others the viewer can reach. */
+    projects?: {
+        path: string;
+        name: string;
+    }[];
     kinds: {
         kind: BrowserFlowStage["kind"];
         label: string;

package/dist/chat-actions.d.ts

@@ -91,6 +91,11 @@ export declare const CHAT_ACTIONS: {
         readonly protected: false;
         readonly password: false;
     };
+    readonly flow_card_choose: {
+        readonly label: "Choose";
+        readonly protected: false;
+        readonly password: false;
+    };
     readonly flow_card_cancel: {
         readonly label: "Cancel card";
         readonly protected: false;

package/dist/chat-actions.js

@@ -16,9 +16,10 @@ import { acceptAndCompleteAsOperator, assignmentOf } from "./assignment.js";
 import { getDecision, recordDecision, retireDecision } from "./project-memory.js";
 import { resumeTaskStop, taskControlOf } from "./task-control.js";
 import { addToolTo, catalogTool, projectToolsOf, removeToolFrom, toolCommandLine, validateToolSpec } from "./project-tools.js";
-import { deciderOf, FLOW_KIND_WORDS, flowDigest, flowTerms, validateFlowDefinition } from "./flows.js";
+import { deciderOf, FLOW_KIND_WORDS, flowDigest, flowTerms, replyTarget, validateFlowDefinition } from "./flows.js";
 import { saveScript, scriptDigest, validateScript } from "./flow-scripts.js";
-import { addCardToFlow, advanceFlows, cancelFlowCard, decideFlowCard, flowCardHref, flowCardText, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
+import { addCardToFlow, advanceFlows, cancelFlowCard, crossProjectProblem, decideFlowCard, flowCardHref, flowCardText, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
+import { chooseFlowCard, flowPersonOf } from "./flow-send.js";
 import { assignFlowCard, commentOnFlowCard, flowPeople, mentionsIn, watchFlowCard } from "./flow-people.js";
 import { addFlowTriggerTo, describeTrigger, readLinearKey, removeFlowTrigger, scheduleFromWords, takesDeliveries, triggerConfigOf, validateTriggerConfig } from "./flow-triggers.js";
 import { describeSchedule, parseSchedule } from "./routine.js";
@@ -87,6 +88,7 @@ export const CHAT_ACTIONS = {
     flow_card_move: { label: "Move card", protected: false, password: false },
     flow_card_approve: { label: "Approve", protected: false, password: false },
     flow_card_send_back: { label: "Send back", protected: false, password: false },
+    flow_card_choose: { label: "Choose", protected: false, password: false },
     flow_card_cancel: { label: "Cancel card", protected: false, password: false },
     flow_card_comment: { label: "Comment", protected: false, password: false },
     flow_card_assign: { label: "Set owner", protected: false, password: false },
@@ -144,6 +146,7 @@ export const CHAT_ACTION_FIELDS = {
     flow_card_move: ["card", "zone"],
     flow_card_approve: ["card", "note"],
     flow_card_send_back: ["card", "note"],
+    flow_card_choose: ["card", "choice", "note"],
     flow_card_cancel: ["card"],
     flow_card_comment: ["card", "note"],
     flow_card_assign: ["card", "owner"],
@@ -580,6 +583,9 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
         if (operation === "flow_create") {
             const name = text(input, "name", 80).trim();
             const definition = flowDrawingOf(store, input, repo);
+            const elsewhere = crossProjectProblem(store, definition, { repo, owner: who.name });
+            if (elsewhere !== null)
+                throw Error(elsewhere);
             request["name"] = name;
             request["definition"] = definition;
             state = {};
@@ -613,6 +619,9 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
             const name = input["name"] === undefined ? flow.name : text(input, "name", 80).trim();
             const definition = input["definition"] === undefined ? before : flowDrawingOf(store, input, repo);
             const redrawn = flowDigest(definition) !== flowDigest(before);
+            const elsewhere = crossProjectProblem(store, definition, flow, who.name);
+            if (elsewhere !== null)
+                throw Error(elsewhere);
             if (!redrawn && name === flow.name)
                 throw Error("That's the flow as it is now.");
             Object.assign(request, { name, definition });
@@ -728,6 +737,38 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
                 title = `Take ${quoted(card.title)} out of the flow`;
                 terms.push("The card leaves the flow. Any tasks it filed stay as they are.");
             }
+            else if (operation === "flow_card_choose") {
+                // "Person chooses" (flow-send.ts): one of the zone's own options, or a reply that becomes the note.
+                if (at?.kind !== "choose")
+                    throw Error("That card isn't waiting for a choice.");
+                const person = flowPersonOf(card, flowTarget.flow);
+                if (person !== who.name)
+                    throw Error(`Only ${person} chooses here.`);
+                const titleOf = (id) => definition.stages.find(one => one.id === id)?.title ?? id;
+                if (input["choice"] !== undefined && input["choice"] !== null) {
+                    const index = Number(input["choice"]) - 1;
+                    const option = Number.isSafeInteger(input["choice"]) ? (at.options ?? [])[index] : undefined;
+                    if (option === undefined)
+                        throw Error(`Choose one of its ${(at.options ?? []).length} options, by number.`);
+                    delete request["note"];
+                    // Bound to the option as shown: if the flow's options change before it is confirmed, it is refused.
+                    Object.assign(state, { label: option.label, to: option.to });
+                    title = `Choose “${option.label}” for ${quoted(card.title)}`;
+                    terms.push(option.to === "end" ? `${at.title}: “${option.label}”. The card is closed as Ignored.` : `${at.title}: “${option.label}”. It moves to ${titleOf(option.to)}.`);
+                }
+                else {
+                    const note = input["note"] === undefined ? "" : text(input, "note", 2000).trim();
+                    const target = replyTarget(at);
+                    if (target === null)
+                        throw Error("This step takes one of its options, not a reply.");
+                    if (note === "")
+                        throw Error("Say what you'd change, or choose an option by number.");
+                    request["note"] = note;
+                    state["to"] = target;
+                    title = `Reply on ${quoted(card.title)}`;
+                    terms.push(`${at.title}: your reply goes to ${titleOf(target)} as its note:\n${note}`);
+                }
+            }
             else {
                 if (at?.kind !== "approval")
                     throw Error("That card isn't waiting for a decision.");
@@ -1342,10 +1383,20 @@ function runFlowAction(store, payload, actor, repos, root, now) {
     }
     const acted = payload.operation === "flow_card_move" ? moveCardInFlow(store, card, String(req["zone"]), actor, now)
         : payload.operation === "flow_card_cancel" ? cancelFlowCard(store, card, actor, now)
-            : (() => {
-                const decided = decideFlowCard(store, { card: card.id, decision: payload.operation === "flow_card_approve" ? "approve" : "send-back", note: typeof req["note"] === "string" ? req["note"] : null, actor, repos, ...(root === undefined ? {} : { evidenceRoot: root }) }, now);
-                return decided.ok ? { ok: true, said: decided.said, card: card.id } : { ok: false, message: decided.message };
-            })();
+            : payload.operation === "flow_card_choose" ? (() => {
+                // The option (its words and where it leads) or reply target exactly as proposed; a proposal from before carries neither and is refused.
+                const bound = payload.state;
+                if (typeof bound["to"] !== "string" || (Number.isSafeInteger(req["choice"]) && typeof bound["label"] !== "string"))
+                    return { ok: false, message: "Those options changed since; nothing was changed. Ask for a fresh proposal." };
+                const chosen = chooseFlowCard(store, { card: card.id, entry: Number(bound["entry"]), choice: Number.isSafeInteger(req["choice"]) ? Number(req["choice"]) - 1 : null,
+                    ...(typeof bound["label"] === "string" ? { label: bound["label"] } : {}), to: bound["to"],
+                    note: typeof req["note"] === "string" ? req["note"] : null, actor, where: "chat", repos, ...(root === undefined ? {} : { evidenceRoot: root }) }, now);
+                return chosen.ok ? { ok: true, said: chosen.said, card: card.id } : { ok: false, message: chosen.message };
+            })()
+                : (() => {
+                    const decided = decideFlowCard(store, { card: card.id, decision: payload.operation === "flow_card_approve" ? "approve" : "send-back", note: typeof req["note"] === "string" ? req["note"] : null, actor, repos, ...(root === undefined ? {} : { evidenceRoot: root }) }, now);
+                    return decided.ok ? { ok: true, said: decided.said, card: card.id } : { ok: false, message: decided.message };
+                })();
     if (!acted.ok)
         throw Error(acted.message);
     return settle(card.flow, acted.said, card.id);

package/dist/chat-delivery-state.d.ts

@@ -92,6 +92,21 @@ export type ChatContent = {
         entry: number;
         actions: Array<"approve" | "edit" | "send-back">;
     };
+    /** A flow's "Person chooses" buttons ride this part: minted when it is planned. */
+    choose?: {
+        card: number;
+        entry: number;
+        options: Array<{
+            choice: number;
+            label: string;
+        }>;
+    };
+    /** "Use this as your note?" Yes / No about the person's message `held` (an event id), for one choice's visit. */
+    note?: {
+        card: number;
+        entry: number;
+        held: string;
+    };
     /** A teammate's question's buttons ride this part (v93): each option, then one to answer in words (choice null). */
     question?: {
         id: number;

package/dist/chat-delivery-state.js

@@ -78,6 +78,25 @@ CREATE TABLE IF NOT EXISTS chat_flow_prompt (
 );
 CREATE INDEX IF NOT EXISTS chat_flow_prompt_open ON chat_flow_prompt(binding, consumed);
 `;
+/** A flow's "Person chooses" zone in the chat app (flow-send.ts): one button per option (choice is its index, label its words
+ * when sent) for one visit of one card, on the part it rides. A reply in that notice's thread is the note; chat_flow_note
+ * is "Use this as your note?" Yes / No about one other message (held: its event; words: what it said, kept only until
+ * answered, as an event's own payload is cleared once it is handled), asked once per visit.
+ * Never in CHAT_TABLES: an older database has no such table until this schema creates it. */
+const CHAT_FLOW_CHOICE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS chat_flow_choice (
+ token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
+ card INTEGER NOT NULL REFERENCES flow_card(id), entry INTEGER NOT NULL,
+ choice INTEGER NOT NULL, label TEXT NOT NULL, expires TEXT NOT NULL, consumed TEXT
+);
+CREATE INDEX IF NOT EXISTS chat_flow_choice_visit ON chat_flow_choice(card, entry);
+CREATE TABLE IF NOT EXISTS chat_flow_note (
+ token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
+ card INTEGER NOT NULL REFERENCES flow_card(id), entry INTEGER NOT NULL,
+ held TEXT NOT NULL, words TEXT, answer TEXT NOT NULL CHECK(answer IN ('yes','no')), expires TEXT NOT NULL, consumed TEXT
+);
+CREATE INDEX IF NOT EXISTS chat_flow_note_visit ON chat_flow_note(card, entry);
+`;
 /** v93: a teammate's question in the chat app. One button per option (choice)
  * and one to answer in words (choice NULL); that one opens a prompt the
  * person's next message in their DM answers. Never in CHAT_TABLES: an older
@@ -121,7 +140,7 @@ export class ChatState {
         this.channel = channel;
     }
     prepare(sql) {
-        return this.db.prepare(sql.replace(/\bchat_(binding|pair|event|part|action|progress|runtime|room|meta|flow_action|flow_prompt|question_action|question_prompt|ask_action)\b/g, `${this.channel}_$1`));
+        return this.db.prepare(sql.replace(/\bchat_(binding|pair|event|part|action|progress|runtime|room|meta|flow_action|flow_prompt|flow_choice|flow_note|question_action|question_prompt|ask_action)\b/g, `${this.channel}_$1`));
     }
     /** Small transport facts a channel must remember per chat (a Teams service URL). Never credentials. */
     meta(installation, key) {
@@ -286,6 +305,12 @@ export class ChatState {
                 if (Number(inserted.changes) && part.ask)
                     for (const choice of [...part.ask.options.map((_, index) => index), null])
                         this.prepare("INSERT INTO chat_ask_action(token,part,turn,choice,expires) VALUES(?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.ask.turn, choice, new Date(now.getTime() + MATE_ASK_TTL_MS).toISOString());
+                if (Number(inserted.changes) && part.choose)
+                    for (const one of part.choose.options)
+                        this.prepare("INSERT INTO chat_flow_choice(token,part,card,entry,choice,label,expires) VALUES(?,?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.choose.card, part.choose.entry, one.choice, one.label, new Date(now.getTime() + 7 * 86_400_000).toISOString());
+                if (Number(inserted.changes) && part.note)
+                    for (const answer of ["yes", "no"])
+                        this.prepare("INSERT INTO chat_flow_note(token,part,card,entry,held,answer,expires) VALUES(?,?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.note.card, part.note.entry, part.note.held, answer, new Date(now.getTime() + 86_400_000).toISOString());
                 if (Number(inserted.changes) && part.flow)
                     for (const action of part.flow.actions)
                         this.prepare("INSERT INTO chat_flow_action(token,part,card,entry,action,expires) VALUES(?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.flow.card, part.flow.entry, action, new Date(now.getTime() + 7 * 86_400_000).toISOString());
@@ -307,7 +332,7 @@ export class ChatState {
         return !!this.prepare("SELECT 1 FROM chat_runtime WHERE installation=? AND owner=? AND lease_until>?").get(installation, owner, now.toISOString());
     }
 }
-export const chatSchema = (channel) => (CHAT_SCHEMA + CHAT_ROOM_SCHEMA + CHAT_FLOW_SCHEMA + CHAT_QUESTION_SCHEMA + CHAT_ASK_SCHEMA).replaceAll("chat_", `${channel}_`);
+export const chatSchema = (channel) => (CHAT_SCHEMA + CHAT_ROOM_SCHEMA + CHAT_FLOW_SCHEMA + CHAT_FLOW_CHOICE_SCHEMA + CHAT_QUESTION_SCHEMA + CHAT_ASK_SCHEMA).replaceAll("chat_", `${channel}_`);
 export const chatTables = (channel) => CHAT_TABLES.map((name) => name.replace("chat_", `${channel}_`));
 export class ChatDeliveryError extends Error {
     code;

package/dist/chat-delivery.js

@@ -8,7 +8,7 @@ import { warmTurn } from "./chat-warmth.js";
 import { confirmMateProposal, dismissMateProposal, } from "./mate-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
 import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.js";
-import { answerChatFlowPrompt, applyChatFlowTap, flowDecisionParts } from "./chat-flow.js";
+import { answerChatFlowPrompt, answerChoiceMessage, applyChatFlowTap, flowDecisionParts, flowSendParts } from "./chat-flow.js";
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
 import { triggerConfigOf } from "./flow-triggers.js";
 import { telegramProgressCard } from "./telegram-progress.js";
@@ -19,8 +19,8 @@ import { leadChannelOf } from "./lead-context.js";
 import { promiseChannelOf } from "./lead-commitments.js";
 import { phoneText, PHONE_HELP, phoneCommand, phoneStatus, phoneTaskView, phoneTaskChoices, phoneTaskListText, resolvePhoneTask, phoneFocusText, PHONE_NO_MATCH, PHONE_BACK_TO_LEAD } from "./telegram-status.js";
 import { applyRoomInbound, conversationRow, roomCardApprover, roomCommand, roomGrantAllowed, roomMessagesAfter, roomMessageText, teamDomain } from "./chat-rooms.js";
-import { isTelegramProgressNotification, proposalTaskOf, RESULT_SHOTS_KIND } from "./store.js";
-import { resultShotsFor } from "./result-shots.js";
+import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
+import { isShotsKind, resultShotsFor } from "./result-shots.js";
 import { messageTeammate } from "./teammate-desk.js";
 import { CHAT_APP_NAMES } from "./flow-triggers.js";
 export const chatObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v)
@@ -124,6 +124,9 @@ export async function processChatEvent(options) {
         // A flow decision asked for this person's next message (Edit, Send back): it is the draft or the note.
         if (answerChatFlowPrompt({ store, state, label: options.label }, event, binding, { text, ...(typeof input.originalLength === "number" ? { originalLength: input.originalLength } : {}) }, repos, nowOf(options)))
             return true;
+        // A "Person chooses" notice's thread reply is the note; the first other message after it is asked about (chat-flow.ts).
+        if (answerChoiceMessage({ store, state, label: options.label }, event, binding, { text, ...(typeof input.originalLength === "number" ? { originalLength: input.originalLength } : {}), lead: input.lead === true }, nowOf(options), repos))
+            return true;
         // A message to a teammate by name (v96), in someone's own chat with Toolroll: a card on its desk.
         if (event.channel === binding.channel) {
             const handed = messageTeammate(store, { who: binding.approver, repos, via: CHAT_APP_NAMES[state.channel] ?? "Chat" }, text, nowOf(options));
@@ -680,6 +683,17 @@ function planResultShots(options, binding, notification, repos, id, now) {
     // The result's message here: its finished-work batch (quiet), its progress card (every step), or the result's own
     // notice. The transport threads the screenshots under it once it is posted, and holds them until then.
     const follows = (() => {
+        // A flow's screenshots follow the "Send to me" or "Person chooses" notice they go with.
+        const visit = /^flow-shots:([1-9][0-9]*):([1-9][0-9]*)$/.exec(notification.dedupeKey);
+        if (visit !== null) {
+            for (const key of [`flow-send:${visit[1]}:${visit[2]}`, `flow-choose:${visit[1]}:${visit[2]}`]) {
+                const notice = store.handle.prepare("SELECT id FROM notification WHERE dedupe_key=?").get(key);
+                const part = notice === undefined ? undefined : state.prepare("SELECT id FROM chat_part WHERE event=? ORDER BY id DESC LIMIT 1").get(chatHash(`${state.channel}:notice:${binding.id}:${Number(notice["id"])}`));
+                if (part !== undefined)
+                    return Number(part.id);
+            }
+            return null;
+        }
         const batch = notification.taskRef === null ? null : store.chatBatchMessageFor(`${state.channel}:${binding.id}`, notification.taskRef, notification.run);
         if (batch !== null)
             return Number(batch);
@@ -745,7 +759,7 @@ export async function planChatNotifications(options) {
                     // Only when I'm needed (the default): the task's one card is edited in place, and a new message
                     // follows only when this person is needed. Every step keeps the branches below unchanged.
                     const quiet = !personal && isTaskFact(notification) && store.notificationPreference(binding.approver).mode === "quiet";
-                    if (notification.kind === RESULT_SHOTS_KIND) {
+                    if (isShotsKind(notification.kind)) {
                         planResultShots(options, binding, notification, repos, id, now);
                         return;
                     }
@@ -833,6 +847,12 @@ export async function planChatNotifications(options) {
                             state.plan(id, parts, now);
                         }
                     }
+                    else if (personal && flowSendParts(store, notification) !== null) {
+                        // A flow's "Send to me" (flow-send.ts): what was done, with its links as buttons.
+                        state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+                            ts: "", thread: "", payload: "{}", created: now.toISOString() });
+                        state.plan(id, flowSendParts(store, notification), now);
+                    }
                     else if (notification.kind === "flow-card" && questionParts(store, notification, binding) !== null) {
                         // A teammate's question (v93): its options and "Answer in words" on the notice, for the person it asks.
                         state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,

package/dist/chat-flow.d.ts

@@ -1,9 +1,15 @@
-import type { ChatBinding, ChatContent, ChatEvent, ChatState } from "./chat-delivery-state.js";
+import { type ChatBinding, type ChatContent, type ChatEvent, type ChatState } from "./chat-delivery-state.js";
 import type { Store } from "./store.js";
 export type ChatFlowAction = "approve" | "edit" | "send-back";
 export declare const CHAT_FLOW_LABELS: Record<ChatFlowAction, string>;
 /** Words kept as written, line breaks and all; only control characters go. */
 export declare function chatFlowText(text: string): string;
+/** A "Send to me" notice as chat parts: what was done, then its links; null when it isn't one. */
+export declare function flowSendParts(store: Store, notification: {
+    dedupeKey: string;
+    subject: string;
+    body: string;
+}): ChatContent[] | null;
 /**
  * A "flow-decision" notice as chat parts, or null when it isn't one (or the
  * card has already moved on, and there is nothing left to decide).
@@ -14,11 +20,13 @@ export declare function flowDecisionParts(store: Store, notification: {
     body: string;
     link: string | null;
 }): ChatContent[] | null;
-/** The live buttons on one part, in the order they were minted. */
+/** The live buttons on one part, in the order they were minted: a decision's, a choice's options in their order, or
+ * "Use this as your note?" Yes / No. `key` is unique on the part (Slack names each button by it). */
 export declare function chatFlowButtons(state: ChatState, part: number, now: Date): Array<{
     token: string;
-    action: ChatFlowAction;
+    action: ChatFlowAction | "choose" | "note";
     label: string;
+    key: string;
 }>;
 /**
  * A tapped flow button, inside the action's transaction. false when the
@@ -30,6 +38,21 @@ export declare function applyChatFlowTap(options: {
     state: ChatState;
     label: string;
 }, event: ChatEvent, binding: ChatBinding, token: string, repos: readonly string[], now: Date): boolean;
+/**
+ * A message in the person's own chat while one of their choices waits. Only a reply in the Choose notice's thread (Slack,
+ * Discord) is the note. Any other message there is the lead's, except the first one after a choice that takes replies:
+ * that one is asked about, once — "Use this as your note?" — and only Yes makes it the note (No passes it on to the lead).
+ * false when the message isn't about a choice at all.
+ */
+export declare function answerChoiceMessage(options: {
+    store: Store;
+    state: ChatState;
+    label: string;
+}, event: ChatEvent, binding: ChatBinding, input: {
+    text: string;
+    originalLength?: number;
+    lead?: boolean;
+}, now: Date, repos: readonly string[]): boolean;
 /**
  * A message from the person while a prompt is open: the new draft or the
  * note. false when no prompt is open (the message goes on as usual).