toolroll 0.9.20 → 0.9.21

package/dist/chat-flow.js

@@ -16,13 +16,24 @@
  * Every button is one opaque token for one visit of one card, on the part it
  * rides: a tap on any other message, from anyone but the paired person, or
  * for a card that moved on, changes nothing.
+ *
+ * A "Send to me" visit (flow-send.ts) is one notice with its links; a "Person
+ * chooses" visit is the same with the zone's own options as buttons. Instead
+ * of a tap, a reply in the notice's thread is the note for where replies go;
+ * the first other message in their chat is asked about once ("Use this as
+ * your note?"), and everything else goes to the lead as usual. Choices are
+ * made through chooseFlowCard, by that person alone, for exactly that visit,
+ * and spend that visit's buttons in every chat app.
  */
 import { keptDraft } from "./flow-draft.js";
 import { decideFlowCard, flowCardHref, flowDefinitionOf } from "./flow-engine.js";
-import { deciderOf } from "./flows.js";
+import { chooseFlowCard, flowChoiceAt, flowSendPaths, FLOW_CHOOSE_KEY, FLOW_SEND_KEY, readFlowSend } from "./flow-send.js";
+import { deciderOf, replyTarget } from "./flows.js";
 import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
 import { verifyApproverStanding } from "./principal.js";
+import { chatHash } from "./chat-delivery-state.js";
 import { FLOW_DECIDE_KEY, flowDecisionAt } from "./telegram-flow.js";
+import { phoneCommand } from "./telegram-status.js";
 export const CHAT_FLOW_LABELS = { approve: "Approve", edit: "Edit", "send-back": "Send back" };
 const PART_CHARS = 2800;
 const PROMPT_MS = 30 * 60_000;
@@ -56,24 +67,57 @@ function decisionParts(text, visit, link) {
     const all = pieces(chatFlowText(text));
     return all.map((piece, index) => index < all.length - 1 ? { text: piece } : { text: piece, flow: visit, ...(link === null ? {} : { link }) });
 }
+/** A sent visit's links as a part's buttons: the first as its link, the rest beside it. */
+function sendLinks(paths) {
+    return { ...(paths[0] === undefined ? {} : { link: paths[0] }), ...(paths.length > 1 ? { also: paths.slice(1) } : {}) };
+}
+/** A "Send to me" notice as chat parts: what was done, then its links; null when it isn't one. */
+export function flowSendParts(store, notification) {
+    const visit = FLOW_SEND_KEY.exec(notification.dedupeKey);
+    const kept = visit === null ? null : store.flowSend(Number(visit[1]), Number(visit[2]));
+    const content = kept === null ? null : readFlowSend(kept.contentJson);
+    if (content === null)
+        return null;
+    const all = pieces(chatFlowText(`${notification.subject}\n\n${notification.body}`));
+    return all.map((piece, index) => index < all.length - 1 ? { text: piece } : { text: piece, ...sendLinks(flowSendPaths(content)) });
+}
 /**
  * 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).
  */
 export function flowDecisionParts(store, notification) {
+    const choose = FLOW_CHOOSE_KEY.exec(notification.dedupeKey);
+    if (choose !== null) {
+        const visit = flowChoiceAt(store, Number(choose[1]), Number(choose[2]));
+        const kept = visit === null ? null : store.flowSend(visit.card.id, visit.card.entry);
+        const content = kept === null ? null : readFlowSend(kept.contentJson);
+        if (visit === null || content === null)
+            return null;
+        const options = (content.options ?? []).filter(one => visit.stage.options?.[one.choice]?.label === one.label);
+        const all = pieces(chatFlowText(`${notification.subject}\n\n${notification.body}`));
+        return all.map((piece, index) => index < all.length - 1 ? { text: piece }
+            : { text: piece, choose: { card: visit.card.id, entry: visit.card.entry, options }, ...sendLinks(flowSendPaths(content)) });
+    }
     const visit = FLOW_DECIDE_KEY.exec(notification.dedupeKey);
     const waiting = visit === null ? null : flowDecisionAt(store, Number(visit[1]), Number(visit[2]));
     if (waiting === null)
         return null;
     return decisionParts(`${notification.subject}\n\n${notification.body}`, { card: waiting.card.id, entry: waiting.card.entry, actions: actionsFor(waiting) }, notification.link === null ? null : { label: "Open", path: notification.link });
 }
-/** 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 function chatFlowButtons(state, part, now) {
-    return state.prepare("SELECT token,action FROM chat_flow_action WHERE part=? AND consumed IS NULL AND expires>? ORDER BY rowid").all(part, now.toISOString())
-        .map(one => ({ token: String(one.token), action: one.action, label: CHAT_FLOW_LABELS[one.action] }));
+    const decide = state.prepare("SELECT token,action FROM chat_flow_action WHERE part=? AND consumed IS NULL AND expires>? ORDER BY rowid").all(part, now.toISOString())
+        .map(one => ({ token: String(one.token), action: one.action, label: CHAT_FLOW_LABELS[one.action], key: one.action.replace("-", "_") }));
+    const choose = state.prepare("SELECT token,choice,label FROM chat_flow_choice WHERE part=? AND consumed IS NULL AND expires>? ORDER BY choice").all(part, now.toISOString())
+        .map(one => ({ token: String(one.token), action: "choose", label: String(one.label), key: `choose_${Number(one.choice)}` }));
+    const note = state.prepare("SELECT token,answer FROM chat_flow_note WHERE part=? AND consumed IS NULL AND expires>? ORDER BY answer DESC").all(part, now.toISOString())
+        .map(one => ({ token: String(one.token), action: "note", label: one.answer === "yes" ? "Yes" : "No", key: `note_${one.answer}` }));
+    return [...decide, ...choose, ...note];
 }
 const retire = (state, card, entry, now) => {
     state.prepare("UPDATE chat_flow_action SET consumed=? WHERE card=? AND entry=? AND consumed IS NULL").run(now.toISOString(), card, entry);
+    state.prepare("UPDATE chat_flow_choice SET consumed=? WHERE card=? AND entry=? AND consumed IS NULL").run(now.toISOString(), card, entry);
     state.prepare("UPDATE chat_flow_prompt SET consumed=? WHERE card=? AND entry=? AND consumed IS NULL").run(now.toISOString(), card, entry);
 };
 /** Show the tapped notice again with what happened, and without its buttons. */
@@ -92,7 +136,7 @@ export function applyChatFlowTap(options, event, binding, token, repos, now) {
     const { store, state } = options;
     const action = state.prepare("SELECT a.*,p.message,e.binding AS owner,e.channel FROM chat_flow_action a JOIN chat_part p ON p.id=a.part JOIN chat_event e ON e.id=p.event WHERE a.token=?").get(token);
     if (action === undefined)
-        return false;
+        return applyChatChoiceTap(options, event, binding, token, repos, now) || applyChatNoteTap(options, event, binding, token, repos, now);
     const say = (text) => state.plan(event.id, [{ text }], now);
     // Bound to the person, the chat and the exact message the button rode.
     if (Number(action["owner"]) !== binding.id || action["channel"] !== event.channel || action["message"] !== event.ts) {
@@ -144,6 +188,174 @@ export function applyChatFlowTap(options, event, binding, token, repos, now) {
         : `What should change on “${waiting.card.title}”? Your next message here is the note, and the card goes back to ${back} with it. Send “cancel” to leave it where it is.`);
     return true;
 }
+/** A tapped option of a "Person chooses" notice; false when the token isn't one. */
+function applyChatChoiceTap(options, event, binding, token, repos, now) {
+    const { store, state } = options;
+    const tapped = state.prepare("SELECT c.*,p.message,e.binding AS owner,e.channel FROM chat_flow_choice c JOIN chat_part p ON p.id=c.part JOIN chat_event e ON e.id=p.event WHERE c.token=?").get(token);
+    if (tapped === undefined)
+        return false;
+    const say = (text) => state.plan(event.id, [{ text }], now);
+    // Bound to the person, the chat and the exact message the button rode.
+    if (Number(tapped["owner"]) !== binding.id || tapped["channel"] !== event.channel || tapped["message"] !== event.ts) {
+        say("That button expired or was already used. Ask for the current state before trying again.");
+        return true;
+    }
+    if (tapped["consumed"] !== null || String(tapped["expires"]) <= now.toISOString()) {
+        say("That was already chosen, or these buttons are too old.");
+        return true;
+    }
+    const card = Number(tapped["card"]), entry = Number(tapped["entry"]), part = Number(tapped["part"]);
+    const visit = flowChoiceAt(store, card, entry);
+    if (visit === null) {
+        retire(state, card, entry, now);
+        repaint(state, part, event, "This card has moved on since; nothing was changed.");
+        state.finish(event.id);
+        return true;
+    }
+    if (visit.person !== binding.approver) {
+        say(`Only ${visit.person} chooses here.`);
+        return true;
+    }
+    if (!verifyApproverStanding(store, binding.approver, binding.generation, repos).ok) {
+        state.finish(event.id, true);
+        return true;
+    }
+    const label = String(tapped["label"]);
+    const chosen = chooseFlowCard(store, { card, entry, choice: Number(tapped["choice"]), label, note: null, actor: binding.approver, where: options.label, repos }, now);
+    if (!chosen.ok) {
+        say(chosen.message);
+        return true;
+    }
+    retire(state, card, entry, now);
+    store.retireFlowChoices(card, entry, now);
+    repaint(state, part, event, `✅ You chose “${label}”. ${chosen.said}`);
+    state.finish(event.id);
+    return true;
+}
+/** A reply that is the note for where a choice's replies go; `say` answers on the message it came from. */
+function replyAsNote(options, binding, said, cutShort, visit, repos, now) {
+    const { store } = options;
+    if (said === "")
+        return { ok: false, said: "Say what you'd change." };
+    if (cutShort || said.length > 2000)
+        return { ok: false, said: "That's too long to take from here. Keep it under 2,000 characters, or reply in Toolroll." };
+    if (!verifyApproverStanding(store, binding.approver, binding.generation, repos).ok)
+        return null;
+    const chosen = chooseFlowCard(store, { card: visit.card, entry: visit.entry, choice: null, note: said, actor: binding.approver, where: options.label, repos }, now);
+    return chosen.ok ? { ok: true, said: chosen.said } : { ok: false, said: chosen.message };
+}
+/** The choice a part's message carries, by the message any of its parts was posted as (a long notice is several). */
+function choiceOnMessage(state, binding, channel, message) {
+    const row = state.prepare(`SELECT c.card,c.entry,MAX(c.consumed IS NULL) AS live FROM chat_part p JOIN chat_event e ON e.id=p.event
+    JOIN chat_part q ON q.event=p.event JOIN chat_flow_choice c ON c.part=q.id WHERE e.binding=? AND e.channel=? AND p.message=? GROUP BY c.card,c.entry ORDER BY MAX(c.rowid) DESC LIMIT 1`)
+        .get(binding.id, channel, message);
+    return row === undefined ? null : { card: Number(row["card"]), entry: Number(row["entry"]), live: Number(row["live"]) === 1 };
+}
+/**
+ * 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 function answerChoiceMessage(options, event, binding, input, now, repos) {
+    const { store, state } = options;
+    if (event.kind !== "message" || event.channel !== binding.channel || input.lead === true)
+        return false;
+    const say = (text) => state.plan(event.id, [{ text }], now);
+    const said = input.text.trim();
+    return store.transact(() => {
+        if (event.thread !== "" && event.thread !== event.ts) {
+            const on = choiceOnMessage(state, binding, event.channel, event.thread);
+            if (on === null)
+                return false;
+            const visit = flowChoiceAt(store, on.card, on.entry);
+            if (visit === null || !on.live) {
+                say("That choice was already made, or the card moved on; nothing was changed.");
+                return true;
+            }
+            if (visit.person !== binding.approver) {
+                say(`Only ${visit.person} chooses here.`);
+                return true;
+            }
+            if (replyTarget(visit.stage) === null) {
+                say("This step takes one of its options. Tap one above.");
+                return true;
+            }
+            const done = replyAsNote(options, binding, said, (input.originalLength ?? 0) > input.text.length, on, repos, now);
+            if (done === null)
+                state.finish(event.id, true);
+            else
+                say(done.ok ? `↩️ ${done.said}` : done.said);
+            return true;
+        }
+        if (said === "" || phoneCommand(said) !== null)
+            return false;
+        // The newest choice of theirs still open here that takes a reply and hasn't asked yet.
+        const open = state.prepare(`SELECT DISTINCT c.card,c.entry FROM chat_flow_choice c JOIN chat_part p ON p.id=c.part JOIN chat_event e ON e.id=p.event
+      WHERE e.binding=? AND c.consumed IS NULL AND c.expires>? AND NOT EXISTS (SELECT 1 FROM chat_flow_note n WHERE n.card=c.card AND n.entry=c.entry) ORDER BY c.rowid DESC`)
+            .all(binding.id, now.toISOString());
+        for (const one of open) {
+            const visit = flowChoiceAt(store, Number(one.card), Number(one.entry));
+            const target = visit === null ? null : replyTarget(visit.stage);
+            if (visit === null || target === null || visit.person !== binding.approver)
+                continue;
+            const to = visit.definition.stages.find(stage => stage.id === target)?.title ?? target;
+            state.plan(event.id, [{ text: `Use this as your note on “${visit.card.title}”?\nYes sends it to ${to}. No passes it to the lead.`,
+                    note: { card: visit.card.id, entry: visit.card.entry, held: event.id } }], now);
+            // What it said is kept beside its question until answered: the event's own copy is cleared once it is handled.
+            state.prepare("UPDATE chat_flow_note SET words=? WHERE held=?").run(JSON.stringify({ text: input.text, ...(input.originalLength === undefined ? {} : { originalLength: input.originalLength }) }), event.id);
+            return true;
+        }
+        return false;
+    });
+}
+/** Yes or No to "Use this as your note?"; false when the token isn't one. */
+function applyChatNoteTap(options, event, binding, token, repos, now) {
+    const { store, state } = options;
+    const tapped = state.prepare("SELECT n.*,p.message,e.binding AS owner,e.channel FROM chat_flow_note n JOIN chat_part p ON p.id=n.part JOIN chat_event e ON e.id=p.event WHERE n.token=?").get(token);
+    if (tapped === undefined)
+        return false;
+    const say = (text) => state.plan(event.id, [{ text }], now);
+    if (Number(tapped["owner"]) !== binding.id || tapped["channel"] !== event.channel || tapped["message"] !== event.ts) {
+        say("That button expired or was already used. Ask for the current state before trying again.");
+        return true;
+    }
+    const part = Number(tapped["part"]), card = Number(tapped["card"]), entry = Number(tapped["entry"]);
+    if (tapped["consumed"] !== null || String(tapped["expires"]) <= now.toISOString()) {
+        repaint(state, part, event, "That choice was already made, or the card moved on; nothing was changed.");
+        state.finish(event.id);
+        return true;
+    }
+    state.prepare("UPDATE chat_flow_note SET consumed=?,words=NULL WHERE part=?").run(now.toISOString(), part);
+    const held = state.event(String(tapped["held"]));
+    const words = typeof tapped["words"] === "string" ? JSON.parse(tapped["words"]) : null;
+    if (held === null || words === null || typeof words.text !== "string") {
+        repaint(state, part, event, "That message is no longer kept; nothing was changed.");
+        state.finish(event.id);
+        return true;
+    }
+    if (tapped["answer"] === "no") {
+        // Passed on as the message it was, to the lead, once.
+        state.enqueue({ id: chatHash(`${held.id}:lead`), installation: held.installation, binding: held.binding, kind: "message", channel: held.channel, member: held.member,
+            ts: held.ts, thread: held.thread, payload: JSON.stringify({ ...words, lead: true }), created: now.toISOString() });
+        repaint(state, part, event, "Passed to the lead.");
+        state.finish(event.id);
+        return true;
+    }
+    if (flowChoiceAt(store, card, entry) === null) {
+        repaint(state, part, event, "That choice was already made, or the card moved on; nothing was changed.");
+        state.finish(event.id);
+        return true;
+    }
+    const done = replyAsNote(options, binding, words.text.trim(), typeof words.originalLength === "number" && words.originalLength > words.text.length, { card, entry }, repos, now);
+    if (done === null) {
+        state.finish(event.id, true);
+        return true;
+    }
+    repaint(state, part, event, done.ok ? `↩️ ${done.said}` : done.said);
+    state.finish(event.id);
+    return true;
+}
 /**
  * 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).

package/dist/desktop-update.d.ts

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

package/dist/discord-chat.js

@@ -284,11 +284,11 @@ export async function deliverDiscordPart(options) {
         else if (!content.image)
             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: 2,
                         style: one.action === "approve" ? 3 : 2,
-                        label: one.label,
+                        label: one.label.slice(0, 80),
                         custom_id: `so_${one.token}`,
                     }))
                     : []),

package/dist/evidence.d.ts

@@ -13,7 +13,7 @@
  * cannot pre-write them — created exclusively (`wx`) with mode 0600. The
  * store holds keys relative to that root, never absolute paths.
  */
-import { type ParsedReport } from "./scout-report.js";
+import { type ParsedReport, type ReportImage } from "./scout-report.js";
 import { type ParsedProof } from "./proof.js";
 import type { Artifact, Store } from "./store.js";
 import type { ExecResult } from "./exec.js";
@@ -108,11 +108,23 @@ export type ReportView = {
     ok: true;
     run: number;
     report: ParsedReport;
+    shots: ReportShot[];
 } | {
     ok: false;
     run: number;
     problem: string;
 };
+/** A report's screenshot as a page shows it: its stored evidence, or why it can't be shown. The bytes are
+ * verified again whenever the image itself is served. */
+export type ReportShot = {
+    file: string;
+    caption: string;
+    url: string;
+    artifactId: number | null;
+    problem: string | null;
+};
+/** Each image a report names, matched to the screenshot evidence its own run stored with the same sha256. */
+export declare function reportShotsOf(artifacts: readonly Artifact[], root: string, run: number, images: readonly ReportImage[]): ReportShot[];
 export declare function readVerifiedReport(store: Store, root: string, taskRef: number): ReportView | null;
 /** A build's proof, read the same verified way as a scout's report — but
  * keyed by RUN, not task: unlike a scout's report (the task's one rolling

package/dist/evidence.js

@@ -227,6 +227,15 @@ export function readMailbox(path, cap = LIMITS.payload) {
         closeSync(fd);
     }
 }
+/** Each image a report names, matched to the screenshot evidence its own run stored with the same sha256. */
+export function reportShotsOf(artifacts, root, run, images) {
+    const pruned = existsSync(join(root, String(run), RETENTION_NOTE));
+    return images.map(image => {
+        const stored = artifacts.find(one => one.id === image.artifact && one.run === run && one.kind === "screenshot" && one.sha256 === image.sha256);
+        const problem = pruned ? "removed by the retention setting" : stored === undefined ? "the saved screenshot is missing" : null;
+        return { file: image.file, caption: image.caption, url: image.url, artifactId: problem === null ? stored.id : null, problem };
+    });
+}
 export function readVerifiedReport(store, root, taskRef) {
     const artifact = store.latestReportArtifact(taskRef);
     if (artifact === null)
@@ -243,7 +252,7 @@ export function readVerifiedReport(store, root, taskRef) {
     const parsed = parseReport(verified.content.toString("utf8"));
     if (!parsed.ok)
         return { ok: false, run: artifact.run, problem: "the stored report is not a report this build can read" };
-    return { ok: true, run: artifact.run, report: parsed.report };
+    return { ok: true, run: artifact.run, report: parsed.report, shots: reportShotsOf(store.artifactsFor(artifact.run), root, artifact.run, parsed.report.images) };
 }
 /** Verifies this run's proof bytes and format. A handoff that relies on a
  * revision's ancestors must also recheck its saved review-context custody. */

package/dist/flow-engine.d.ts

@@ -22,6 +22,11 @@ export declare function flowGoalCuts(store: Store, taskId: string, goal: string)
     label: string;
     text: string;
 }[];
+/** Why a flow can't be saved as drawn: a build zone in a project its owner, or whoever saves it, may not file work in; null when none. */
+export declare function crossProjectProblem(store: Store, definition: FlowDefinition, flow: {
+    repo: string;
+    owner: string;
+}, editor?: string): string | null;
 export type FlowAct = {
     ok: true;
     said: string;
@@ -57,6 +62,8 @@ export type FlowDecision = {
 /** A person's decision on a card waiting in an approval zone. A send back to a build zone whose work has a result becomes a revision of that work. */
 /** The draft a decision is about: the draft zone that sends its cards to this one. */
 export declare function draftFor(definition: FlowDefinition, stage: FlowStage): FlowStage | null;
+/** Back to a build zone with a finished result: a revision of that same work, carrying the note; null when it isn't one. */
+export declare function revisionWithNote(store: Store, card: FlowCardRow, target: FlowStage | undefined, note: string, actor: string, repos: readonly string[], evidenceRoot: string | undefined, now: Date): string | null;
 export declare function decideFlowCard(store: Store, input: {
     card: number;
     decision: "approve" | "send-back";

package/dist/flow-engine.js

@@ -9,13 +9,14 @@ import { assignmentOf } from "./assignment.js";
 import { filerFor } from "./approval-policy.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
 import { deciderOf, durationWords, fillFlowText, fitFlowText, flowWorkTemplate, validateFlowDefinition, withinHours } from "./flows.js";
-import { reportSummaryFor } from "./report-summary.js";
+import { reportFillIns, reportSummaryFor } from "./report-summary.js";
 import { fileTaskProposal } from "./proposal.js";
 import { requestResultChanges } from "./result-actions.js";
 import { revisionSourceOf } from "./result-review.js";
-import { scanForSecrets } from "./evidence.js";
+import { readVerifiedReport, scanForSecrets } from "./evidence.js";
 import { cardFollowers, notifyPeople } from "./flow-people.js";
 import { keptDraft } from "./flow-draft.js";
+import { chooseStep, flowPersonOf, sendStep } from "./flow-send.js";
 import { parseSoul, teammateLabel } from "./teammates.js";
 /** The flow's drawing, or null when it can't be read (the card then says so and waits). */
 export function flowDefinitionOf(flow) {
@@ -38,6 +39,7 @@ function fill(template, card) {
     return fillFlowText(template, { title: card.title, description: card.description, note: card.note, outputs: card.outputs });
 }
 const titleIn = (definition, id) => definition.stages.find(one => one.id === id)?.title ?? id;
+const flowDefinitionStage = (definition, id) => definition.stages.find(one => one.id === id);
 /** A teammate's name as its soul file gives it (its handle when the file can't be read). */
 function teammateName(mate) {
     const read = parseSoul(mate.soul);
@@ -109,7 +111,7 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
     if (stage.limit !== undefined && stage.kind !== "wait" && stage.kind !== "done") {
         const entered = Date.parse(store.flowCardEnteredAt(card.id) ?? card.updatedAt);
         if (now.getTime() >= entered + stage.limit.minutes * 60_000) {
-            const decider = stage.kind === "approval" ? deciderOf(stage, flow) : null;
+            const decider = stage.kind === "approval" ? deciderOf(stage, flow) : stage.kind === "choose" ? flowPersonOf(card, flow) : null;
             const to = stage.limit.to;
             notifyPeople(store, card, [decider ?? card.owner ?? flow.owner], null, { key: `limit:${card.entry}`, attention: true,
                 subject: `“${card.title}” has waited ${durationWords(stage.limit.minutes)} in ${stage.title}`,
@@ -212,9 +214,18 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
             }
             return;
         }
+        case "send":
+            // What the step before produced, to the card's person in each chat app they paired and on the card; then on.
+            sendStep(store, flow, definition, stage, card, now, options.evidenceRoot);
+            onward("ok");
+            return;
+        case "choose":
+            // The same, with the zone's options as buttons: the card waits for the person's choice (chooseFlowCard).
+            chooseStep(store, flow, definition, stage, card, now, options.evidenceRoot);
+            return;
         case "task":
         case "report":
-            workStage(store, flow, stage, card, now, options, outcome, onward);
+            workStage(store, flow, definition, stage, card, now, options, outcome, onward);
             return;
         case "check":
         case "pull-request":
@@ -228,7 +239,9 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
             return;
     }
 }
-function workStage(store, flow, stage, card, now, options, outcome, onward) {
+function workStage(store, flow, definition, stage, card, now, options, outcome, onward) {
+    // A build may work in another project (its zone's repo), one the flow's owner may file in; research stays in the flow's.
+    const repo = stage.kind === "task" && stage.repo !== undefined ? stage.repo : flow.repo;
     if (card.task === null) {
         const report = stage.kind === "report";
         // Waiting cards try again every pass, so a cause that's fixed (a shorter zone, a freed backlog) files the work then.
@@ -241,6 +254,10 @@ function workStage(store, flow, stage, card, now, options, outcome, onward) {
             wait(`${stage.title}'s instructions are too long for a task. Open the flow and shorten them.`);
             return;
         }
+        if (repo !== flow.repo && !store.accountCanAccess(flow.owner, repo)) {
+            wait(`${flow.owner}, who owns this flow, can't file work in ${repo}. Choose another project for ${stage.title}, or give them access.`);
+            return;
+        }
         // Filed exactly once however many passes advance this project: the card is claimed (still this entry, in this zone,
         // with no task) in the same transaction that files its task, so another pass finds it claimed and leaves it.
         const filed = store.transact(() => {
@@ -249,13 +266,13 @@ function workStage(store, flow, stage, card, now, options, outcome, onward) {
                 return null;
             const made = fileTaskProposal(store, {
                 title: (report ? `${stage.title}: ${card.title}` : card.title).slice(0, 200),
-                repo: flow.repo,
+                repo,
                 goal,
                 filedVia: `flow:${flow.id}`, filedBy: filerFor(card.createdBy), // who made the card asked for the work (an owner can be reassigned by anyone)
                 deliverable: report ? "report" : "branch",
                 planning: report ? "skip" : stage.planning ?? "auto",
                 acceptance: report ? ACCEPTANCE.report : ACCEPTANCE.task,
-                admittedRepos: [flow.repo],
+                admittedRepos: [repo],
             }, now);
             if (made.ok)
                 store.updateFlowCard(card.id, { task: made.id, ...(report || fresh.primaryTask !== null ? {} : { primaryTask: made.id }), waiting: "Filed as a task" }, now);
@@ -271,7 +288,7 @@ function workStage(store, flow, stage, card, now, options, outcome, onward) {
         return;
     }
     // A send back may have made a revision: follow the task's current version.
-    const family = store.taskFamilyOf(card.task, [flow.repo], false);
+    const family = store.taskFamilyOf(card.task, [repo], false);
     const current = family?.current.id ?? card.task;
     const task = store.getTask(current);
     if (task === null) {
@@ -281,7 +298,7 @@ function workStage(store, flow, stage, card, now, options, outcome, onward) {
     if (task.state === "done") {
         // A build whose project checks failed is done but not good: it takes the failure path, like a failed build.
         if (stage.kind === "task") {
-            const checks = assignmentOf(store, current, now, { principal: "operator", repos: [flow.repo] }, options.evidenceRoot)?.receipt?.checks ?? null;
+            const checks = assignmentOf(store, current, now, { principal: "operator", repos: [repo] }, options.evidenceRoot)?.receipt?.checks ?? null;
             if (checks?.status === "failed") {
                 const said = `The checks failed on its result: ${checks.detail}`;
                 store.updateFlowCard(card.id, { outputs: { ...card.outputs, [stage.id]: `${said} (task ${current})` }, primaryTask: current }, now);
@@ -297,12 +314,24 @@ function workStage(store, flow, stage, card, now, options, outcome, onward) {
             const ref = store.lookupRef(current);
             const summary = ref === null ? null : reportSummaryFor(store, options.evidenceRoot, ref.id);
             outputs[stage.id] = summary !== null && "summary" in summary ? summary.summary.slice(0, 6000) : "The report is ready on its task.";
+            // {{stage.<id>.items}} and {{stage.<id>.report}}: what it found and the whole report, for the zones after it.
+            // A visit's report replaces the last visit's, so nothing stale is left behind.
+            const view = ref === null || options.evidenceRoot === undefined ? null : readVerifiedReport(store, options.evidenceRoot, ref.id);
+            const found = view?.ok === true ? reportFillIns(view.report) : { items: "", report: "" };
+            for (const [part, text] of Object.entries(found)) {
+                if (text === "")
+                    delete outputs[`${stage.id}.${part}`];
+                else
+                    outputs[`${stage.id}.${part}`] = text;
+            }
         }
         else {
             outputs[stage.id] = `Result ready on task ${current}.`;
         }
         store.updateFlowCard(card.id, { outputs, ...(stage.kind === "task" ? { primaryTask: current } : {}), waiting: null }, now);
-        onward("ok");
+        // A "Send to me" or "Person chooses" zone next reads what this task produced: the task goes with the card there.
+        const following = stage.next === null ? undefined : flowDefinitionStage(definition, stage.next);
+        onward("ok", undefined, following?.kind === "send" || following?.kind === "choose" ? current : undefined);
         return;
     }
     if (task.state === "failed" || task.state === "cancelled") {
@@ -343,17 +372,27 @@ function goalCuts(store, taskId, goal) {
     const labels = { "card.title": "The card's title", "card.description": "The card's description", note: "The note it was sent back with" };
     const cuts = [];
     const seen = new Set();
-    for (const match of flowWorkTemplate(stage.instructions ?? card.title, card).matchAll(/\{\{\s*(card\.title|card\.description|note|stage\.([a-z0-9-]+))\s*\}\}/g)) {
+    for (const match of flowWorkTemplate(stage.instructions ?? card.title, card).matchAll(/\{\{\s*(card\.title|card\.description|note|stage\.([a-z0-9-]+)(?:\.(items|report))?)\s*\}\}/g)) {
         if (seen.has(match[1]))
             continue;
         seen.add(match[1]);
         const text = fillFlowText(`{{${match[1]}}}`, card);
         if (text === "" || goal.includes(text))
             continue;
-        cuts.push({ label: labels[match[1]] ?? `What ${titleIn(definition, match[2])} found`, text: text.slice(0, 50_000) });
+        const part = match[3] === "items" ? "listed" : match[3] === "report" ? "reported in full" : "found";
+        cuts.push({ label: labels[match[1]] ?? `What ${titleIn(definition, match[2])} ${part}`, text: text.slice(0, 50_000) });
     }
     return cuts;
 }
+/** Why a flow can't be saved as drawn: a build zone in a project its owner, or whoever saves it, may not file work in; null when none. */
+export function crossProjectProblem(store, definition, flow, editor = flow.owner) {
+    const elsewhere = definition.stages.filter((one) => one.kind === "task" && one.repo !== undefined && one.repo !== flow.repo);
+    const owners = elsewhere.find(one => !store.accountCanAccess(flow.owner, one.repo));
+    if (owners !== undefined)
+        return `Zone ${owners.title}: ${flow.owner}, who owns this flow, can't file work in that project.`;
+    const editors = elsewhere.find(one => !store.accountCanAccess(editor, one.repo));
+    return editors === undefined ? null : `Zone ${editors.title}: you can't file work in that project, so you can't point a build there.`;
+}
 const zoneWords = (title) => `${title}${/[.?!]$/.test(title) ? "" : "."}`;
 /** A card's words, checked once for every door: a title, an optional description, and no keys, because cards become agent instructions. */
 export function flowCardText(title, description) {
@@ -411,6 +450,25 @@ export function draftFor(definition, stage) {
         // A teammate's zone that leads here (by its next, or one of its answers) wrote the draft this decision checks (starter kits).
         ?? definition.stages.find(one => one.kind === "teammate" && (one.next === stage.id || (one.routes ?? []).some(route => route.to === stage.id))) ?? null;
 }
+/** Back to a build zone with a finished result: a revision of that same work, carrying the note; null when it isn't one. */
+export function revisionWithNote(store, card, target, note, actor, repos, evidenceRoot, now) {
+    if (target?.kind !== "task" || card.primaryTask === null || evidenceRoot === undefined)
+        return null;
+    // The build's own project (a zone may build in another) must be one the person can reach.
+    const repo = store.lookupRef(card.primaryTask)?.repo ?? null;
+    if (repo !== null && !repos.includes(repo))
+        return null;
+    const snapshot = assignmentOf(store, card.primaryTask, now, { principal: "operator", repos });
+    const runId = snapshot?.receipt?.runId;
+    const runTask = runId === undefined ? null : store.externalIdFor(store.getRun(runId)?.taskRef ?? -1);
+    if (runId === undefined || runTask === null)
+        return null;
+    const revised = requestResultChanges(store, evidenceRoot, {
+        run: runId, source: revisionSourceOf(store.getScope(runTask)?.digest ?? null), actor, repos,
+        batch: "", note, path: "", line: "", request: `flow-${card.id}-${card.entry}`, allowMode: true,
+    }, now);
+    return revised.ok ? revised.id : null;
+}
 export function decideFlowCard(store, input, now) {
     const card = store.getFlowCard(input.card);
     const flow = card === null ? null : store.getFlow(card.flow);
@@ -449,21 +507,7 @@ export function decideFlowCard(store, input, now) {
     if (input.note === null || input.note.trim() === "")
         return { ok: false, message: "Say what should change." };
     const target = definition.stages.find(one => one.id === stage.onFail);
-    // Back to a build zone with a finished result: a revision of that same work, carrying the note.
-    let revision = null;
-    if (target?.kind === "task" && card.primaryTask !== null && input.evidenceRoot !== undefined) {
-        const snapshot = assignmentOf(store, card.primaryTask, now, { principal: "operator", repos: input.repos });
-        const runId = snapshot?.receipt?.runId;
-        const runTask = runId === undefined ? null : store.externalIdFor(store.getRun(runId)?.taskRef ?? -1);
-        if (runId !== undefined && runTask !== null) {
-            const revised = requestResultChanges(store, input.evidenceRoot, {
-                run: runId, source: revisionSourceOf(store.getScope(runTask)?.digest ?? null), actor: input.actor, repos: input.repos,
-                batch: "", note: input.note.trim(), path: "", line: "", request: `flow-${card.id}-${card.entry}`, allowMode: true,
-            }, now);
-            if (revised.ok)
-                revision = revised.id;
-        }
-    }
+    const revision = revisionWithNote(store, card, target, input.note.trim(), input.actor, input.repos, input.evidenceRoot, now);
     store.moveFlowCard(card.id, { to: stage.onFail, outcome: "sent-back", actor: input.actor, note: input.note.trim(), ...(revision === null ? {} : { task: revision }), expectEntry: card.entry }, now);
     if (card.owner !== null)
         notifyPeople(store, card, [card.owner], input.actor, { key: `sent-back:${card.entry}`, subject: `${input.actor} sent “${card.title}” back`, body: `Sent back to ${target?.title ?? stage.onFail}:\n\n${input.note.trim()}`, attention: true }, now);

package/dist/flow-gallery-ui.d.ts

@@ -4,7 +4,7 @@
  * needs, previews in plain words what it will do and never do, and creates it — the same answers it previewed.
  */
 import { type GalleryAnswers, type GalleryPreview, type GalleryTemplate } from "./flow-gallery.js";
-import type { FlowDefinition } from "./flows.js";
+import { type FlowDefinition } from "./flows.js";
 export declare const GALLERY_CSS: string;
 /** A small drawing of a flow's zones where they sit on its canvas, with its paths; a person's decisions stand out. */
 export declare function zonesDiagram(definition: FlowDefinition, label: string): string;