toolroll 0.9.19 → 0.9.21

package/dist/mate-tools.js

@@ -46,6 +46,7 @@ import { agentsSummary, chosenWords, isRiskLevel, PHASES, postureWords, RISK_CHO
 import { TOOL_CATALOG, discoverTools, projectToolsOf, secretsSetFor, toolCommandLine, toolStanding } from "./project-tools.js";
 import { deciderOf, durationWords, FLOW_KIND_WORDS, FLOW_STAGE_KINDS, FLOW_TEMPLATES, flowFromSteps, stepsFor } from "./flows.js";
 import { flowDefinitionOf } from "./flow-engine.js";
+import { flowPersonOf } from "./flow-send.js";
 import { flowInsights } from "./flow-insights.js";
 import { describeTrigger, FLOW_TRIGGER_KINDS, triggerConfigOf } from "./flow-triggers.js";
 export const MATE_MAX_PROPOSALS_PER_TURN = 5;
@@ -796,8 +797,11 @@ export const MATE_TOOLS = [
         inputSchema: schema({ repo: REPO_ARG, flow: { type: "integer", minimum: 1 }, card: { type: "integer", minimum: 1 } }),
         handle: (ctx, args) => {
             const reachable = (repo) => ctx.who.repos.includes(repo) && ctx.store.accountCanAccess(ctx.who.name, repo);
-            const needsYou = (flow, definition, stage) => {
-                const at = definition?.stages.find(one => one.id === stage);
+            const needsYou = (flow, definition, card) => {
+                const at = definition?.stages.find(one => one.id === card.stage);
+                // A "Person chooses" zone waits for the card's person; a "Person decides" one for its decider.
+                if (at?.kind === "choose")
+                    return flowPersonOf(card, flow) === ctx.who.name;
                 if (at?.kind !== "approval")
                     return false;
                 const decider = deciderOf(at, flow);
@@ -832,15 +836,19 @@ export const MATE_TOOLS = [
                             ...(stage.merge === undefined ? {} : { merge: stage.merge }),
                             ...(stage.teammate === undefined ? {} : { teammate: stage.teammate }),
                             ...(stage.kind === "teammate" && stage.routes !== undefined ? { routes: stage.routes.map(one => ({ answer: one.answer, goesTo: titleOf(one.to) })) } : {}),
+                            ...(stage.kind === "choose" ? { options: (stage.options ?? []).map((one, index) => ({ choice: index + 1, label: one.label, goesTo: one.to === "end" ? "end" : titleOf(one.to) })) } : {}),
+                            ...(stage.kind === "task" && stage.repo !== undefined ? { repo: repoIdOf(ctx.who, stage.repo) ?? "another project" } : {}),
                             ...(stage.limit === undefined ? {} : { remindAfter: durationWords(stage.limit.minutes), ...(stage.limit.to === null ? {} : { thenMoveTo: titleOf(stage.limit.to) }) }),
-                            next: titleOf(stage.next), ...(stage.kind === "sort" ? { ifNotSure: titleOf(stage.onFail) } : stage.kind === "wait" ? { ifNoReply: titleOf(stage.onFail) } : { ifFails: titleOf(stage.onFail) }),
+                            next: titleOf(stage.next), ...(stage.kind === "sort" ? { ifNotSure: titleOf(stage.onFail) } : stage.kind === "wait" ? { ifNoReply: titleOf(stage.onFail) } : stage.kind === "choose" ? { ifReplied: titleOf(stage.onFail) } : { ifFails: titleOf(stage.onFail) }),
                         })),
                         cards: [...active, ...finished].map(card => ({
                             card: card.id, title: card.title, ...(card.description === null ? {} : { description: card.description.slice(0, 300) }),
-                            at: titleOf(card.stage) ?? card.stage, state: card.state, needsYou: card.state === "active" && needsYou(flow, definition, card.stage),
+                            at: titleOf(card.stage) ?? card.stage, state: card.state, needsYou: card.state === "active" && needsYou(flow, definition, card),
                             // Names never reach the model; a decision says whose it is in its own terms.
-                            waiting: card.state !== "active" || definition.stages.find(one => one.id === card.stage)?.kind !== "approval" || card.waiting === null ? card.waiting
-                                : needsYou(flow, definition, card.stage) ? "Waiting for you to approve or send it back" : "Waiting for someone else to decide",
+                            waiting: card.state === "active" && definition.stages.find(one => one.id === card.stage)?.kind === "choose" && card.waiting !== null
+                                ? (flowPersonOf(card, flow) === ctx.who.name ? "Waiting for you to choose (operation choose: choice by number, or note to reply)" : "Waiting for someone else to choose")
+                                : card.state !== "active" || definition.stages.find(one => one.id === card.stage)?.kind !== "approval" || card.waiting === null ? card.waiting
+                                    : needsYou(flow, definition, card) ? "Waiting for you to approve or send it back" : "Waiting for someone else to decide",
                             task: card.task ?? card.primaryTask, ...(card.note === null ? {} : { lastNote: card.note.slice(0, 300) }),
                             // Names never reach the model: people read as you or a teammate.
                             owner: card.owner === null ? null : card.owner === ctx.who.name ? "you" : "a teammate", following: ctx.store.flowCardWatchers(card.id).includes(ctx.who.name),
@@ -867,7 +875,7 @@ export const MATE_TOOLS = [
                         const definition = flowDefinitionOf(flow);
                         const cards = ctx.store.flowCards(flow.id, false);
                         return { flow: flow.id, name: flow.name, project: repoIdOf(ctx.who, flow.repo), steps: definition === null ? "can't be read" : definition.stages.map(one => one.title).join(" → "),
-                            cards: cards.length, needYou: cards.filter(card => needsYou(flow, definition, card.stage)).length, triggers: ctx.store.flowTriggers(flow.id).length };
+                            cards: cards.length, needYou: cards.filter(card => needsYou(flow, definition, card)).length, triggers: ctx.store.flowTriggers(flow.id).length };
                     }),
                     templates: FLOW_TEMPLATES.map(one => ({ template: one.id, about: one.about })),
                     // Scripts belong to a project, not a flow: they exist (and can be saved) before any flow does.
@@ -878,9 +886,9 @@ export const MATE_TOOLS = [
     },
     {
         name: "propose_flow",
-        description: "Draft a flow change as a card the operator confirms. To make a flow, create with a template or the steps in plain names; leave instructions out unless the operator gave them, and use decider 'me' when they decide. To change one, edit with the whole step list, keeping existing steps by id. For cards use add_card, move_card, approve, send_back with the operator's note, or cancel_card; find the card by what it is about; comment (with @name to ping someone), assign and follow here too. For triage, spam, lead, effort or exception routing, start from the matching template, with the sort as the first step. Use remindAfter and thenMoveTo for follow-ups and decisions that stall. The Issues to PRs template runs GitHub issues labelled toolroll through build, approval, pull request and a comment on the issue. When the operator asks for something to happen every time (fix CI when it fails, turn labelled issues into tasks, queue work overnight, review what went wrong every morning), offer the matching starter; each is one yes, and none merges without a person. When someone new wants a support desk, bug triage, sales follow-up or requests handled, a kit sets up the teammate and its flow in one card. Teammates: propose_teammate adds one (from a template: support, sales, ops, triage), changes one rule section (edit_section), pauses, resumes or removes it, passes it a note, or answers its question for the operator; put it to work with a flow here. When the operator says something like 'Maya can approve refunds up to $100 now', change that section of her soul file; when it's for this week or a one-off, pass it as a note. Teammates use the project's tools under a rule per action (do it, ask first: the operator approves each exact call, never, or up to a limit on a number); propose_teammate use_tool, stop_tool and tool_rule change them, and when a rule has a limit also change the soul file so its words agree. forget or edit_memory when the operator says a teammate has something wrong; a rule change it suggests is a question for the operator, answered only as they say. propose_teammate add_routine puts a card on its desk on a schedule; propose_teammate undo undoes a tool call only when its action has an undo set (tool_rule undoWith). Actions: starter: switch on a starter flow in a project (repo, starter: ci-fix files a fix task when CI fails on the main branch, issue-task makes a task of each GitHub issue labelled toolroll, overnight holds cards added in the day until 22:00 and leaves results for the morning, plane-review reviews the plane's last 24 hours every morning and turns each problem worth fixing into a researched fix and a pull request) — its zones and trigger in one card; offer the matching one when the operator says to do something every time. kit: set up a starter kit in a project (repo, kit: support-desk, bug-triage, sales-follow-up or ops-requests) — a teammate, the flow it works and its buttons, in one card; prefer it when the operator wants a support desk, bug triage, sales follow-up or requests handled. create: a template, or the steps in order (each leads to the next; Done is added; instructions may be left out). 'request' calls a web address (method, url with its host written out, headers — {{secret.NAME}} uses a secret the operator saved on the step, never in chat — and body); 'email' sends mail (to, subject, body; {{card.email}} is the card's email address); 'tool' calls one of the project's tools (server: the tool's name from get_project_tools, tool: its function, args: an object). Put a decision before any of these when they send what a model wrote or what an outsider sent. A 'draft' step has Claude write something from the card (instructions: what to write); follow it with an approval step (decider 'owner' asks the flow's owner in their chat app, where they can approve, edit or send it back), then an 'update' or 'notify' step whose message is '{{stage.<draft id>}}'. A 'sort' step has Jev pick one of its answers; make it the first step (never a holding step before it, or new cards wait unsorted): question, answers (answer, means: a few words Jev reads, goesTo: a step), sureAt (percent, default 80), ifNotSure (a step; otherwise the card waits for a person), and up to 3 alsoNote (score with levels lowest first, or yes-no); a sort has no next, so give each branch's last step its own next. A 'pull-request' step opens a pull request for the card's built result and waits for CI: next when it passes, ifFails when it fails (only this step defaults it: to the build before it, as a revision carrying the failing check); merge ('squash', 'merge' or 'rebase') merges once checks pass, and needs an approval step before it on every path. waitFor 'hours' with from and until (like '22:00' and '06:00') holds cards until the clock is inside those hours. A 'wait' step, after an 'email' step, waits for a reply to that email from someone it went to (waitFor 'reply', the default): next is where a reply goes (the reply is {{stage.<wait id>}}), ifNoReply where the card goes when none comes within wait (like '3 days', up to 30 days); waitFor 'time' just waits, then next. Any step but wait and done can have remindAfter (like '2 days': whoever it waits on is reminded once; 'none' removes it) and, on holding and approval steps, thenMoveTo (a step the card moves to then). AI teammates (get_teammates): an approval step with teammate (its short name) is decided by that teammate within its rules, and it hands hard ones to the step's decider; a 'teammate' step (teammate, instructions, routes of answer and goesTo) has it read the card, pick where it goes and write what the next steps send (the email body is then {{stage.<id>}}), asking the flow's owner when its rules say to. edit: the full step list, keeping existing steps by id — what a kept step leaves out carries over. add_card (starts in the first zone unless zone is named), move_card, approve, send_back (needs a note), cancel_card, comment (note; @name pings that person), assign (owner: a name, 'me', or 'nobody'), follow, unfollow, save_script (repo, and script: name, about, language python|node|shell, and either body (short) or file (a path in the project, like scripts/enrich.py), and timeoutMinutes; scripts belong to the project, so no flow is needed; a 'check' step in any of its flows names it). A 'check' step runs its script with the card as JSON on stdin (and in $FLOW_INPUT); what it prints is its result for later steps ({{stage.<id>}}); runIn 'folder' (an empty folder: for scripts that work on data) or 'copy' (a copy of the card's work, after setup: for tests on code; the default); routes (answer, goesTo) that a last printed line 'goto: <answer>' picks; ifFails is where a failing script sends the card, such as back to the build (it has no default: without it the card waits there); secrets (names of saved secrets it gets as variables). add_trigger with settings (kind button: label, questions; schedule: schedule like 'daily 09:00 Europe/London', and title, or script (a saved script whose printed items — one per line, a title or JSON with title, description, key — each become a card, once) with secrets; github: repo owner/name, watch issues|pulls|checks, label, branch, from team|anyone; linear: team, state, label; flow: follow (another flow's id), when (its zone); email: folder (default INBOX), sender (addresses or domains), subject (words it must contain); plane-review: at (HH:MM, default 07:30), timeZone — every day it reads the plane's last 24 hours and makes one card per problem worth fixing, a returning problem joining its card); pause_trigger, resume_trigger, remove_trigger with trigger. Read get_flows first except to create.",
+        description: "Draft a flow change as a card the operator confirms. To make a flow, create with a template or the steps in plain names; leave instructions out unless the operator gave them, and use decider 'me' when they decide. To change one, edit with the whole step list, keeping existing steps by id. For cards use add_card, move_card, approve, send_back with the operator's note, or cancel_card; find the card by what it is about; comment (with @name to ping someone), assign and follow here too. For triage, spam, lead, effort or exception routing, start from the matching template, with the sort as the first step. Use remindAfter and thenMoveTo for follow-ups and decisions that stall. The Issues to PRs template runs GitHub issues labelled toolroll through build, approval, pull request and a comment on the issue. When the operator asks for something to happen every time (fix CI when it fails, turn labelled issues into tasks, queue work overnight, review what went wrong every morning), offer the matching starter; each is one yes, and none merges without a person. When someone new wants a support desk, bug triage, sales follow-up or requests handled, a kit sets up the teammate and its flow in one card. Teammates: propose_teammate adds one (from a template: support, sales, ops, triage), changes one rule section (edit_section), pauses, resumes or removes it, passes it a note, or answers its question for the operator; put it to work with a flow here. When the operator says something like 'Maya can approve refunds up to $100 now', change that section of her soul file; when it's for this week or a one-off, pass it as a note. Teammates use the project's tools under a rule per action (do it, ask first: the operator approves each exact call, never, or up to a limit on a number); propose_teammate use_tool, stop_tool and tool_rule change them, and when a rule has a limit also change the soul file so its words agree. forget or edit_memory when the operator says a teammate has something wrong; a rule change it suggests is a question for the operator, answered only as they say. propose_teammate add_routine puts a card on its desk on a schedule; propose_teammate undo undoes a tool call only when its action has an undo set (tool_rule undoWith). Actions: starter: switch on a starter flow in a project (repo, starter: ci-fix files a fix task when CI fails on the main branch, issue-task makes a task of each GitHub issue labelled toolroll, overnight holds cards added in the day until 22:00 and leaves results for the morning, plane-review reviews the plane's last 24 hours every morning and turns each problem worth fixing into a researched fix and a pull request) — its zones and trigger in one card; offer the matching one when the operator says to do something every time. kit: set up a starter kit in a project (repo, kit: support-desk, bug-triage, sales-follow-up or ops-requests) — a teammate, the flow it works and its buttons, in one card; prefer it when the operator wants a support desk, bug triage, sales follow-up or requests handled. create: a template, or the steps in order (each leads to the next; Done is added; instructions may be left out). 'request' calls a web address (method, url with its host written out, headers — {{secret.NAME}} uses a secret the operator saved on the step, never in chat — and body); 'email' sends mail (to, subject, body; {{card.email}} is the card's email address); 'tool' calls one of the project's tools (server: the tool's name from get_project_tools, tool: its function, args: an object). Put a decision before any of these when they send what a model wrote or what an outsider sent. A 'draft' step has Claude write something from the card (instructions: what to write); follow it with an approval step (decider 'owner' asks the flow's owner in their chat app, where they can approve, edit or send it back), then an 'update' or 'notify' step whose message is '{{stage.<draft id>}}'. A 'sort' step has Jev pick one of its answers; make it the first step (never a holding step before it, or new cards wait unsorted): question, answers (answer, means: a few words Jev reads, goesTo: a step), sureAt (percent, default 80), ifNotSure (a step; otherwise the card waits for a person), and up to 3 alsoNote (score with levels lowest first, or yes-no); a sort has no next, so give each branch's last step its own next. A 'pull-request' step opens a pull request for the card's built result and waits for CI: next when it passes, ifFails when it fails (only this step defaults it: to the build before it, as a revision carrying the failing check); merge ('squash', 'merge' or 'rebase') merges once checks pass, and needs an approval step before it on every path. waitFor 'hours' with from and until (like '22:00' and '06:00') holds cards until the clock is inside those hours. A 'wait' step, after an 'email' step, waits for a reply to that email from someone it went to (waitFor 'reply', the default): next is where a reply goes (the reply is {{stage.<wait id>}}), ifNoReply where the card goes when none comes within wait (like '3 days', up to 30 days); waitFor 'time' just waits, then next. Any step but wait and done can have remindAfter (like '2 days': whoever it waits on is reminded once; 'none' removes it) and, on holding and approval steps, thenMoveTo (a step the card moves to then). AI teammates (get_teammates): an approval step with teammate (its short name) is decided by that teammate within its rules, and it hands hard ones to the step's decider; a 'teammate' step (teammate, instructions, routes of answer and goesTo) has it read the card, pick where it goes and write what the next steps send (the email body is then {{stage.<id>}}), asking the flow's owner when its rules say to. edit: the full step list, keeping existing steps by id — what a kept step leaves out carries over. add_card (starts in the first zone unless zone is named), move_card, approve, send_back (needs a note), cancel_card, comment (note; @name pings that person), assign (owner: a name, 'me', or 'nobody'), follow, unfollow, save_script (repo, and script: name, about, language python|node|shell, and either body (short) or file (a path in the project, like scripts/enrich.py), and timeoutMinutes; scripts belong to the project, so no flow is needed; a 'check' step in any of its flows names it). A 'check' step runs its script with the card as JSON on stdin (and in $FLOW_INPUT); what it prints is its result for later steps ({{stage.<id>}}); runIn 'folder' (an empty folder: for scripts that work on data) or 'copy' (a copy of the card's work, after setup: for tests on code; the default); routes (answer, goesTo) that a last printed line 'goto: <answer>' picks; ifFails is where a failing script sends the card, such as back to the build (it has no default: without it the card waits there); secrets (names of saved secrets it gets as variables). add_trigger with settings (kind button: label, questions; schedule: schedule like 'daily 09:00 Europe/London', and title, or script (a saved script whose printed items — one per line, a title or JSON with title, description, key — each become a card, once) with secrets; github: repo owner/name, watch issues|pulls|checks, label, branch, from team|anyone; linear: team, state, label; flow: follow (another flow's id), when (its zone); email: folder (default INBOX), sender (addresses or domains), subject (words it must contain); plane-review: at (HH:MM, default 07:30), timeZone — every day it reads the plane's last 24 hours and makes one card per problem worth fixing, a returning problem joining its card); pause_trigger, resume_trigger, remove_trigger with trigger. A 'send' step ('Send to me') sends the card's owner what the step before produced (summary, links, screenshots) in their chat apps, then moves on; a 'choose' step sends the same with 2 to 4 options (label, goesTo: a step, or 'end' to ignore the card) as buttons, ifReplied (where a reply goes as {{note}}; the build before by default), and remindAfter with ifNoReply. choose (card, and choice by number or a note to reply) answers one for the operator. A 'task' step may build in another project: repo (from list_repos). Read get_flows first except to create.",
         inputSchema: schema({
-            operation: { type: "string", enum: ["create", "edit", "add_card", "move_card", "approve", "send_back", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter"] },
+            operation: { type: "string", enum: ["create", "edit", "add_card", "move_card", "approve", "send_back", "choose", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter"] },
             repo: REPO_ARG, flow: { type: "integer", minimum: 1 }, card: { type: "integer", minimum: 1 }, kit: { type: "string", enum: KITS.map(one => one.id) },
             starter: { type: "string", enum: [...STARTER_IDS] },
             name: { type: "string", maxLength: 80 }, template: { type: "string", enum: FLOW_TEMPLATES.map(one => one.id) },
@@ -901,9 +909,12 @@ export const MATE_TOOLS = [
                         waitFor: { type: "string", enum: ["reply", "time", "hours"] }, wait: { type: "string", maxLength: 40 }, ifNoReply: { type: "string", maxLength: 60 },
                         from: { type: "string", maxLength: 5 }, until: { type: "string", maxLength: 5 }, merge: { type: "string", enum: ["squash", "merge", "rebase"] },
                         remindAfter: { type: "string", maxLength: 40 }, thenMoveTo: { type: "string", maxLength: 60 }, teammate: { type: "string", maxLength: 40 },
+                        options: { type: "array", minItems: 2, maxItems: 4, items: { type: "object", additionalProperties: false, properties: { label: { type: "string", maxLength: 40 }, goesTo: { type: "string", maxLength: 60 } } } },
+                        ifReplied: { type: "string", maxLength: 60 }, repo: REPO_ARG,
                         next: { type: "string", maxLength: 60 }, ifFails: { type: "string", maxLength: 60 }, ifNotSure: { type: "string", maxLength: 60 },
                     } } },
             title: { type: "string", maxLength: 200 }, description: { type: "string", maxLength: 4000 }, zone: { type: "string", maxLength: 60 }, note: { type: "string", maxLength: 2000 },
+            choice: { type: "integer", minimum: 1, maximum: 4 },
             trigger: { type: "integer", minimum: 1 }, owner: { type: "string", maxLength: 64 },
             script: { type: "object", additionalProperties: false, properties: { name: { type: "string", maxLength: 40 }, about: { type: "string", maxLength: 160 }, body: { type: "string", maxLength: 1600 }, timeoutMinutes: { type: "integer", minimum: 1, maximum: 60 },
                     language: { type: "string", enum: ["python", "node", "shell"] }, file: { type: "string", maxLength: 200 } } },
@@ -921,7 +932,15 @@ export const MATE_TOOLS = [
         handle: (ctx, args) => {
             const pick = (keys) => Object.fromEntries(keys.filter(key => args[key] !== undefined).map(key => [key, args[key]]));
             // "me" in a step means the operator; the drawing stores their name.
-            const steps = () => stepsFor(Array.isArray(args["steps"]) ? args["steps"] : [], ctx.who.name);
+            // A build step in another project names it as list_repos does (r2); the drawing keeps its path.
+            const steps = () => stepsFor(Array.isArray(args["steps"]) ? args["steps"] : [], ctx.who.name).map(step => {
+                if (step === null || typeof step !== "object" || step.repo === undefined)
+                    return step;
+                const path = repoPathOf(ctx.who, step.repo);
+                if (path === null)
+                    throw new Error("A build step's repo is a project from list_repos.");
+                return { ...step, repo: path };
+            });
             const flowOf = () => {
                 const flow = Number.isSafeInteger(args["flow"]) ? ctx.store.getFlow(Number(args["flow"])) : null;
                 return flow !== null && ctx.who.repos.includes(flow.repo) ? flow : null;
@@ -988,6 +1007,10 @@ export const MATE_TOOLS = [
                         operation = "flow_card_send_back";
                         input = pick(["card", "note"]);
                         break;
+                    case "choose":
+                        operation = "flow_card_choose";
+                        input = pick(["card", "choice", "note"]);
+                        break;
                     case "cancel_card":
                         operation = "flow_card_cancel";
                         input = pick(["card"]);

package/dist/operate.js

@@ -180,6 +180,7 @@ import { isDirectChatProvider, isSubscriptionChatProvider, priceOf, PRICED_MODEL
 import { resolvePhaseAgent, resolveScopeProfile, resolveScopeChain, resolveRouteCandidates, routeOfTask, INSTALLATION_SCOPE } from "./agentconfig.js";
 import { isRiskLevel, legOf, projectRoute, riskConsequence, routeDigestOf, routeWords, RISK_LEVELS, PHASES as ROUTE_PHASES } from "./phase-routing.js";
 import { observeProviderReadiness, reportProviderReadinessAuthed } from "./runner.js";
+import { parseDemoUrl, projectDemoUrl, saveProjectDemo } from "./project-demo.js";
 import { effectiveConcurrency, maySlotTake, parseProjectConcurrency, PROJECT_CONCURRENCY_DEFAULT, ProjectPasses, projectConcurrency, saveProjectConcurrency, savedProjectConcurrency } from "./project-concurrency.js";
 import { clearWebhook, effectivePrimary, isMessagingChannel, loadConsoleUrl, loadPrimary, loadWebhookTargets, phoneOrigin, saveConsoleUrl, savePrimary, saveWebhook, webhookPass, SLACK_ENV, DISCORD_ENV } from "./webhooks.js";
 import { auditOf, inspectionOf, isProviderId, MONEY_CAPABILITIES, PROVIDER_IDS, validModelId, validateSpec, ALL_CREDENTIAL_ENV } from "./provider.js";
@@ -233,6 +234,9 @@ export const OPERATE_HELP = `toolroll — operating the queue
   toolroll project concurrency [<n>] --repo <p>
                                         how many of a project's tasks build at once (default 2, never past the
                                         worker's capacity); an approver changes it with <n>
+  toolroll project demo [<url>|off] --repo <p>
+                                        the project's own demo or dev server, the one non-public address a
+                                        report's scout may screenshot
   toolroll task evidence <id>        the task's evidence pack as JSON (--html for a printable page; --out <file>)
   toolroll storage                   where the disk goes: database, build checkouts, releases, evidence, leftover test temp folders
   toolroll storage clean [--yes]     preview removing finished tasks' clean checkouts (their branches stay) and test temp folders older than a day; --yes removes them
@@ -971,6 +975,8 @@ async function dispatch(command, positional, flags, context) {
                 return projectDeleteCommand(positional, flags, context);
             if (positional[0] === "concurrency")
                 return projectConcurrencyCommand(positional, flags, context);
+            if (positional[0] === "demo")
+                return projectDemoCommand(positional, flags, context);
             return runProjectCommand(positional, flags, context);
         case "assignment":
             // The person's own lead (its lead token) claims as the lead; coordinator credentials keep their own path.
@@ -3465,6 +3471,7 @@ async function tickCommand(flags, context) {
                 onProviderSpawn: pid => { worktrees.recordProviderOccupancy(scoutLeased.worktree.path, runner, pid, scoutLeased.worktree.leaseEpoch); },
                 evidenceRoot: context.evidenceRoot,
                 answers: scoutAnswers,
+                demoUrl: projectDemoUrl(context.databaseFile, repo),
                 provider: spec.provider,
                 model: proof.effective.model,
                 ...(proof.effective.maxTurns === undefined ? {} : { maxTurns: proof.effective.maxTurns }),
@@ -12024,6 +12031,40 @@ async function projectConcurrencyCommand(positional, flags, context) {
         ...(changed.before > changed.after ? ["Builds already running carry on; the new number applies to the next one."] : []),
     ]);
 }
+/** `project demo [<url>|off] --repo <p>` (review 827): the project's own demo or dev server, which its scouts may
+ * screenshot. Changing it is an approver's act. */
+async function projectDemoCommand(positional, flags, context) {
+    const command = "project demo";
+    const allowed = new Set(["repo", "as", "token", "token-file", "token-env", "db", "json"]);
+    for (const name of flags.keys())
+        if (!allowed.has(name))
+            return fail(context.write, context.json, command, "usage", `--${name} is not a project demo option.`, EXIT.usage);
+    const repoFlag = text(flags, "repo");
+    if (positional.length > 2 || repoFlag === undefined)
+        return fail(context.write, context.json, command, "usage", "Use project demo [<url>|off] --repo <project path>.", EXIT.usage);
+    const registered = await loadRepos(registryPathOf(context)).catch(() => ({ error: "unreadable" }));
+    const known = [...new Set([...context.store.knownRepos(), ...("error" in registered ? [] : registered.repos)])];
+    const repo = known.find(one => one === repoFlag || one === resolve(repoFlag) || one === canonicalProject(repoFlag));
+    if (repo === undefined)
+        return fail(context.write, context.json, command, "not-found", "That isn't a project Toolroll knows.", EXIT.refused);
+    const words = (url) => url === null ? `${repo}: no demo; scouts screenshot public pages only.` : `${repo}: scouts may also screenshot ${url}.`;
+    const given = positional[1];
+    if (given === undefined) {
+        const current = projectDemoUrl(context.databaseFile, repo);
+        return succeed(context.write, context.json, command, { repo, demoUrl: current }, () => [words(current)]);
+    }
+    const url = given.trim().toLowerCase() === "off" ? null : parseDemoUrl(given);
+    if (url === null && given.trim().toLowerCase() !== "off")
+        return fail(context.write, context.json, command, "usage", "The demo is an http or https address without a sign-in, or off.", EXIT.usage);
+    const acting = await askCredentials(flags, context);
+    const verified = acting === null ? null : authenticateApprover(context.store, acting.name, acting.token);
+    if (acting === null || verified === null || !verified.ok || !context.store.accountCanAccess(acting.name, repo)) {
+        return fail(context.write, context.json, command, "refused", "An approver for this project sets its demo: pass --as and --token (or use the remembered login).", EXIT.refused);
+    }
+    const changed = saveProjectDemo(context.databaseFile, repo, url);
+    context.store.recordProjectDemo(acting.name, repo, changed.before, changed.after, context.clock());
+    return succeed(context.write, context.json, command, { repo, before: changed.before, demoUrl: changed.after }, () => [words(changed.after)]);
+}
 /** Write a pack or export where asked (never over an existing file), or to the terminal. */
 function writeOut(context, command, out, content, summary, line, data) {
     if (out === undefined) {

package/dist/plane-review.d.ts

@@ -11,6 +11,8 @@ export type PlaneProblem = {
     evidence: string[];
 };
 export declare const REVIEW_HOURS = 24;
+/** A person's wait this long is mentioned in the review's summary line. */
+export declare const LONG_WAIT_DAYS = 3;
 export declare const RUN_CAUSES: readonly ["provider", "sign-in", "check", "timeout", "no-handoff", "stuck-lease", "orphaned", "no-change", "other"];
 export type RunCause = (typeof RUN_CAUSES)[number];
 /** Anything shaped like a key is hidden; one short line. */
@@ -30,6 +32,19 @@ export declare function runCause(run: {
  * project counts only when every project may be seen).
  */
 export declare function reviewPlane(store: Store, now: Date, canSee?: (repo: string | null) => boolean): PlaneProblem[];
+/**
+ * Results nobody has opened, and tasks waiting on a person's answer, approval or hold, for over `LONG_WAIT_DAYS`
+ * before `now`. Counted for the review's summary line only; they are never problems.
+ */
+export declare function longPersonWaits(store: Store, now: Date, canSee?: (repo: string | null) => boolean): {
+    results: number;
+    tasks: number;
+};
+/** "3 results have waited over 3 days for you." — or null when nothing has. */
+export declare function longWaitWords(waits: {
+    results: number;
+    tasks: number;
+}): string | null;
 /** A problem as a card's details (or a day's note on a card it joins). */
 export declare function problemText(problem: PlaneProblem, day: string): string;
 /** The card's opening details: the day's evidence, and what it is. */

package/dist/plane-review.js

@@ -6,7 +6,9 @@
  * - failed or no-change runs, grouped by cause (provider error, sign-in
  *   expiry, check failure, timeout, quit without handoff, stuck lease,
  *   orphaned process, no change, other);
- * - tasks waiting on a person for over a day, grouped by what they wait for;
+ * - tasks stuck for over a day on something the system must fix (unfinished
+ *   work no worker holds, repeated failures, an incident hold), grouped by
+ *   what they wait for;
  * - sign-in and plan-limit pauses, per provider;
  * - chat replies that couldn't be delivered, per app;
  * - integrations that are Broken (integration_check);
@@ -17,6 +19,13 @@
  * problem (flow-triggers.ts joins it to its card), and carries counts, run
  * ids and short evidence excerpts with anything shaped like a secret hidden.
  * A clean day is no problems at all. Only projects the reader may see count.
+ *
+ * Waits only a person can end — a result to open, a question to answer, a
+ * plan or task to approve, a hold to lift, a scope to write — are never
+ * problems: each card starts a find-the-cause → fix → pull request flow, and
+ * no code change opens a result for someone. Needs you and chat already ask
+ * the person. `longPersonWaits` counts the ones over `LONG_WAIT_DAYS` so the
+ * review's own summary line can mention them once, filing nothing.
  */
 import { scanForSecrets } from "./evidence.js";
 import { scrubIntegrationText } from "./integrations.js";
@@ -24,8 +33,10 @@ import { taskWaitSnapshot } from "./lead-status.js";
 export const REVIEW_HOURS = 24;
 const EVIDENCE_LINES = 5;
 const WAITING_DAYS = 1;
-/** A Ready result older than this is history, not today's problem. */
-const READY_WINDOW_DAYS = 7;
+/** A person's wait this long is mentioned in the review's summary line. */
+export const LONG_WAIT_DAYS = 3;
+/** What a person, not the code, must do next (lead-status.ts `taskWaitSnapshot`). The rest have a system cause. */
+const PERSON_NEXT = new Set(["Open result", "Answer the task's question", "Answer question", "Remove hold", "Review plan", "Resume or close attempt", "Choose a result", "Approve plan", "Add scope", "Approve task"]);
 export const RUN_CAUSES = ["provider", "sign-in", "check", "timeout", "no-handoff", "stuck-lease", "orphaned", "no-change", "other"];
 const CAUSE_TITLES = {
     provider: "Runs failed on a provider error",
@@ -140,24 +151,12 @@ export function reviewPlane(store, now, canSee = () => true) {
         const run = Number(row["run"]);
         add("run/orphaned", CAUSE_TITLES.orphaned, ["run", "runs"], { run, evidence: `Run ${run} (task ${str(row["task"]) ?? "?"}): process ${str(row["pid"]) ?? "?"} on ${excerpt(str(row["host"]), 40)} was still running after it finished` });
     }
-    // Tasks waiting on a person for over a day, by what they wait for.
-    const waited = new Date(now.getTime() - WAITING_DAYS * 86_400_000).toISOString();
-    const readyFrom = new Date(now.getTime() - READY_WINDOW_DAYS * 86_400_000).toISOString();
-    const tasks = store.handle.prepare(`SELECT task.id, task.title, task.updated_at, ref.repo FROM task JOIN task_ref ref ON ref.backend = 'built-in' AND ref.external_id = task.id
-    WHERE task.updated_at <= ? AND (task.state IN ('queued', 'running') OR (task.state = 'done' AND task.updated_at >= ?)) ORDER BY task.updated_at LIMIT 500`).all(waited, readyFrom);
-    for (const row of tasks) {
-        if (!canSee(str(row["repo"])))
-            continue;
-        // A version a later revision replaced never waits on its own.
-        const family = store.taskFamilyOf(String(row["id"]), null, true);
-        if (family !== null && family.current.id !== String(row["id"]))
-            continue;
-        const snapshot = taskWaitSnapshot(store, String(row["id"]), now);
-        if (snapshot === null || (snapshot.reason !== "needs-person" && snapshot.reason !== "ready"))
+    // Tasks stuck for over a day on a system cause, by what they wait for. Waits on a person are never cards.
+    for (const wait of openWaits(store, new Date(now.getTime() - WAITING_DAYS * 86_400_000), now, canSee)) {
+        if (wait.person)
             continue;
-        const days = Math.floor((now.getTime() - Date.parse(String(row["updated_at"]))) / 86_400_000);
-        add(`waiting/${keyPart(snapshot.next)}`, `Tasks waited over a day: ${snapshot.next}`, ["task", "tasks"], { run: snapshot.run,
-            evidence: `Task ${String(row["id"])} “${excerpt(str(row["title"]), 80)}”: ${plural(days, "day")} waiting` });
+        add(`waiting/${keyPart(wait.next)}`, `Tasks waited over a day: ${wait.next}`, ["task", "tasks"], { run: wait.run,
+            evidence: `Task ${wait.id} “${excerpt(wait.title, 80)}”: ${plural(wait.days, "day")} waiting` });
     }
     // Sign-in and plan-limit pauses.
     if (tableExists(store, "provider_auth_pause")) {
@@ -227,6 +226,49 @@ export function reviewPlane(store, now, canSee = () => true) {
             summary: `${plural(bucket.count, bucket.noun[0], bucket.noun[1])} in the last ${REVIEW_HOURS} hours${runsList.length === 0 ? "" : ` (${runsList.length === 1 ? "run" : "runs"} ${runsList.slice(0, 12).join(", ")}${runsList.length > 12 ? ", …" : ""})`}.` };
     }).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
 }
+/** Queued or running tasks last touched by `before` that wait, and on what; replaced versions never wait on their own. */
+function openWaits(store, before, now, canSee) {
+    const rows = store.handle.prepare(`SELECT task.id, task.title, task.updated_at, ref.repo FROM task JOIN task_ref ref ON ref.backend = 'built-in' AND ref.external_id = task.id
+    WHERE task.updated_at <= ? AND task.state IN ('queued', 'running') ORDER BY task.updated_at LIMIT 500`).all(before.toISOString());
+    return waitsOf(store, rows, now, canSee);
+}
+function waitsOf(store, rows, now, canSee) {
+    const waits = [];
+    for (const row of rows) {
+        if (!canSee(str(row["repo"])))
+            continue;
+        const id = String(row["id"]);
+        const family = store.taskFamilyOf(id, null, true);
+        if (family !== null && family.current.id !== id)
+            continue;
+        const snapshot = taskWaitSnapshot(store, id, now);
+        if (snapshot === null || (snapshot.reason !== "needs-person" && snapshot.reason !== "ready"))
+            continue;
+        waits.push({ id, title: str(row["title"]), next: snapshot.next, run: snapshot.run, days: Math.floor((now.getTime() - Date.parse(String(row["updated_at"]))) / 86_400_000),
+            person: snapshot.reason === "ready" || PERSON_NEXT.has(snapshot.next) });
+    }
+    return waits;
+}
+/**
+ * Results nobody has opened, and tasks waiting on a person's answer, approval or hold, for over `LONG_WAIT_DAYS`
+ * before `now`. Counted for the review's summary line only; they are never problems.
+ */
+export function longPersonWaits(store, now, canSee = () => true) {
+    const before = new Date(now.getTime() - LONG_WAIT_DAYS * 86_400_000);
+    // Newest first, so years of Complete work never crowds out this week's unopened results.
+    const finished = store.handle.prepare(`SELECT task.id, task.title, task.updated_at, ref.repo FROM task JOIN task_ref ref ON ref.backend = 'built-in' AND ref.external_id = task.id
+    WHERE task.updated_at <= ? AND task.state = 'done' ORDER BY task.updated_at DESC LIMIT 500`).all(before.toISOString());
+    const results = waitsOf(store, finished, now, canSee).filter(wait => wait.person).length;
+    const tasks = openWaits(store, before, now, canSee).filter(wait => wait.person).length;
+    return { results, tasks };
+}
+/** "3 results have waited over 3 days for you." — or null when nothing has. */
+export function longWaitWords(waits) {
+    const parts = [waits.results > 0 ? plural(waits.results, "result") : null, waits.tasks > 0 ? plural(waits.tasks, "task") : null].filter(one => one !== null);
+    if (parts.length === 0)
+        return null;
+    return `${parts.join(" and ")} ${waits.results + waits.tasks === 1 ? "has" : "have"} waited over ${LONG_WAIT_DAYS} days for you.`;
+}
 /** A problem as a card's details (or a day's note on a card it joins). */
 export function problemText(problem, day) {
     return [`${day}: ${problem.summary}`, ...problem.evidence.map(line => `- ${line}`)].join("\n");

package/dist/project-delete.js

@@ -216,6 +216,8 @@ function deleteRows(store, repo, d, now) {
         del(`${surface}_action`, IN("proposal"), proposals);
         del(`${surface}_flow_action`, IN("card"), C);
         del(`${surface}_flow_prompt`, IN("card"), C);
+        del(`${surface}_flow_choice`, IN("card"), C);
+        del(`${surface}_flow_note`, IN("card"), C);
         del(`${surface}_question_action`, IN("question"), questions);
         del(`${surface}_question_prompt`, IN("question"), questions);
         del(`${surface}_ask_action`, IN("turn"), U);
@@ -226,6 +228,8 @@ function deleteRows(store, repo, d, now) {
     del("telegram_proposal_action", IN("proposal"), proposals);
     del("telegram_flow_action", IN("card"), C);
     del("telegram_flow_prompt", IN("card"), C);
+    del("telegram_flow_choice", IN("card"), C);
+    del("flow_send", IN("card"), C);
     del("telegram_question_action", IN("question"), questions);
     del("telegram_question_prompt", IN("question"), questions);
     del("chat_decide_action", IN("task_id"), K);

package/dist/project-demo.d.ts

@@ -0,0 +1,12 @@
+export declare const projectDemoPath: (databaseFile: string) => string;
+/** A demo URL as typed: an http(s) address with no sign-in details, at most 500 characters, or null. */
+export declare function parseDemoUrl(value: string): string | null;
+/** Every saved demo URL, by canonical project path. An unreadable file reads as none saved. */
+export declare function savedProjectDemos(databaseFile: string): Map<string, string>;
+/** The project's demo URL, or null when it has none. */
+export declare function projectDemoUrl(databaseFile: string, repo: string): string | null;
+/** Save (or, with null, clear) one project's demo URL atomically; returns it before and after. */
+export declare function saveProjectDemo(databaseFile: string, repo: string, url: string | null): {
+    before: string | null;
+    after: string | null;
+};

package/dist/project-demo.js

@@ -0,0 +1,71 @@
+/**
+ * A project's own demo or dev server (review 827): the one address a scout
+ * may reach that is not on the public internet, so it can take screenshots
+ * of the project's UI. An approver sets it with
+ * `toolroll project demo --repo <p> <url>|off`; it is kept in a small file
+ * beside the database, like a project's builds-at-once number, and recorded
+ * in the ledger as before → after. A project without one has none.
+ */
+import { lstatSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname, join } from "node:path";
+export const projectDemoPath = (databaseFile) => join(dirname(databaseFile), "project-demo.json");
+/** A demo URL as typed: an http(s) address with no sign-in details, at most 500 characters, or null. */
+export function parseDemoUrl(value) {
+    const typed = value.trim();
+    if (typed === "" || typed.length > 500)
+        return null;
+    try {
+        const url = new URL(typed);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return null;
+        if (url.username !== "" || url.password !== "")
+            return null;
+        return url.href;
+    }
+    catch {
+        return null;
+    }
+}
+/** Every saved demo URL, by canonical project path. An unreadable file reads as none saved. */
+export function savedProjectDemos(databaseFile) {
+    const saved = new Map();
+    const file = projectDemoPath(databaseFile);
+    try {
+        const stat = lstatSync(file, { throwIfNoEntry: false });
+        if (stat === undefined || !stat.isFile() || stat.size > 262_144)
+            return saved;
+        const value = JSON.parse(readFileSync(file, "utf8"));
+        const projects = value !== null && typeof value === "object" ? value.projects : undefined;
+        if (projects === null || typeof projects !== "object")
+            return saved;
+        for (const [repo, url] of Object.entries(projects)) {
+            const parsed = typeof url === "string" ? parseDemoUrl(url) : null;
+            if (parsed !== null)
+                saved.set(repo, parsed);
+        }
+    }
+    catch {
+        // A damaged file never stops a scout: it simply has no demo to open.
+    }
+    return saved;
+}
+/** The project's demo URL, or null when it has none. */
+export function projectDemoUrl(databaseFile, repo) {
+    return savedProjectDemos(databaseFile).get(repo) ?? null;
+}
+/** Save (or, with null, clear) one project's demo URL atomically; returns it before and after. */
+export function saveProjectDemo(databaseFile, repo, url) {
+    const saved = savedProjectDemos(databaseFile);
+    const before = saved.get(repo) ?? null;
+    if (url === null)
+        saved.delete(repo);
+    else
+        saved.set(repo, url);
+    const file = projectDemoPath(databaseFile);
+    const temp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(temp, `${JSON.stringify({ version: 1, projects: Object.fromEntries([...saved].sort(([a], [b]) => a.localeCompare(b))) }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    renameSync(temp, file);
+    return { before, after: url };
+}

package/dist/provider.d.ts

@@ -68,6 +68,16 @@ export type Invocation = {
      * Codex renders it as its own sandbox profile; Claude as deny rules for
      * its file tools (its shell is fenced by the macOS sandbox around it). */
     fence?: readonly string[];
+    /** Claude's structured-output floor for a non-review phase: the scout's
+     * report rides the terminal result event instead of a file plan mode
+     * would refuse to write. Ignored by providers without `--json-schema`. */
+    jsonSchema?: Readonly<Record<string, unknown>>;
+    /** Claude tools allowed without asking, for a `dontAsk` launch: the scout's
+     * research and screenshot tools, and nothing that edits or runs commands. */
+    allowedTools?: readonly string[];
+    /** More MCP servers for this launch only, beside the project's own (the
+     * scout's headless browser). Claude-only; ignored for a review. */
+    extraMcpServers?: Readonly<Record<string, unknown>>;
 };
 export type ProviderRunner = (file: string, args: readonly string[], options?: RunOptions) => Promise<ExecResult>;
 /** The harness's own account of how a turn ended. */
@@ -86,6 +96,10 @@ export type ParsedEnvelope = {
     protocolError: string | null;
     /** The agent's spoken conclusion — diagnostics only, never the handoff. */
     finalMessage: string | null;
+    /** Claude's schema-validated `structured_output` alone, re-serialized —
+     * never the prose result, even when that prose is JSON. Absent or null
+     * when the turn ran without `--json-schema` or returned none. */
+    structuredOutput?: string | null;
     /** How the harness said the turn ended (claude: the result's subtype and
      * turn count) — absent on dialects that carry no such record. */
     ending?: AgentEnding | null;

package/dist/provider.js

@@ -229,7 +229,11 @@ const claudeArgv = (invocation) => [
             // Headless (run 2085): a wakeup, cron job or monitor needs a later
             // turn that a -p process never gets. Denied at the harness too.
             "--disallowedTools", HEADLESS_DISALLOWED_TOOLS.join(","),
-            ...(invocation.toolArgv ?? []), ...(invocation.fence !== undefined && invocation.fence.length > 0 ? ["--settings", claudeFenceSettings(invocation.fence)] : [])
+            ...(invocation.allowedTools === undefined || invocation.allowedTools.length === 0 ? [] : ["--allowedTools", invocation.allowedTools.join(",")]),
+            ...(invocation.toolArgv ?? []),
+            ...(invocation.extraMcpServers === undefined ? [] : ["--mcp-config", JSON.stringify({ mcpServers: invocation.extraMcpServers })]),
+            ...(invocation.fence !== undefined && invocation.fence.length > 0 ? ["--settings", claudeFenceSettings(invocation.fence)] : []),
+            ...(invocation.jsonSchema === undefined ? [] : ["--json-schema", JSON.stringify(invocation.jsonSchema)])
         ]),
 ];
 /**
@@ -276,6 +280,9 @@ function claudeEnvelopeOf(result, sessionFromInit, initObserved, initSessionConf
                 ? "the Claude init event and terminal result announced different session ids"
                 : null,
         finalMessage: claudeFinalMessage(result),
+        structuredOutput: result === null || result.structured_output === undefined || result.structured_output === null
+            ? null
+            : JSON.stringify(result.structured_output),
         ending: result === null ? null : {
             subtype: typeof result.subtype === "string" ? result.subtype : null,
             turns: typeof result.num_turns === "number" && result.num_turns >= 0 ? result.num_turns : null,

package/dist/report-summary.d.ts

@@ -1,4 +1,5 @@
 import type { Store } from "./store.js";
+import type { ParsedReport } from "./scout-report.js";
 /** The report a scout delivered, for get_task: title, summary, follow-ups —
  * verified before it is read; the document itself stays on the task page. */
 export declare function reportSummaryFor(store: Store, evidenceRoot: string | undefined, taskRef: number): {
@@ -11,3 +12,11 @@ export declare function reportSummaryFor(store: Store, evidenceRoot: string | un
 } | {
     problem: string;
 } | null;
+/** The longest full report a later flow step is given through {{stage.<id>.report}}. */
+export declare const REPORT_FILL_LIMIT = 20000;
+/** What a report zone gives the zones after it besides its summary: its items as a numbered list (title, why, URL)
+ * and the report's markdown, capped. Empty strings when it has neither. */
+export declare function reportFillIns(report: Pick<ParsedReport, "items" | "report">): {
+    items: string;
+    report: string;
+};

package/dist/report-summary.js

@@ -13,3 +13,12 @@ export function reportSummaryFor(store, evidenceRoot, taskRef) {
         return { problem: view.problem };
     return { title: view.report.title, summary: view.report.summary, followUps: view.report.followUps };
 }
+/** The longest full report a later flow step is given through {{stage.<id>.report}}. */
+export const REPORT_FILL_LIMIT = 20_000;
+/** What a report zone gives the zones after it besides its summary: its items as a numbered list (title, why, URL)
+ * and the report's markdown, capped. Empty strings when it has neither. */
+export function reportFillIns(report) {
+    const items = report.items.map((one, index) => `${index + 1}. ${one.title}\n   ${one.why.replace(/\s*\n\s*/g, " ")}\n   ${one.url}`).join("\n");
+    const document = report.report.length <= REPORT_FILL_LIMIT ? report.report : `${report.report.slice(0, REPORT_FILL_LIMIT)}\n… (the rest of the report is on its task)`;
+    return { items, report: document };
+}

package/dist/result-shots.d.ts

@@ -39,6 +39,8 @@ export type ResultShotsPlan =
  * no wait in between, or asks again.
  */
 export declare function resultShotsFor(store: Store, evidenceRoot: string | undefined, repos: readonly string[], row: Pick<Notification, "kind" | "recipient" | "taskId" | "taskRef" | "run">, sent?: ReadonlySet<number>): ResultShotsPlan;
+/** A row that carries a result's screenshots: one a person asked for with results, or one a flow sends them. */
+export declare function isShotsKind(kind: string): boolean;
 /** A screenshot whose result message is not posted yet waits for that message's own next try (at least a second). */
 export declare function shotWaitsUntil(resultNextAt: unknown, now: Date): string;
 /** Retention removed this result's files: its screenshots go quietly, never as a complaint. */