toolroll 0.9.103 → 0.9.105

package/dist/flows-cli.js

@@ -1,12 +1,3 @@
-/** `toolroll flows …`: set up and inspect flows from a terminal, through the
- * same helpers the console and the lead's flow tool use — flowFromSteps,
- * FLOW_TEMPLATES, the starter flows, addFlowTriggerTo, saveScript and
- * addCardToFlow — so a flow made here is checked exactly as one drawn there.
- * Reads need no login; every write is an approver's, proved by --as/--token
- * (or the remembered login), and lands in the ledger as a console request
- * does. create, edit, archive, import and trigger add preview until --yes.
- * export writes a flow file (flow-share.ts); import reads one, from a path
- * or a gist/GitHub address, and previews it in plain words first. */
 import { readFileSync, statSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { envelopeJson } from './envelope.js';
@@ -76,7 +67,6 @@ export const FLOWS_DESCRIPTORS = [
             { name: 'digest', takesValue: true, meaning: "required with --yes: the approval digest the preview showed; refuses if the flow or its scripts changed since" }] },
     { action: 'archive', synopsis: 'archive a flow: its cards stop moving and its triggers stop; previews until --yes', mutation: 'identity-idempotent', positionals: ['flow'], flags: [...write, yes] },
 ];
-/** `--file` is a value here (a path in the project), where elsewhere it is a switch; so are unattended's `--budget`, `--runs` and `--include`. */
 export const FLOWS_VALUE_FLAGS = new Set(['file', 'param', 'budget', 'runs', 'include']);
 export async function runFlowsCommand(positional, flags, context) {
     const [first, second] = positional;
@@ -98,7 +88,6 @@ export async function runFlowsCommand(positional, flags, context) {
     const text = (key) => { const value = flags.get(key); return typeof value === 'string' ? value : null; };
     const readInput = context.readInput ?? ((path) => readFileSync(path === '-' ? 0 : resolve(path), 'utf8'));
     const { store } = context;
-    // ---- reads: what the installation holds, no login needed
     const projectOf = (given) => given === null ? null : context.projects.find(one => one === given || one === resolve(given)) ?? null;
     const flowOf = (value, repos) => {
         const flow = value !== undefined && /^[1-9][0-9]{0,9}$/.test(value) ? store.getFlow(Number(value)) : null;
@@ -146,7 +135,6 @@ export async function runFlowsCommand(positional, flags, context) {
         }
         return ok({ path: resolve(out), fileName: exported.fileName, left: exported.left }, [`Wrote ${flow.name} to ${resolve(out)}.`, ...left]);
     }
-    // ---- writes: an approver's, on a project they can reach
     if (context.credentials === null)
         return fail('unauthenticated', 'Changing a flow needs an approver: pass --as <you> --token <your password> (or sign in once with toolroll up).');
     const acting = context.credentials;
@@ -156,14 +144,10 @@ export async function runFlowsCommand(positional, flags, context) {
         return fail('unauthenticated', 'That name and password aren\'t an approver\'s. Nothing was changed.');
     const who = verified.who.name;
     const now = context.clock();
-    // Each write, taken or refused, is a line in the ledger, like a console request.
     const record = (project, outcome, detail = null) => {
         store.recordAction({ at: context.clock().toISOString(), actor: who, repo: project, taskId: null, runId: null, action: command, outcome, source: 'request', detail: `command line${detail === null ? '' : ` · ${detail}`}` });
     };
     const refuse = (project, reason, message, code = EXIT.refused) => { record(project, 'refused', reason); return fail(reason, message, code); };
-    // A trigger from anyone widens what comes in (chat-management.md §0a.3): only the person's own proof counts, never a
-    // machine credential standing in for them (a remote run's API token, a lead's token), though both pass the check above.
-    // The same proof approves browser use in a flow's script zones (flow-browser.ts): the method is recorded with it.
     const personMethod = (project) => {
         const proved = authenticateApprover(store, acting.name, acting.token, project);
         return proved.ok && personProof(proved.method) ? proved.method : null;
@@ -172,7 +156,7 @@ export async function runFlowsCommand(positional, flags, context) {
     const settle = (project) => { try {
         advanceFlows(store, project, context.clock(), { evidenceRoot: context.evidenceRoot });
     }
-    catch { /* the next worker pass retries */ } };
+    catch { } };
     const preview = (project, title, terms, extra) => ok({ applied: false, repo: project, title, terms, ...extra }, [title, ...terms.map(one => `  ${one.replace(/\n/g, '\n     ')}`), '', 'Nothing has changed. Add --yes to make this change.']);
     const readJson = (value, what) => {
         let raw;
@@ -203,7 +187,6 @@ export async function runFlowsCommand(positional, flags, context) {
         const name = (text('name') ?? '').replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 80);
         const starter = templateId === null ? null : starterOf(templateId);
         if (starter !== null) {
-            // A starter flow: its zones and its trigger, together, under its own name.
             if (name !== '' && name !== starter.name)
                 return fail('usage', `A starter flow keeps its name, ${starter.name}.`, EXIT.usage);
             if (starterFlowOf(store, starter, project) !== null)
@@ -260,7 +243,6 @@ export async function runFlowsCommand(positional, flags, context) {
             id = store.transact(() => {
                 const made = store.createFlow({ repo: project, name: flowName, definitionJson: JSON.stringify(definition), by: who }, now);
                 if (template?.trigger !== undefined) {
-                    // A trigger from anyone only on the person's own proof (widening above); a machine credential's is refused.
                     const trigger = addFlowTriggerTo(store, store.getFlow(made), template.trigger, who, now, context.configDir, proof);
                     if (!trigger.ok)
                         throw new Error(trigger.message);
@@ -323,7 +305,7 @@ export async function runFlowsCommand(positional, flags, context) {
                 try {
                     size = source === '-' ? 0 : statSync(resolve(source)).size;
                 }
-                catch { /* readInput says it can't be read */ }
+                catch { }
                 if (size > FLOW_FILE_MAX_BYTES)
                     throw new FlowFileError(`That file is too big: a flow file is at most ${FLOW_FILE_MAX_BYTES / 1024} KB.`);
                 try {
@@ -364,14 +346,12 @@ export async function runFlowsCommand(positional, flags, context) {
             return refuse(project, 'unknown-script', `There's no script called ${name} in ${projectName(project)}.`);
         if (script.held === null)
             return ok({ applied: false, repo: project, said: `${script.name} already runs.` }, [`${script.name} already runs.`]);
-        // Bound to the version just read: a script swapped under the same name meanwhile is refused, never approved unseen.
         if (store.approveFlowScript(project, script.name, { version: script.version, digest: script.digest }) !== 'approved')
             return refuse(project, 'changed', `${script.name} changed while this ran. Read it again (toolroll flows show), then approve it. Nothing was approved.`);
         record(project, 'accepted', `script ${script.name} v${script.version} approved`);
         settle(project);
         return ok({ applied: true, repo: project, said: `Approved ${script.name}. Zones that run it go on.` }, [`Approved ${script.name}. Zones that run it go on.`]);
     }
-    // Everything else names a flow in one of this person's projects.
     const flow = flowOf(args[0], reachable);
     if (flow === null)
         return refuse(null, 'unknown-flow', 'No such flow in your projects. toolroll flows list names them.');
@@ -384,7 +364,6 @@ export async function runFlowsCommand(positional, flags, context) {
         if (turn !== 'on' && turn !== 'off')
             return fail('usage', `Use flows unattended ${flow.id} on --days N, or flows unattended ${flow.id} off.`, EXIT.usage);
         if (turn === 'off') {
-            // Lowering authority is one step for any approver on the project.
             if (!revokeUnattended(store, flow.id, who, now))
                 return refuse(flow.repo, 'not-on', `${flow.name} isn't running on its own. Nothing was changed.`);
             record(flow.repo, 'accepted', `flow #${flow.id} off`);
@@ -411,7 +390,6 @@ export async function runFlowsCommand(positional, flags, context) {
         if (turn !== 'on' && turn !== 'off')
             return fail('usage', `Use flows browser ${flow.id} on, or flows browser ${flow.id} off.`, EXIT.usage);
         if (turn === 'off') {
-            // Lowering authority is one step for any approver on the project.
             if (!revokeFlowBrowser(store, flow.id, who, now))
                 return refuse(flow.repo, 'not-on', `${flow.name} has no approved browser use. Nothing was changed.`);
             record(flow.repo, 'accepted', `flow #${flow.id} browser off`);
@@ -426,8 +404,6 @@ export async function runFlowsCommand(positional, flags, context) {
         const digest = browserApprovalDigest(terms);
         if (!flags.has('yes'))
             return preview(flow.repo, `Approve browser use in the ${flow.name} flow`, [...browserTerms(terms.zones), `Approval digest ${digest}: approve exactly this with --yes --digest ${digest}.`], { flowId: flow.id, digest, zones: terms.zones });
-        // A person's own proof only: a lead's or remote run's token passes the approver check above but never approves this.
-        // The digest the person read is required: approving with --yes alone could approve something they never saw.
         const given = text('digest');
         if (given === null)
             return fail('usage', `Approve exactly what you read: flows browser ${flow.id} on --yes --digest <the digest the preview showed>.`, EXIT.usage);
@@ -501,7 +477,6 @@ export async function runFlowsCommand(positional, flags, context) {
         return ok({ applied: true, card: card === null ? { id: added.card } : cardOf(definition, card), said: added.said }, [`${added.said} Card #${added.card}.`]);
     }
     if (action === 'card approve' || action === 'card send-back') {
-        // The console's own doors (decideFlowCard, chooseFlowCard): the same decider, visit and project checks, and the same card history.
         const approving = action === 'card approve';
         const note = text('note')?.trim() ?? null;
         if (args[1] === undefined || (!approving && (note === null || note === '')))
@@ -555,25 +530,20 @@ export async function runFlowsCommand(positional, flags, context) {
             const zone = definition.stages.find(one => one.id === (config.zone ?? definition.start))?.title ?? 'the first zone';
             return preview(flow.repo, `Add a trigger to ${flow.name}`, [words, `Cards start in ${zone}.`, 'Work a card starts still waits for your usual approvals.'], { flowId: flow.id, trigger: config });
         }
-        // A trigger that takes deliveries mints an address: a credential act, a password typed for this command (never the
-        // remembered login under Passwordless) (docs/plans/passwordless.md).
         const ingress = rawTakesDeliveries(input.value);
         if (ingress && !proveCredential(store, acting.name, acting.token).ok)
             return refuse(flow.repo, 'unauthenticated', 'Making a webhook address takes your password, typed: pass --token.');
-        // A trigger from anyone only on the person's own proof (widening above): a machine credential's is refused.
         const made = addFlowTriggerTo(store, flow, input.value, who, now, context.configDir, ingress ? { ingress: 'proved' } : widening(flow.repo));
         if (!made.ok)
             return refuse(flow.repo, 'invalid-trigger', made.message);
         await prepareUnattendedCandidates(store, flow.id);
         record(flow.repo, 'accepted', `flow #${flow.id} trigger #${made.id}`);
         settle(flow.repo);
-        // A webhook's address (and GitHub's signing secret) is shown this once, never stored readable.
         return ok({ applied: true, triggerId: made.id, said: made.said, ...(made.reveal === null ? {} : { reveal: made.reveal }) }, [
             `${made.said} Trigger #${made.id}: ${words}`,
             ...(made.reveal === null ? [] : [`  address: ${made.reveal.address ?? `<your public address>${made.reveal.path}`}`, ...(made.reveal.secret === null ? [] : [`  signing secret: ${made.reveal.secret}`])]),
         ]);
     }
-    // trigger pause | resume | remove | check <flow> <trigger>
     const trigger = args[1] !== undefined && /^[1-9][0-9]{0,9}$/.test(args[1]) ? store.getFlowTrigger(Number(args[1])) : null;
     if (trigger === null || trigger.flow !== flow.id || trigger.state === 'removed')
         return refuse(flow.repo, 'unknown-trigger', 'That trigger isn\'t on this flow. toolroll flows show <flow> names them.');
@@ -599,7 +569,6 @@ function listed(store, flow) {
         triggers: store.flowTriggers(flow.id).filter(one => one.state === 'active').length, cardsWaiting: cards.length,
         needDecision: cards.filter(card => ['approval', 'choose'].includes(definition?.stages.find(one => one.id === card.stage)?.kind ?? '')).length };
 }
-/** One zone and every path out of it, by zone id. */
 function zoneOf(stage, flow) {
     return {
         id: stage.id, title: stage.title, kind: stage.kind, does: FLOW_KIND_WORDS[stage.kind].label,
@@ -633,13 +602,10 @@ function describeFlow(store, flow, now) {
         }),
         cards: store.flowCards(flow.id, true).slice(0, 10).map(card => cardOf(definition, card)),
         unattended: unattendedJson(store, flow, now),
-        // The latest grant a change ended early (the flow, a script, a schedule): why and when, as the flow page says it.
         ...(() => { const ended = unattendedViewOf(store, flow, { name: flow.owner, approver: true }, now).ended; return ended === null ? {} : { unattendedEnded: ended }; })(),
-        // Browser use, only for a flow with a zone that starts one: the same status line the flow page shows.
         ...(() => { const view = browserViewOf(store, flow); return view === null ? {} : { browser: { status: view.status, words: view.words, signedBy: view.signedBy, signedAt: view.signedAt } }; })(),
     };
 }
-/** Whether a flow runs on its own, and until when: null when it doesn't. */
 function unattendedJson(store, flow, now) {
     const live = activeUnattendedGrant(store, flow.id, now) === null ? null : unattendedViewOf(store, flow, { name: flow.owner, approver: true }, now).active;
     return live === null ? null : { until: live.until, signedBy: live.signedBy, budgetMicrousd: live.budgetMicrousd, dailyRunCap: live.dailyRunCap, runsToday: live.runsToday, covers: live.covers };

package/dist/flows-ui.js

@@ -1,5 +1,3 @@
-/** Flows in the console: the list of a person's flows, and one flow's canvas
- * (the React view's data, plus a plain fallback page the view replaces). */
 import { liveAttemptOf, steerControlsFor } from "./steer-controls.js";
 import { draftFor, flowDefinitionOf, NO_REPLY_MOVE_ON } from "./flow-engine.js";
 import { describeStandingOrder } from "./flow-schedule.js";
@@ -32,8 +30,6 @@ import { flowResultCard } from "./flow-result-card.js";
 import { acts, btn, chip, count, disclose, doc, docHeader, dock, empty, field, group, infoLine, input as input_, note, notice, overlay, overlayTrigger, pageHeader, phoneHeader, row, segLinks, select, status } from "./server/kit.js";
 import { agoWords } from "./lead-voice.js";
 const projectName = (repo) => repo.split(/[\\/]/).filter(Boolean).pop() ?? repo;
-/** v126: what happens to deliveries turned away (refused with 503), as far as each sender is known to say: nothing
- * here claims a loss that a sender's own retries may still make good. */
 function resendWords(config) {
     if (config.kind === "github")
         return "GitHub doesn't retry on its own: resend them from the repository's Settings → Webhooks → this webhook → Recent Deliveries → Redeliver.";
@@ -44,39 +40,30 @@ function resendWords(config) {
         : sender === "sentry" ? "Sentry may retry a refused delivery. Your Internal Integration's Dashboard in Sentry (Developer Settings) shows its request log; any it doesn't resend are lost, though new alerts for the same issues still arrive."
             : "The sender may retry. Look in its webhook delivery log and resend from there if it offers it; any it doesn't resend are lost.";
 }
-/** v126: what a webhook trigger's row says about how its deliveries are proved. */
 function hookView(trigger, config, dir) {
     const ready = hookReady(trigger, dir);
     const dropped = trigger.droppedCount > 0 && trigger.droppedSince !== null ? { count: trigger.droppedCount, since: trigger.droppedSince, resend: resendWords(config) } : null;
     if (config.kind !== "webhook")
         return { ready, needsSecret: config.kind === "linear", sender: null, makesSecret: false, warning: null, readerNote: null, dropped, scope: null };
     const sender = senderOf(config);
-    // What it needs first, first: an unset secret refuses everything, so that is said before any narrowing.
     const warning = trigger.hookHash === null && (sender === "none" || ready) ? "No address yet: choose New address to make one and give it to the sender."
         : sender === "none" ? "Unsigned: anyone with its address can add cards. Choose who signs its deliveries to close that."
             : !ready ? `Not set up: its deliveries are refused until ${sender === "sentry" || sender === "vercel" ? `${SENDER_WORDS[sender]}'s secret is pasted (with New address for the address to give it)` : "it is set up"}.`
                 : (sender === "sentry" || sender === "vercel") && config.project == null ? `Any ${SENDER_WORDS[sender]} project this secret covers can add cards. Name the project to narrow it.`
                     : null;
-    // A sender that signs only the body: byte-identical requests are one delivery (§3).
     const repeats = sender === "github-style" ? "Identical requests count once. If the sender must send the same request again and have it count, use Standard Webhooks." : null;
-    // A reader written from its sender's documentation, not yet from a captured delivery, says so on its own line,
-    // whatever else the row says (webhook-readers.ts).
     const readerNote = (sender === "sentry" || sender === "vercel") && !READER_CAPTURED[sender]
         ? `Reader unverified: Toolroll reads ${SENDER_WORDS[sender]} deliveries from ${SENDER_WORDS[sender]}'s documented examples; no real delivery has been checked yet.` : null;
     return { ready, needsSecret: sender === "sentry" || sender === "vercel", sender, makesSecret: sender === "standard" || sender === "github-style", warning, readerNote: [readerNote, repeats].filter(one => one !== null).join(" ") || null, dropped,
         scope: sender === "sentry" || sender === "vercel" ? { project: config.project ?? null, team: config.team ?? null } : null };
 }
-/** The flow page's fallback rules, plus the Flows list and the import preview (kit pieces; only layout here). */
 export const FLOWS_CSS = `.flows{max-width:880px;min-width:0}.flows .card{padding:16px 18px;margin:12px 0}.flows form{display:grid;gap:10px;margin:0}.flows label{display:grid;gap:6px}.flows input,.flows select{box-sizing:border-box;width:100%;max-width:100%}.flows button{justify-self:start;min-height:44px}.flows .flow-fallback ol{padding-left:20px}.flows summary{cursor:pointer;min-height:44px;display:flex;align-items:center;font-weight:600}.flows button.primary{background:var(--primary);color:var(--primary-foreground);border-color:var(--primary)}.flows fieldset{border:0;padding:0;margin:0;display:grid;gap:10px;min-width:0}.flows legend{font-weight:600;padding:0;margin-bottom:6px}.flows textarea[hidden]{display:none}.flows button.secondary{background:transparent;color:var(--foreground);border:1px solid var(--border)}@media(max-width:600px){.flows input,.flows select{font-size:16px}}@media(max-width:760px){.flows .card{padding:10px 12px;margin:8px 0;position:relative}}` +
-    // The list: the phone's project bar under the phone header; notices and the example in the page's gutter.
     `.fl-pbar{display:flex;gap:8px;align-items:center;padding:10px 16px;border-bottom:1px solid var(--so-line)}.fl-pbar form{flex:1;display:flex;gap:8px;margin:0;min-width:0}.fl-pbar .k-selw{flex:1;min-width:0}` +
     `.fl-say{padding:12px 24px 0}.fl-try{display:grid;gap:10px;justify-items:start;padding:0 24px 24px}.fl-try form{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin:0}` +
-    // The import drawer: the file chooser is a labelled outline button over the native input.
     `.fl-imp{display:grid;gap:18px;margin:0}.fl-file{display:flex;align-items:center;gap:10px;min-width:0}.fl-file input[type=file]{position:absolute;width:1px;height:1px;opacity:0}.fl-file label{cursor:pointer}.fl-file label:focus-within{outline:2px solid var(--so-ring);outline-offset:2px}.fl-file .k-note{min-width:0;overflow-wrap:anywhere}` +
     `.fl-imp textarea[hidden]{display:none}.fl-terms{list-style:none;padding:0;margin:0;display:grid;gap:8px;font-size:13px;line-height:1.5}.fl-terms li{white-space:pre-line;overflow-wrap:anywhere}` +
     `.fl-terms pre{white-space:pre-wrap;overflow-wrap:anywhere;margin:6px 0 0}.fl-pv-form{display:grid;gap:16px;margin:0}.fl-pv-form fieldset{border:0;padding:0;margin:0;display:grid;gap:14px;min-width:0}.fl-pv-form legend{font:600 13px/1.3 var(--so-font-sans);padding:0;margin-bottom:10px}` +
     `@media(max-width:760px){.fl-say{padding:12px 16px 0}.fl-try{padding:0 16px 24px}.fl-file label{min-height:44px}}`;
-/** "in 12 min", "in 5 h", "in 3 days": when a trigger next looks. */
 function nextWords(at, now) {
     const minutes = Math.max(0, Math.round((Date.parse(at) - now.getTime()) / 60_000));
     if (!Number.isFinite(minutes) || minutes < 1)
@@ -86,7 +73,6 @@ function nextWords(at, now) {
     const hours = Math.round(minutes / 60);
     return hours < 24 ? `in ${hours} h` : `in ${Math.round(hours / 24)} day${Math.round(hours / 24) === 1 ? "" : "s"}`;
 }
-/** What starts a flow, in a few words: its active triggers, else the paused ones, else that cards are added by hand. */
 function triggerWords(store, triggers) {
     const shown = triggers.filter(one => one.state === "active");
     const pick = shown.length > 0 ? shown : triggers.filter(one => one.state === "paused");
@@ -101,7 +87,6 @@ function triggerWords(store, triggers) {
     return words.length === 1 ? words[0] : `${words[0]} and ${words.length - 1} more`;
 }
 const FLOW_LIST_GROUPS = [["needs", "Needs you"], ["running", "Running"], ["on", "Turned on"], ["paused", "Paused"]];
-/** One flow as a quiet row: what the store knows now (cards waiting on a decision, cards in progress, its triggers). */
 function flowListRow(store, flow, now, options) {
     const cards = store.flowCards(flow.id, false);
     const definition = flowDefinitionOf(flow);
@@ -139,11 +124,9 @@ function flowListRow(store, flow, now, options) {
     return { group: "paused", row: row({ href: `/flows/${flow.id}`, chip: chip(paused ? "Paused" : "Off", "", { dot: false }), title: flow.name,
             desc: paused ? `${starts} · paused${tail}` : `${starts} · nothing starts it on its own${tail}`, meta, attrs: { "data-flow": flow.id } }) };
 }
-/** The project field of a list form: a select when there's a choice. */
 const projectSelect = (id, projects, current) => projects.length === 1
     ? html `<input type="hidden" name="repo" value="${projects[0]}">`
     : field({ id, label: "Project", control: select({ id, name: "repo", items: projects.map(repo => [repo, projectName(repo)]), current: current ?? projects[0], wide: true }) });
-/** The import form: a flow file chosen here or fetched from a gist, previewed in plain words before anything is made. */
 function importFormHtml(projects, current) {
     return postForm("/flows/import", html `${note("A flow file from another Toolroll, a teammate or a gist. Nothing runs until you import it, and any script it brings waits for your approval.")}\
 ${projectSelect("fl-imp-project", projects, current)}\
@@ -152,11 +135,6 @@ ${projectSelect("fl-imp-project", projects, current)}\
 ${field({ id: "fl-imp-url", label: "Or its address", control: input_({ id: "fl-imp-url", name: "url", type: "url", attrs: { inputmode: "url", placeholder: "https://gist.github.com/…" } }) })}\
 <p class="k-notice" role="alert" data-flow-file-note hidden></p>${acts(btn("Preview import", { type: "submit" }))}`, { attrs: { class: "fl-imp", "data-flow-import": true } });
 }
-/**
- * Flows: the top bar (a project filter, More, New flow), then each flow as a quiet row under Needs you, Running,
- * Turned on and Paused. Words come only from what the store knows now: cards waiting on a decision, cards in
- * progress, and the triggers (on, paused, when they last looked and what they found).
- */
 export function flowsListHtml(store, flows, projects, canCreate, problem, filter = null, now = new Date()) {
     const scope = filter !== null && projects.includes(filter) ? filter : null;
     const shown = scope === null ? flows : flows.filter(one => one.repo === scope);
@@ -166,7 +144,6 @@ export function flowsListHtml(store, flows, projects, canCreate, problem, filter
     const more = (id, phone) => overlayTrigger("More", "fl-more", { variant: phone ? "outline" : "ghost", sm: !phone, iconOnly: "more", ...(id === "" ? {} : { attrs: { id } }) });
     const create = making ? btn("New flow", { variant: "primary", sm: true, lead: "plus", href: "/flows/new" }) : html ``;
     const header = pageHeader("Flows", { right: html `${seg}${more("", false)}${create}` });
-    // On a phone the filter is a select (the form posts nothing: it's an address), beside More.
     const phoneBar = html `<div class="fl-pbar k-phone-only">${projects.length > 1 ? html `<form method="get" action="/flows">${select({ name: "project", label: "Project", items: [["", "All projects"], ...projects.map(repo => [repo, projectName(repo)])], current: scope ?? "", wide: true, attrs: { "data-k-autosubmit": "" } })}<noscript>${btn("Show", { sm: true, type: "submit" })}</noscript></form>` : html `<span class="k-grow"></span>`}${more("", true)}</div>`;
     const menu = overlay({ id: "fl-more", kind: "menu", title: "More", body: html `${making ? html `<button type="button" data-k-open="fl-import" aria-haspopup="dialog" aria-controls="fl-import">Import a flow file…</button>` : ""}<a href="/flows/new?group=kits">Starter kits</a><a href="/settings/lead/subagents">Subagents</a>` });
     const importDrawer = making ? overlay({ id: "fl-import", kind: "drawer", title: "Import a flow file", body: importFormHtml(projects, scope) }) : html ``;
@@ -189,17 +166,13 @@ export function flowsListHtml(store, flows, projects, canCreate, problem, filter
     }
     return html `<div class="fl-page" data-kit-page>${header}${phoneBar}${say}${body}${menu}${importDrawer}${making ? dock(btn("New flow", { variant: "primary", lead: "plus", href: "/flows/new" })) : ""}</div>`;
 }
-/** Reads the chosen flow file into the form (the server reads it again, whole, before anything is made), and sends a
- * filter select's form when it changes. */
 export const FLOW_IMPORT_SCRIPT = `(function(){document.querySelectorAll('select[data-k-autosubmit]').forEach(function(s){s.addEventListener('change',function(){if(s.form)s.form.requestSubmit();});});var form=document.querySelector('[data-flow-import]');if(!form)return;var input=form.querySelector('[data-flow-file]'),text=form.querySelector('[data-flow-document]'),note=form.querySelector('[data-flow-file-note]'),named=form.querySelector('[data-flow-file-name]'),address=form.querySelector('[name=url]');function say(words){note.textContent=words;note.hidden=words==='';}var reading=null;input.addEventListener('change',function(){text.value='';say('');var file=input.files&&input.files[0];if(named)named.textContent=file?file.name:'No file chosen';if(!file){reading=null;return;}if(file.size>${FLOW_FILE_MAX_BYTES}){say('That file is too big: a flow file is at most ${FLOW_FILE_MAX_BYTES / 1024} KB.');input.value='';if(named)named.textContent='No file chosen';reading=null;return;}reading=file.text().then(function(value){text.value=value;});});form.addEventListener('submit',function(event){if(reading!==null&&text.value===''){event.preventDefault();reading.then(function(){form.requestSubmit();});return;}if(text.value===''&&address.value.trim()===''){event.preventDefault();say('Choose a flow file or give its address.');}});})();`;
-/** An import's preview, a reading page: the plan in plain words, what it asks for, and one Import button after the terms. */
 export function flowImportHtml(input) {
     const { plan, file } = input;
     const fields = file.parameters.map((one, index) => field({ id: `fl-param-${index}`, label: one.optional === true ? `${one.about} (optional)` : one.about,
         control: input_({ id: `fl-param-${index}`, name: `param.${one.id}`, value: input.values[one.id] ?? plan?.values[one.id] ?? one.default ?? "", attrs: { maxlength: 200, autocomplete: "off" } }) }));
     const list = (items) => items.length === 0 ? "" : html `<ul class="fl-terms">${items.map(term => html `<li>${term}</li>`)}</ul>`;
     const section = (title, body) => html `<section class="k-sec"><h3>${title}</h3>${body}</section>`;
-    // The steps, what they mean, the triggers and the scripts; each script's code one tap away, as on the Scripts panel.
     const terms = plan === null ? "" : html `${plan.parts.about !== null && html `<p class="k-note">${plan.parts.about}</p>`}\
 ${section("Steps", html `${infoLine("Its instructions come from the file, not from you: read what each step is asked before you import.")}${list(plan.parts.steps)}`)}\
 ${plan.parts.triggers.length > 0 && section("Triggers", list(plan.parts.triggers))}\
@@ -218,7 +191,6 @@ const historyText = (event, title, sorts = new Set()) => {
         case "approved": return `Approved${who}${note}`;
         case "sent-back": return `Sent back to ${title(event.toStage)}${who}${note}`;
         case "fail": return `Moved to ${title(event.toStage)} after a problem${note}`;
-        // "Ignore" on a choice closes the card (flow-send.ts): said as such, with what was chosen and where.
         case "cancelled": return event.note?.startsWith("Ignored") ? `Ignored${who}${event.note.slice("Ignored".length)}` : `Cancelled${who}`;
         case "ok": return event.fromStage !== null && sorts.has(event.fromStage) ? `Sorted into ${title(event.toStage)}` : `Moved on to ${title(event.toStage)}${note}`;
         default: return `Moved to ${title(event.toStage)}${who}${note}`;
@@ -229,14 +201,11 @@ export function flowCardWaitsOn(store, flow, card, viewer, reads = {}) {
     if (!viewer.approver || card.state !== "active")
         return none;
     const stage = "stage" in reads ? reads.stage : flowDefinitionOf(flow)?.stages.find(one => one.id === card.stage);
-    // Its subagent's open question is the person's to answer whatever zone it is in, even one since removed from the flow
-    // (the flow page shows it and takes the answer).
     const asked = "asked" in reads ? reads.asked ?? null : store.openSubagentQuestionOn(card.id, card.entry);
     const answer = asked !== null && asked.state === "open" && asked.askedOf === viewer.name && store.getSubagent(asked.subagent) !== null;
     if (stage === undefined)
         return { ...none, answer };
     const decider = stage.kind === "approval" ? deciderOf(stage, flow) : null;
-    // While its subagent is deciding (v92), the card isn't anyone else's to decide yet.
     const subagentDeciding = stage.subagent !== undefined && card.waiting !== null && card.waiting.endsWith(" is deciding");
     const choosing = stage.kind !== "choose" ? null : "choosing" in reads ? reads.choosing ?? null : flowChoiceAt(store, card.id, card.entry);
     const browser = stage.kind !== "check" || stage.browser !== true ? null : "browser" in reads ? reads.browser ?? null : browserViewOf(store, flow);
@@ -250,12 +219,10 @@ export function flowCardWaitsOn(store, flow, card, viewer, reads = {}) {
             && flowPersonOf(card, flow) === viewer.name,
     };
 }
-/** A check zone's card waiting for browser use (flow-browser.ts): the flow's browser isn't allowed and the card says so. */
 function browserWaitOn(card, stage, browser) {
     return card.state === "active" && stage?.kind === "check" && stage.browser === true && browser !== null && browser.status !== "allowed"
         && card.waiting !== null && card.waiting.startsWith(`${stage.title} starts a browser`);
 }
-/** One flow's canvas for one person. */
 export function flowView(store, flow, viewer, selectedCard, setup = { dir: null, repos: [] }) {
     const definition = flowDefinitionOf(flow);
     const stages = definition?.stages ?? [];
@@ -275,24 +242,17 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
     const cards = store.flowCards(flow.id, true).filter(card => card.state === "active" || Date.now() - Date.parse(card.updatedAt) < 7 * 86_400_000).map((card) => {
         const stage = stages.find(one => one.id === card.stage);
         const task = card.task ?? card.primaryTask;
-        // Build zones may file into another project; the flow alone does not admit its task's detail.
         const taskRepo = card.task === null ? null : store.lookupRef(card.task)?.repo ?? null;
         const canReadTask = taskRepo !== null && (taskRepo === flow.repo || (setup.repos.includes(taskRepo) && store.accountCanAccess(viewer.name, taskRepo)));
         const discussion = store.flowComments(card.id);
         const watchers = store.flowCardWatchers(card.id);
-        // Its open question: one of its own, or (v94) a tool call waiting for approval.
         const asked = card.state === "active" ? store.openSubagentQuestionOn(card.id, card.entry) : null;
-        // "Person chooses" (flow-send.ts): what was sent, and the options, for the person it waits on; the latest send otherwise.
         const choosing = card.state === "active" && stage?.kind === "choose" ? flowChoiceAt(store, card.id, card.entry) : null;
-        // Who may decide it here: the one rule Home reads too (flowCardWaitsOn).
         const canDecide = flowCardWaitsOn(store, flow, card, viewer, { stage, asked, choosing, browser: browserNow }).decide;
-        // History reads moves and ownership together, newest first.
         const owned = discussion.filter(one => one.kind === "owner").map(one => ({ text: one.body === "" ? `${one.author} left it without an owner` : one.body === one.author ? `${one.author} took it on` : `${one.author} made ${one.body} the owner`, at: one.at }));
         const moves = store.flowEvents(card.id).map(event => ({ text: historyText(event, title, sortZones), at: event.at }));
         const decision = parseSortDecision(decisions.get(card.id)?.decisionJson ?? null);
         const shown = stage?.kind === "approval" && definition !== null ? draftFor(definition, stage) : null;
-        // v91: when a Wait zone gives up (or moves on), or a zone's time limit comes.
-        // An "hours" wait has no deadline of its own: it goes on when the clock reaches its hours.
         const clock = stage?.wait?.for === "hours" ? stage.limit : stage?.wait ?? stage?.limit;
         const until = card.state !== "active" || stage === undefined || clock === undefined ? null : new Date(Date.parse(store.flowCardEnteredAt(card.id) ?? card.updatedAt) + clock.minutes * 60_000);
         const deadline = until === null || until.getTime() <= Date.now() ? null : {
@@ -300,7 +260,6 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             label: stage.wait !== undefined && stage.wait.for !== "hours" ? (stage.wait.for === "reply" ? "No reply by" : "Moves on at") : stage.limit.to !== null ? `Moves to ${title(stage.limit.to)} at` : "Reminder at",
         };
         const pending = asked?.toolCall == null ? null : store.subagentCall(asked.toolCall);
-        // A decision its subagent handed over carries what the subagent said (v92).
         const turn = card.state === "active" && stage?.kind === "approval" && stage.subagent !== undefined ? store.flowStepRun(card.id, card.entry) : null;
         let handoff = null;
         if (turn !== null && turn.kind === "subagent" && turn.state === "passed") {
@@ -317,11 +276,9 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
         const asker = asked === null || asked.state !== "open" ? null : store.getSubagent(asked.subagent);
         const latest = store.flowSends(card.id)[0] ?? null;
         const sentContent = latest === null ? null : readFlowSend(latest.contentJson);
-        // On the card itself: where it came from (the card's title is right above), and only the links the panel doesn't already have.
         const own = new Set([`/flows/${flow.id}?card=${card.id}`, ...(task === null ? [] : [`/t/${encodeURIComponent(task)}`])]);
         const sentView = (content) => ({ title: content.from === undefined ? "What was done" : `From ${content.from}`, summary: content.summary,
             links: content.links.map(one => ({ label: one.label, href: "url" in one ? one.url : one.path })).filter(one => !own.has(one.href)),
-            // After research: the same numbered items the message carried, each beside its screenshot.
             ...(content.items === undefined ? {} : { items: content.items.map((item, index) => ({ number: index + 1, title: item.title, lines: whyLines(item.why), source: item.source, url: item.url,
                     image: item.shot === null || content.shots === null ? null : { src: `/r/${content.shots.run}/evidence/${item.shot}`, caption: itemCaption(index + 1, item) } })) }) });
         const browserWait = browserWaitOn(card, stage, browser);
@@ -329,11 +286,9 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             id: card.id, title: card.title, description: card.description, stage: card.stage, state: card.state,
             waiting: card.state === "active" && card.task !== null && (stage?.kind === "task" || stage?.kind === "report")
                 ? canReadTask ? flowCardTaskLine(store, card.task, taskRepo, now, secretsFor(taskRepo)) : "Task unavailable"
-                // Waiting for browser use: the page offers Allow browser itself, so the command line the CLI shows is left off.
                 : browserWait ? card.waiting.replace(/ Approve it with: toolroll flows browser \d+ on$/, "") : card.waiting,
             ...(browserWait ? { browserWait: true } : {}),
             task: task === null ? null : { id: task, href: `/t/${encodeURIComponent(task)}`,
-                // Its running attempt's composer, for an approver who may read the task (steer-controls.ts).
                 ...(() => {
                     const ref = card.state === "active" && canReadTask && viewer.approver ? store.lookupRef(task) : null;
                     const run = ref === null ? null : liveAttemptOf(store, ref.id, now);
@@ -342,11 +297,8 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
                 })() },
             createdBy: card.createdBy, updatedAt: card.updatedAt,
             canDecide,
-            // What a "Send to me" sent shows once, in its own box (sent), not again here; a report zone's items and full report
-            // (`<id>.items`, `<id>.report`) are for later zones, and its summary is shown.
             outputs: Object.entries(card.outputs).filter(([id]) => !id.includes(".") && stages.find(one => one.id === id)?.kind !== "send").map(([id, text]) => ({ stage: id, title: title(id), text })),
             history: [...moves, ...owned].sort((a, b) => b.at.localeCompare(a.at)).slice(0, 30),
-            // v126: an outside event's card says how it was proved and where its link goes, from what was kept at receipt.
             source: card.source === null ? null : (() => { const snapshot = snapshotOf(card.source); return snapshot === null ? card.source : { ...card.source, proved: provedWords(snapshot), host: hostOf(card.source.url), shown: card.source.url === null ? null : linkWords(card.source.url) }; })(),
             owner: card.owner, watchers, watching: watchers.includes(viewer.name),
             mine: card.owner === viewer.name || watchers.includes(viewer.name) || canDecide || choosing?.person === viewer.name,
@@ -369,7 +321,6 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
                     call: pending === null ? null : { why: pending.why, rule: pending.result ?? "" } },
             calls: store.subagentCallsOn(card.id).slice(-30).map(call => {
                 const mate = mates.get(call.subagent) ?? null;
-                // A person's undo (v97) reads as theirs, and its outcome says what it undid.
                 return { id: call.id, who: call.undoOf !== null ? call.decidedBy ?? "A person" : mate === null ? "A subagent" : nameOf(mate), words: callWords(call.tool, call.action, call.input, 400), state: call.state, outcome: receiptWords(store, call),
                     why: call.undoOf !== null ? "" : call.why, result: call.state === "asked" ? null : call.result, at: call.createdAt, subagent: call.subagent, undo: viewer.approver ? undoFor(store, call) : null };
             }),
@@ -424,7 +375,6 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
         colors: [...FLOW_COLORS],
     };
 }
-/** The page the canvas replaces when scripts can't run: each zone and its cards, in order. */
 export function flowFallbackHtml(view) {
     const own = view.unattended.active;
     return html `<section class="flows flow-fallback"><p class="meta">${view.flow.project}</p>${own !== null && html `<p data-flow-unattended>Runs on its own until ${own.untilWords}</p>`}${view.browser !== null && html `<p data-flow-browser="${view.browser.status}">${view.browser.words}</p>`}<ol>${view.stages.map(stage => {
@@ -432,7 +382,6 @@ export function flowFallbackHtml(view) {
         return html `<li><strong>${stage.title}</strong> · ${FLOW_KIND_WORDS[stage.kind].label}${cards.length > 0 && html `<ul>${cards.map(card => html `<li>${card.title}${card.waiting !== null && ` — ${card.waiting}`}</li>`)}</ul>`}</li>`;
     })}</ol></section>`;
 }
-/** The nightly check's own health on its flow (release-once.md, part 3): nothing since the last firing for 26 hours. */
 function nightlyHealthOf(store, flow) {
     const nightly = store.flowTriggers(flow.id).find(one => one.state === "active" && triggerConfigOf(one)?.kind === "schedule" && triggerConfigOf(one).order?.check !== undefined);
     return nightly === undefined ? null : nightlyHealthWords(store, flow.repo, nightly.updatedAt, new Date());