toolroll 0.9.20 → 0.9.21

package/dist/serve.js

@@ -50,7 +50,8 @@ import { saveScript } from "./flow-scripts.js";
 import { flowInsights } from "./flow-insights.js";
 import { FORM_PATH, flowFormPage, receiveFlowForm, shareFlowButton, stopSharingFlowButton } from "./flow-triggers.js";
 import { addFlowTriggerTo, checkFlowTriggerNow, HOOK_PATH, pressFlowButton, receiveFlowHook, removeFlowTrigger, renewFlowHook, removeLinearKey, saveHooksBase, saveLinearKey, saveLinearSigningSecret } from "./flow-triggers.js";
-import { addCardToFlow, advanceFlows, cancelFlowCard, decideFlowCard, FLOW_HREF, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
+import { addCardToFlow, advanceFlows, cancelFlowCard, crossProjectProblem, decideFlowCard, FLOW_HREF, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
+import { chooseFlowCard } from "./flow-send.js";
 import { FLOW_TEMPLATES, validateFlowDefinition } from "./flows.js";
 import { TOOL_CATALOG, addToolTo, catalogTool, discoverTools, projectToolsOf, removeToolFrom, secretsSetFor, setToolSecret, splitCommandLine, testToolOf } from "./project-tools.js";
 import { changeLearning, learningView } from "./project-learning.js";
@@ -167,7 +168,7 @@ import { join } from "node:path";
 import { TEMPLATES, templateByName } from "./templates.js";
 import { starterRecipes, savedRecipes, findRecipe, importRecipe, exportRecipe, createWorkflowPreview, workflowPreview, launchWorkflow, saveWorkflowRecipe, RecipeError, prepareRecipeRun } from "./recipes.js";
 import { recipeFromForm, recipeLibraryHtml, recipeEditorHtml, workflowPreviewHtml, recipeScript, RECIPE_CSS, recipeDefinitionPreviewHtml, recipeRunHtml, recipeAnswersFromForm } from "./recipe-ui.js";
-import { EVIDENCE_CAPS, readVerifiedArtifact, readVerifiedReport, readVerifiedProofForRun, storeEvidence, writeEvidenceFile, scanForSecrets } from "./evidence.js";
+import { EVIDENCE_CAPS, readVerifiedArtifact, readVerifiedReport, readVerifiedProofForRun, reportShotsOf, storeEvidence, writeEvidenceFile, scanForSecrets } from "./evidence.js";
 import { GOAL_ASSESSMENT_PENDING, reviewConflict, manualReviewOnly, manualReviewCriterionOf, personCheckWords, plainReasonWords, dispatchStatusToken, passFraction, semanticCoverage, coverageWords, coverageStateWords } from "./proof.js";
 import { WORK_VIEWS, REVIEW_TOKENS, RESULT_DECISION_SENTENCE, acceptWordsOf, buildProgressOf, cantAcceptYetOf, earlierAttemptsWords, evidenceProblemOf, lastErrorLineOf, missedRequirementOf, reportMismatchesOf, ACCEPT_NEEDS_REASON, MISMATCH_HEADLINE, parseWorkView, resultStatusOf, resultHeadlineOf, receiptHeadingOf, receiptPublicationWords, reviewFactsOf, workStatusOf, primaryDestinationOf, needsPerson, dispatchActionLabel, } from "./workspace-ui.js";
 import { PRICED_BUILD_MODELS } from "./pricing.js";
@@ -6924,7 +6925,7 @@ export function createDecisionServer(options) {
             const repo = body.get("repo") ?? "";
             if (!projects.includes(repo))
                 return refuse(response, who, 404, "Choose one of your projects.", "/flows/new");
-            const answers = Object.fromEntries(template.asks.map(ask => [ask.key, body.get(ask.key) ?? ""]));
+            const answers = { ...Object.fromEntries(template.asks.map(ask => [ask.key, body.get(ask.key) ?? ""])), ...(body.get("send-result") === "yes" ? { "send-result": "yes" } : {}) };
             const name = (body.get("name") ?? "").replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 80) || template.name;
             if (body.get("intent") !== "create")
                 return sendGalleryUse(response, who, template, projects, repo, answers, name, null);
@@ -6943,7 +6944,7 @@ export function createDecisionServer(options) {
                 return sendGalleryUse(response, who, template, projects, repo, answers, name, used.said);
             return redirect(response, `/flows/${used.flow}`);
         }
-        const flowPost = /^\/flows\/([1-9][0-9]{0,9})\/(save|cards|archive|triggers|linear-key|hooks-address|scripts|secrets)$/.exec(url.pathname) ?? /^\/flows\/([1-9][0-9]{0,9})\/cards\/([1-9][0-9]{0,9})\/(move|decide|cancel|comment|assign|watch)$/.exec(url.pathname);
+        const flowPost = /^\/flows\/([1-9][0-9]{0,9})\/(save|cards|archive|triggers|linear-key|hooks-address|scripts|secrets)$/.exec(url.pathname) ?? /^\/flows\/([1-9][0-9]{0,9})\/cards\/([1-9][0-9]{0,9})\/(move|decide|choose|cancel|comment|assign|watch)$/.exec(url.pathname);
         const triggerPost = /^\/flows\/([1-9][0-9]{0,9})\/triggers\/([1-9][0-9]{0,9})\/(pause|resume|remove|check|press|renew|secret|share|unshare)$/.exec(url.pathname);
         if (url.pathname === "/flows/new" || url.pathname === "/flows/example" || url.pathname === "/flows/import" || flowPost !== null || triggerPost !== null) {
             const now = clock();
@@ -7143,6 +7144,10 @@ export function createDecisionServer(options) {
                 const owner = (body.get("owner") ?? "").trim();
                 if (owner !== "" && owner !== flow.owner && !(store.listApprovers().some(one => one.name === owner) && store.accountCanAccess(owner, flow.repo)))
                     return answer(400, { ok: false, said: `${owner} can't approve on this project, so they can't own this flow.` });
+                // A build zone in another project files work there as the flow's owner: only in one they may file in.
+                const elsewhere = crossProjectProblem(store, saved, { repo: flow.repo, owner: owner || flow.owner }, who.name);
+                if (elsewhere !== null)
+                    return answer(400, { ok: false, said: elsewhere });
                 if (!store.saveFlow(flow.id, { name, definitionJson: JSON.stringify(saved), sawRevision: Number(body.get("revision")), by: who.name }, now))
                     return answer(409, { ok: false, said: "Someone else changed this flow. Reload to see their changes, then make yours again." });
                 if (owner !== "" && owner !== flow.owner)
@@ -7180,6 +7185,13 @@ export function createDecisionServer(options) {
                 const decided = decideFlowCard(store, { card: target.id, decision, note, actor: who.name, repos: projects, evidenceRoot, draft: body.get("draft") }, now);
                 return decided.ok ? settle(decided.said) : answer(409, { ok: false, said: decided.message });
             }
+            if (verb === "choose") {
+                // "Person chooses": one of the zone's options (by its place and words), or a reply that becomes the note.
+                const choice = /^[0-9]$/.test(body.get("choice") ?? "") ? Number(body.get("choice")) : null;
+                const chosen = chooseFlowCard(store, { card: target.id, ...(/^[1-9][0-9]{0,9}$/.test(body.get("entry") ?? "") ? { entry: Number(body.get("entry")) } : {}), choice,
+                    ...(choice !== null && body.get("label") !== null ? { label: body.get("label") } : {}), note: choice === null ? body.get("note") : null, actor: who.name, where: "Toolroll", repos: projects, evidenceRoot }, now);
+                return chosen.ok ? settle(chosen.said) : answer(409, { ok: false, said: chosen.message });
+            }
             if (verb === "comment") {
                 const commented = commentOnFlowCard(store, target, who.name, body.get("body"), now);
                 return commented.ok ? settle(commented.said) : answer(400, { ok: false, said: commented.message });
@@ -13505,6 +13517,9 @@ ${THEME_DARK}
   .receipt-shot { display: grid; gap: .35rem; color: var(--muted-foreground); font-size: .75rem; text-decoration: none; }
   .receipt-shot img { display: block; width: 100%; aspect-ratio: 16 / 10; object-fit: cover; border: 1px solid var(--glass-border); border-radius: calc(var(--radius) - 3px); background: var(--muted); }
   @media (hover: hover) and (pointer: fine) { .receipt-shot:hover { color: var(--foreground); } }
+  .report-items ol { margin: .35rem 0 .75rem; padding-left: 1.25rem; display: grid; gap: .75rem; }
+  .report-items li p { margin: .15rem 0; }
+  .report-link { overflow-wrap: anywhere; }
   .receipt-caveats, .receipt-coverage { margin-top: .8rem; padding: .7rem .8rem; border-left: 1px solid var(--border); border-radius: 0 calc(var(--radius) - 3px) calc(var(--radius) - 3px) 0; background: color-mix(in srgb, var(--muted) 62%, transparent); font-size: .78rem; }
   .receipt-caveats ul, .receipt-coverage ul { margin: .3rem 0 0; padding-left: 1.15rem; }
   /* Secondary receipt detail (concise pass, 2026-09-13): native
@@ -20556,6 +20571,7 @@ function taskBodyParts(data) {
                 `<div class="card report">`,
                 `<p><strong>${escape(data.report.report.title)}</strong> <span class="meta">the scout's report · <a href="/r/${data.report.run}">run ${data.report.run}</a></span></p>`,
                 `<p class="report-summary">${escape(data.report.report.summary)}</p>`,
+                reportItemsHtml(data.report.report.items, data.report.shots, data.report.run),
                 `<pre class="recap plan-doc">${escape(data.report.report.report)}</pre>`,
                 ...(data.report.report.followUps.length === 0
                     ? []
@@ -22331,6 +22347,26 @@ function structuredHandoffView(artifacts, root) {
         return null;
     }
 }
+/** What a scout found, each with its link and picture, then any screenshot no item shows. Every link is the cited
+ * http(s) address the report parser admitted; every picture is served from verified evidence. */
+function reportItemsHtml(items, shots, runId) {
+    const picture = (shot) => shot.artifactId === null
+        ? `<p class="meta">Screenshot unavailable: ${escape(shot.problem ?? "it can't be shown")}</p>`
+        : `<a class="receipt-shot" href="/r/${runId}/evidence/${shot.artifactId}"><img src="/r/${runId}/evidence/${shot.artifactId}" alt="${escape(shot.caption)}" loading="lazy"><span>${escape(shot.caption)}</span></a>`;
+    const link = (url) => `<a href="${escape(url)}" rel="noopener noreferrer nofollow" target="_blank" class="report-link">${escape(url)}</a>`;
+    const shown = new Set(items.map(one => one.image).filter((one) => one !== null));
+    const loose = shots.filter(one => !shown.has(one.file));
+    if (items.length === 0 && loose.length === 0)
+        return "";
+    return `<div class="report-items" data-report-items="${items.length}">` +
+        (items.length === 0 ? "" : `<p><strong>What it found</strong></p><ol>${items.map(item => {
+            const shot = item.image === null ? undefined : shots.find(one => one.file === item.image);
+            return `<li data-report-item><p><strong>${escape(item.title)}</strong></p><p class="meta">${escape(item.why)}</p><p class="meta">${link(item.url)}</p>` +
+                (shot === undefined ? "" : `<div class="receipt-visuals">${picture(shot)}</div>`) + `</li>`;
+        }).join("")}</ol>`) +
+        (loose.length === 0 ? "" : `<p><strong>Screenshots</strong></p><div class="receipt-visuals" aria-label="the scout's screenshots">${loose.map(picture).join("")}</div>`) +
+        `</div>`;
+}
 function runReportView(artifacts, root) {
     const artifact = [...artifacts].reverse().find(one => one.kind === "report");
     if (artifact === undefined)
@@ -22347,7 +22383,8 @@ function runReportView(artifacts, root) {
     const parsed = parseReport(read.content.toString("utf8"));
     if (!parsed.ok)
         return { ok: false, artifactId: artifact.id, problem: artifact.truncated ? "the report was shortened at storage and cannot be read; the missing part was never captured" : "the stored report is not a report this console can read" };
-    return { ok: true, artifactId: artifact.id, title: parsed.report.title, summary: parsed.report.summary, document: parsed.report.report, followUps: parsed.report.followUps.length, truncated: artifact.truncated };
+    return { ok: true, artifactId: artifact.id, title: parsed.report.title, summary: parsed.report.summary, document: parsed.report.report, followUps: parsed.report.followUps.length, truncated: artifact.truncated,
+        items: parsed.report.items, shots: reportShotsOf(artifacts, root, artifact.run, parsed.report.images) };
 }
 /** The shared facts (package 3), computed ONCE from the same verified
  * records every surface reads: the head from the sealed diff summary when
@@ -23112,6 +23149,7 @@ function resultPanelParts(detail, o) {
             // already the outcome line above (and, when shortened there, waits
             // in "What the agent reported"), so the article never repeats it.
             summaryParts.push(`<article class="result-report" data-result-report="ok"><h3>${escape(report.title)}</h3>` +
+                reportItemsHtml(report.items, report.shots, runId) +
                 `<pre class="recap plan-doc">${escape(report.document)}</pre>` +
                 `<p class="meta"><a href="/r/${runId}/evidence/${report.artifactId}">${report.truncated ? "Download the stored part of the report (shortened at storage — not the full report)" : "Download the report"}</a>${report.followUps === 0 ? "" : ` · ${report.followUps} proposed follow-up${report.followUps === 1 ? "" : "s"} on <a href="${taskHref(detail.rootId ?? detail.taskId)}">the task</a>`}</p></article>`);
         }

package/dist/slack-chat.js

@@ -76,7 +76,7 @@ export function receiveSlack(state, identity, type, raw, now) {
         const action = object(actions[0]), container = object(body.container);
         if (
         // toolroll_* since the rename; standing_orders_* buttons on older messages still work.
-        !/^(?:toolroll|standing_orders)_(confirm|dismiss|yes|cancel|flow_approve|flow_edit|flow_send_back|question_choice|question_words)$/.test(String(action.action_id)) ||
+        !/^(?:toolroll|standing_orders)_(confirm|dismiss|yes|cancel|flow_approve|flow_edit|flow_send_back|flow_choose_[0-3]|flow_note_(?:yes|no)|question_choice|question_words)$/.test(String(action.action_id)) ||
             typeof action.value !== "string" ||
             !/^[a-f0-9]{32}$/.test(action.value) ||
             !slackTs(action.action_ts) ||
@@ -370,11 +370,11 @@ export async function deliverSlackPart(options) {
         else
             buttons = [
                 // A flow decision (v88): Approve / Edit / Send back, then the link.
-                ...(content.flow
+                ...(content.flow || content.choose || content.note
                     ? chatFlowButtons(state, row.id, now).map((one) => ({
                         type: "button",
                         text: { type: "plain_text", text: one.label },
-                        action_id: `toolroll_flow_${one.action.replace("-", "_")}`,
+                        action_id: `toolroll_flow_${one.key}`,
                         value: one.token,
                         ...(one.action === "approve" ? { style: "primary" } : {}),
                     }))

package/dist/store.d.ts

@@ -49,6 +49,11 @@ export type TaskActRow = {
 export declare const MATE_ASK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS mate_ask (\n  turn         INTEGER PRIMARY KEY REFERENCES mate_turn(id) ON DELETE CASCADE,\n  thread       INTEGER NOT NULL REFERENCES mate_thread(id) ON DELETE CASCADE,\n  question     TEXT NOT NULL,\n  options_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);\n";
 /** 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 declare const FLOW_SEND_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_send (\n  card         INTEGER NOT NULL REFERENCES flow_card(id),\n  entry        INTEGER NOT NULL,\n  stage        TEXT NOT NULL,\n  person       TEXT NOT NULL,\n  content_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL,\n  PRIMARY KEY (card, entry)\n);\nCREATE TABLE IF NOT EXISTS telegram_flow_choice (\n  token       TEXT PRIMARY KEY,\n  binding     INTEGER NOT NULL REFERENCES telegram_binding(id) ON DELETE RESTRICT,\n  card        INTEGER NOT NULL REFERENCES flow_card(id),\n  entry       INTEGER NOT NULL,\n  choice      INTEGER NOT NULL,\n  label       TEXT NOT NULL,\n  chat_id     TEXT NOT NULL,\n  message_id  TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS telegram_flow_choice_visit ON telegram_flow_choice (card, entry);\n";
 export declare const CHAT_DECIDE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_decide_action (\n  token       TEXT PRIMARY KEY,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  message     TEXT,\n  act         TEXT NOT NULL CHECK (act IN ('accept','changes','retry','approve','not-now','merge')),\n  phase       TEXT NOT NULL CHECK (phase IN ('offer','yes','cancel')),\n  task_id     TEXT NOT NULL,\n  run         INTEGER,\n  digest      TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_action_message ON chat_decide_action (channel, chat, message);\nCREATE TABLE IF NOT EXISTS chat_decide_prompt (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  task_id     TEXT NOT NULL,\n  run         INTEGER NOT NULL,\n  digest      TEXT NOT NULL,\n  message     TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_prompt_open ON chat_decide_prompt (channel, binding, consumed_at);\n";
 export type MateAsk = {
     turn: number;
@@ -1007,6 +1012,9 @@ export type NotificationPreference = {
 };
 /** One person's saved screenshots following a result message: its own outbox row, addressed to them (result-shots.ts). */
 export declare 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 declare const FLOW_SHOTS_KIND = "flow-screenshots";
 /** Tasks filed this close together share one chat message. */
 export declare const QUIET_GROUP_MS = 60000;
 export declare function isDigestTime(value: string): boolean;
@@ -1463,6 +1471,28 @@ export type TelegramFlowPrompt = {
     entry: number;
     mode: "edit" | "send-back";
 };
+/** One option's button on a "Person chooses" message (flow-send.ts). */
+export type TelegramFlowChoice = {
+    token: string;
+    binding: number;
+    card: number;
+    entry: number;
+    choice: number;
+    label: string;
+    chatId: string;
+    messageId: string | null;
+    expiresAt: string;
+    consumedAt: string | null;
+};
+/** What a "Send to me" or "Person chooses" visit sent its person (flow-send.ts). */
+export type FlowSendRow = {
+    card: number;
+    entry: number;
+    stage: string;
+    person: string;
+    contentJson: string;
+    createdAt: string;
+};
 export type TelegramBinding = {
     id: number;
     botId: string;
@@ -5910,6 +5940,27 @@ export declare class Store {
     recordTelegramFlowPrompt(prompt: TelegramFlowPrompt, now: Date, hours?: number): void;
     /** The live prompt a message replies to, if any. */
     telegramFlowPrompt(chatId: string, messageId: string, now: Date): TelegramFlowPrompt | null;
+    /** What one visit sent: recorded once, the first time (a later pass finds it kept). */
+    recordFlowSend(row: Omit<FlowSendRow, "createdAt">, now: Date): boolean;
+    flowSend(card: number, entry: number): FlowSendRow | null;
+    /** Every visit's send for a card, newest first: what the card shows it sent. */
+    flowSends(card: number): FlowSendRow[];
+    createTelegramFlowChoices(at: {
+        binding: number;
+        chatId: string;
+        card: number;
+        entry: number;
+    }, choices: readonly {
+        token: string;
+        choice: number;
+        label: string;
+    }[], now: Date, days?: number): void;
+    getTelegramFlowChoice(token: string): TelegramFlowChoice | null;
+    placeTelegramFlowChoices(tokens: readonly string[], messageId: string): void;
+    /** 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: number, entry: number, now: Date): void;
     createTelegramQuestionActions(at: {
         binding: number;
         chatId: string;
@@ -7305,6 +7356,8 @@ export declare class Store {
     runningBuildsByRepo(now: Date): Map<string, number>;
     /** A project's build concurrency changed (project-concurrency.ts): the ledger keeps before → after. */
     recordProjectConcurrency(by: string, repo: string, before: number, after: number, now: Date): void;
+    /** Review 827: a project's demo URL changed (`off` when it has none). */
+    recordProjectDemo(by: string, repo: string, before: string | null, after: string | null, now: Date): void;
     /** 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: string, updateId: number, payload: string, now: Date): boolean;

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