toolroll 0.9.85 → 0.9.86

package/dist/flow-steps.js

@@ -36,7 +36,9 @@ import { claudeDraftRunner, DRAFT_CHARS, DRAFT_TIMEOUT, draftPrompt, wholeDraft
 import { overruns, passOn, TEXT_LIMITS, writeWithin } from "./text-limits.js";
 import { readFlowSecrets, sendingReady, runRequest, sendEmail, toolWaiting, useTool } from "./flow-actions.js";
 import { cleanFolder, flowLaunch, runCode } from "./flow-code.js";
+import { browserStanding } from "./flow-browser.js";
 import { readProviderKey } from "./keys.js";
+import { cardTaskArchived } from "./task-archive.js";
 import { replyInChannel } from "./chat-inbox.js";
 import { recordSent, threadOf } from "./flow-replies.js";
 import { ASKED, subagentReady, subagentTurn } from "./subagent-work.js";
@@ -70,6 +72,9 @@ export async function runFlowSteps(store, repo, now, io) {
         const stage = known.definition?.stages.find(one => one.id === card.stage);
         if (stage === undefined)
             continue;
+        // A card whose task is put away (v145) runs nothing — no step, subagent turn or pull request — until it's restored.
+        if (cardTaskArchived(store, card.id))
+            continue;
         // v92: a subagent's turn — a zone it handles, or a decision it staffs (a person decides when it's paused or gone).
         if (stage.kind === "subagent" || (stage.kind === "approval" && stage.subagent !== undefined)) {
             await subagentStep(store, known.flow, known.definition, stage, card, now, io, pass);
@@ -145,6 +150,14 @@ export async function runFlowSteps(store, repo, now, io) {
                 store.updateFlowCard(card.id, { waiting }, now);
             continue;
         }
+        // A script that starts a browser waits, saying so, until a person approves browser use for the flow (flow-browser.ts),
+        // rather than run and crash inside the sandbox; it runs on its own once approved.
+        const browser = stage.kind === "check" && stage.browser === true ? (script === null || known.definition === null ? { allowed: false, said: "This zone's script can't be read." } : browserStanding(store, known.flow.id, stage.id, { definition: known.definition, script })) : null;
+        if (browser !== null && !browser.allowed) {
+            if (card.waiting !== browser.said)
+                store.updateFlowCard(card.id, { waiting: browser.said }, now);
+            continue;
+        }
         if (!claimStep(store, card, { stage: stage.id, kind: stage.kind, script: script?.name ?? null, scriptVersion: script?.version ?? null }, now))
             continue;
         pass.ran++;
@@ -174,12 +187,21 @@ export async function runFlowSteps(store, repo, now, io) {
 }
 /** Claim this card's visit to its step zone, only while the card is still there on that visit: a pass that read the card
  * before another pass (or a person) moved it never runs the step for a visit that's over. */
-function claimStep(store, card, step, now) {
+export function claimStep(store, card, step, now) {
     return store.transact(() => {
         const fresh = store.getFlowCard(card.id);
         if (fresh === null || fresh.state !== "active" || fresh.entry !== card.entry || fresh.stage !== step.stage)
             return false;
-        return store.claimFlowStep({ card: card.id, entry: card.entry, ...step }, now);
+        // A card whose task is put away (v145) runs no step until the task is restored (both of its tasks, re-read here).
+        if (cardTaskArchived(store, card.id))
+            return false;
+        if (!store.claimFlowStep({ card: card.id, entry: card.entry, ...step }, now))
+            return false;
+        // The tasks this step was admitted for stay held while it runs, wherever the card moves meanwhile.
+        for (const task of [fresh.task, fresh.primaryTask])
+            if (task !== null)
+                store.handle.prepare("INSERT OR IGNORE INTO flow_step_task (card, entry, task_id) VALUES (?, ?, ?)").run(card.id, card.entry, task);
+        return true;
     });
 }
 /** One subagent turn, when one is due for this card: claimed like any step, retried on failure, and waiting while its question is open. */
@@ -361,16 +383,31 @@ async function runCheck(store, flow, stage, script, card, now, io) {
         if (added.code !== 0)
             return { state: "retry", said: `Couldn't make a copy of${where}: ${added.stderr.trim().split("\n")[0]?.slice(0, 160) ?? "git refused"}.` };
     }
-    const launch = flowLaunch(store, { repo: flow.repo, folder: path, scratch: io.scratch, copy, policy: store.flowFencePolicy(flow.id), ...(io.fenceAvailable === undefined ? {} : { available: io.fenceAvailable }), ...(io.home === undefined ? {} : { home: io.home }) });
+    // Browser use, proved at the moment of launch: a zone that says it starts a browser runs only with a person's standing
+    // approval (flow-browser.ts); then its script, and only its script, gets Chromium's one service.
+    const wantsBrowser = stage.browser === true;
+    // Read once: the drawing and the script this launch runs are the very objects the browser decision is about.
+    const running = flowDefinitionOf(flow);
+    const standing = !wantsBrowser ? null : running === null || running.stages.find(one => one.id === stage.id) === undefined || JSON.stringify(running.stages.find(one => one.id === stage.id)) !== JSON.stringify(stage)
+        ? { allowed: false, said: "This zone changed while it was starting, so it didn't run." } : browserStanding(store, flow.id, stage.id, { definition: running, script });
+    if (standing !== null && !standing.allowed) {
+        if (copy)
+            await io.git("git", ["-C", flow.repo, "worktree", "remove", "--force", path], { timeoutMs: 60_000 }).catch(() => undefined);
+        rmSync(path, { recursive: true, force: true });
+        return { state: "failed", said: standing.said };
+    }
+    const launch = flowLaunch(store, { repo: flow.repo, folder: path, scratch: io.scratch, copy, policy: store.flowFencePolicy(flow.id), ...(standing?.allowed === true ? { browser: true } : {}), ...(io.fenceAvailable === undefined ? {} : { available: io.fenceAvailable }), ...(io.home === undefined ? {} : { home: io.home }) });
     try {
         if (launch !== null && "problem" in launch)
             return { state: "failed", said: launch.problem };
+        // The project's setup never gets the browser rule: only the zone's script asked for it.
+        const setupFence = launch?.fence === undefined ? undefined : { ...launch.fence, fenceGrants: withoutBrowser(launch.fence.fenceGrants) };
         let log = "";
         const setup = copy ? store.liveWorktreeSetup(flow.repo) : null;
         if (setup !== null) {
             const shell = approvedCommandShell(setup.command);
             const prepared = await io.shell(shell.file, shell.args, { cwd: path, timeoutMs: setup.timeoutMs, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST, processGroup: true,
-                ...(launch === null ? {} : { env: launch.env, ...(launch.fence ?? {}) }) });
+                ...(launch === null ? {} : { env: launch.env, ...(setupFence ?? {}) }) });
             log += `$ ${setup.command}\n${prepared.stdout}${prepared.stderr}\n`;
             if (prepared.code !== 0)
                 return { state: "failed", said: `The project's setup failed before ${script.name} ran (exit ${prepared.code}).\n${tail(`${prepared.stdout}\n${prepared.stderr}`)}`, log, exitCode: prepared.code };
@@ -385,7 +422,15 @@ async function runCheck(store, flow, stage, script, card, now, io) {
             answers: (stage.routes ?? []).map(one => one.answer),
         };
         const env = { FLOW_NAME: flow.name, FLOW_CARD_ID: String(card.id), FLOW_CARD_TITLE: card.title, FLOW_COMMIT: commit ?? "", FLOW_SCRIPT: script.name, FLOW_PROJECT: flow.repo };
-        const ran = await runCode({ script, cwd: path, root: copy ? path : flow.repo, input, env, secrets, scratch: io.scratch, shell: io.shell, launch });
+        // Checked again right before the script: the flow or its script may have changed while the setup ran.
+        if (wantsBrowser) {
+            const still = running === null ? { allowed: false, said: "This flow's drawing can't be read." } : browserStanding(store, flow.id, stage.id, { definition: running, script });
+            if (!still.allowed)
+                return { state: "failed", said: still.said, log };
+        }
+        // And at every spawn attempt (a retry after a failed spawn too): revoked or changed meanwhile, nothing starts.
+        const stillApproved = !wantsBrowser || running === null ? undefined : () => browserStanding(store, flow.id, stage.id, { definition: running, script }).allowed;
+        const ran = await runCode({ script, cwd: path, root: copy ? path : flow.repo, input, env, secrets, scratch: io.scratch, shell: io.shell, launch, ...(stillApproved === undefined ? {} : { beforeSpawn: stillApproved }) });
         log += ran.log;
         const output = ran.output === "" ? undefined : ran.output;
         // Where it ran goes at the end of the first line: "run-tests failed (exit 1) on main."
@@ -407,6 +452,11 @@ async function runCheck(store, flow, stage, script, card, now, io) {
         rmSync(path, { recursive: true, force: true });
     }
 }
+/** A fence's grants without Chromium's service (a flow's setup, beside a script zone that has it). */
+function withoutBrowser(grants) {
+    const { browser: _scriptOnly, ...rest } = grants;
+    return rest;
+}
 /** An update: a comment on the issue the card came from, and closing it if the zone says so. */
 async function updateSource(store, stage, card, io, now) {
     const source = card.source;

package/dist/flow-triggers.js

@@ -49,6 +49,7 @@ import { readFlowSecrets } from "./flow-secrets.js";
 import { prepareUnattendedCandidates, grantSignsScriptOf, scriptProvenanceOf, scriptRanDigestOf } from "./flow-unattended.js";
 import { tmpdir } from "node:os";
 import { envValue } from "./names.js";
+import { recordBranchCheckRun, unprovenNoticeRuns } from "./tidy.js";
 import { linearLabelNames, readFormSubmission, readGithubEvent, readGithubIssue, readGithubIssueEventList, readGithubIssueList, readGithubRun, readGithubRunList, readInboundMail, readLinearAnswer, readLinearEvent, readLinearIssue, readWebhookPayload } from "./contracts/trigger-payloads.js";
 import { isRecord } from "./is-record.js";
 export { FLOW_TRIGGER_KINDS };
@@ -925,6 +926,9 @@ async function checkTrigger(store, trigger, config, now, io) {
         store.updateFlowTrigger(trigger.id, { failures, lastAt: now.toISOString(), lastOutcome: fetched.problem, nextAt: new Date(now.getTime() + BACKOFF_MS[Math.min(failures, BACKOFF_MS.length) - 1]).toISOString() }, now);
         return { ok: false, said: fetched.problem, added: 0 };
     }
+    // Tidy's CI evidence (task-tidy.md): the watched branch's completed runs, green and red, beside the failures it carded.
+    if (config.kind === "github" && config.watch === "checks")
+        await observeBranchRuns(store, trigger, config, io.gh, now);
     const by = config.kind === "github" ? "GitHub" : config.kind === "linear" ? "Linear" : "Email";
     // Known items are left out before the batch is taken (v126): a page of things already received can't keep the unseen
     // ones behind it waiting.
@@ -1206,6 +1210,14 @@ export function receiveFlowHook(store, token, delivery, dir, now) {
             : config.watch === "pulls" && event === "pull_request" && ["opened", "ready_for_review", "labeled", "reopened"].includes(action) ? githubItem(config, body.pull_request, "pull")
                 : config.watch === "checks" && event === "workflow_run" && action === "completed" ? githubRunItem(config, body.workflow_run) : null;
         items = found === null ? [] : [found];
+        // A signed workflow run on the watched branch is tidy's CI evidence too (task-tidy.md), green or red: recorded only
+        // inside `written`, which re-proves the trigger is still active with the same config, credential and address.
+        if (config.watch === "checks" && config.branch !== null && event === "workflow_run" && action === "completed") {
+            const branch = config.branch;
+            const recorded = written(() => { recordBranchCheckRun(store, { repo: config.repo, branch }, readGithubRun(body.workflow_run), now); return { status: 200, said: "Recorded." }; });
+            if (recorded.status !== 200)
+                return recorded;
+        }
     }
     else if (config.kind === "linear") {
         const body = readLinearEvent(payload), sent = Number(body.webhookTimestamp);
@@ -1648,3 +1660,46 @@ export function receiveFlowForm(store, token, fields, now) {
     store.updateFlowTrigger(trigger.id, { lastAt: now.toISOString(), lastOutcome: "Someone sent the form." }, now);
     return { status: 200, html: thanks };
 }
+/** Tidy's CI evidence (docs/plans/task-tidy.md): the watched branch's recent completed workflow runs, read through the
+ * person's own gh login. Recorded only while the trigger still watches exactly that repository and branch once GitHub
+ * answered; any failure records nothing (tidy then keeps the notices). */
+async function observeBranchRuns(store, trigger, config, gh, now) {
+    if (config.branch === null)
+        return;
+    const branch = config.branch;
+    let result;
+    try {
+        result = await gh("gh", ["api", "-H", "Accept: application/vnd.github+json", `repos/${config.repo}/actions/runs?branch=${encodeURIComponent(branch)}&status=completed&per_page=50`], { timeoutMs: 20_000 });
+    }
+    catch {
+        return;
+    }
+    if (result.code !== 0)
+        return;
+    let body;
+    try {
+        body = JSON.parse(result.stdout);
+    }
+    catch {
+        return;
+    }
+    const runs = [...readGithubRunList(body).workflow_runs ?? []];
+    // A few older failure cards' own runs, so tidy can tell whether each was a push to this branch (task-tidy.md).
+    for (const id of unprovenNoticeRuns(store, trigger.id, config.repo)) {
+        try {
+            const one = await gh("gh", ["api", "-H", "Accept: application/vnd.github+json", `repos/${config.repo}/actions/runs/${id}`], { timeoutMs: 20_000 });
+            if (one.code === 0)
+                runs.push(readGithubRun(JSON.parse(one.stdout)));
+        }
+        catch { /* read again next time */ }
+    }
+    // Re-proved and recorded in one transaction: a trigger paused or changed meanwhile records nothing.
+    store.transact(() => {
+        const current = store.getFlowTrigger(trigger.id);
+        const still = current === null ? null : triggerConfigOf(current);
+        if (current === null || current.state !== "active" || current.configJson !== trigger.configJson || still === null || still.kind !== "github" || still.watch !== "checks" || still.repo !== config.repo || still.branch !== branch)
+            return;
+        for (const run of runs)
+            recordBranchCheckRun(store, { repo: config.repo, branch }, run, now);
+    });
+}

package/dist/flows-cli.d.ts

@@ -296,6 +296,25 @@ export declare const FLOWS_DESCRIPTORS: readonly [{
         readonly takesValue: true;
         readonly meaning: 'also cover these script or plane-review schedules (trigger ids, like 12,14); plain schedules are covered already';
     }];
+}, {
+    readonly action: 'browser';
+    readonly synopsis: "let a flow's script zones marked browser: true start Chromium in their sandbox (on: a person approves with their own password, previews until --yes; off: any approver revokes)";
+    readonly mutation: 'identity-idempotent';
+    readonly audience: 'operator';
+    readonly positionals: readonly ['flow', 'on|off'];
+    readonly flags: readonly [...{
+        name: string;
+        takesValue: boolean;
+        meaning: string;
+    }[], {
+        name: string;
+        takesValue: boolean;
+        meaning: string;
+    }, {
+        readonly name: 'digest';
+        readonly takesValue: true;
+        readonly meaning: "required with --yes: the approval digest the preview showed; refuses if the flow or its scripts changed since";
+    }];
 }, {
     readonly action: 'archive';
     readonly synopsis: 'archive a flow: its cards stop moving and its triggers stop; previews until --yes';

package/dist/flows-cli.js

@@ -19,6 +19,7 @@ import { STARTER_FLOWS, starterFlowOf, starterOf, startersFor, starterTerms, swi
 import { addFlowTriggerTo, checkFlowTriggerNow, describeTrigger, removeFlowTrigger, setFlowTriggerOn, triggerConfigOf, validateTriggerConfig, rawTakesDeliveries } from './flow-triggers.js';
 import { deciderOf, FLOW_KIND_WORDS, FLOW_TEMPLATES, flowDigest, flowFromSteps, flowTerms, stepsFor } from './flows.js';
 import { prepareUnattendedCandidates, activeUnattendedGrant, parseUnattendedAsk, revokeUnattended, signUnattended, unattendedViewOf, unattendedWords, untilWords, UNATTENDED_MAX_RUNS } from './flow-unattended.js';
+import { browserApprovalDigest, browserTerms, browserTermsOf, browserViewOf, revokeFlowBrowser, signFlowBrowser } from './flow-browser.js';
 import { MODE_MAX_DAYS } from './modes.js';
 import { verifyApproverByPassword } from './principal.js';
 import { authenticateApprover, proveCredential } from './scope.js';
@@ -71,6 +72,8 @@ export const FLOWS_DESCRIPTORS = [
             { name: 'budget', takesValue: true, meaning: 'optional dollar cap per attempt, like 5 or 2.50' },
             { name: 'runs', takesValue: true, meaning: `optional limit on runs a day (UTC), 1 to ${UNATTENDED_MAX_RUNS}` },
             { name: 'include', takesValue: true, meaning: 'also cover these script or plane-review schedules (trigger ids, like 12,14); plain schedules are covered already' }] },
+    { action: 'browser', synopsis: "let a flow's script zones marked browser: true start Chromium in their sandbox (on: a person approves with their own password, previews until --yes; off: any approver revokes)", mutation: 'identity-idempotent', audience: 'operator', positionals: ['flow', 'on|off'], flags: [...write, yes,
+            { 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`. */
@@ -160,10 +163,12 @@ export async function runFlowsCommand(positional, flags, context) {
     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.
-    const widening = (project) => {
+    // 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) ? { widening: 'proved' } : {};
+        return proved.ok && personProof(proved.method) ? proved.method : null;
     };
+    const widening = (project) => personMethod(project) === null ? {} : { widening: 'proved' };
     const settle = (project) => { try {
         advanceFlows(store, project, context.clock(), { evidenceRoot: context.evidenceRoot });
     }
@@ -396,6 +401,42 @@ export async function runFlowsCommand(positional, flags, context) {
             `Revoke: toolroll flows unattended ${flow.id} off`,
         ]);
     }
+    if (action === 'browser') {
+        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.');
+        const turn = args[1];
+        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`);
+            return ok({ applied: true, browser: null }, [`${flow.name}'s scripts can no longer start a browser.`]);
+        }
+        if (flowDefinitionOf(flow) === null)
+            return refuse(flow.repo, 'unreadable', 'This flow\'s drawing can\'t be read. Save it again from the editor.');
+        const terms = browserTermsOf(store, flow);
+        if (terms === null || terms.zones.length === 0)
+            return refuse(flow.repo, 'refused', terms === null ? 'A zone that starts a browser has no script it can approve: missing, waiting for approval, or one that runs a project file (write the script on the zone instead). Nothing was changed.'
+                : `No zone in ${flow.name} says it starts a browser. Mark its script zone with browser: true (flows edit), then approve. Nothing was changed.`);
+        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);
+        const signed = signFlowBrowser(store, { flow: flow.id, signer: who, proof: personMethod(flow.repo), sawDigest: given }, now);
+        if (!signed.ok)
+            return refuse(flow.repo, 'refused', `${signed.message} Nothing was changed.`);
+        record(flow.repo, 'accepted', `flow #${flow.id} browser on`);
+        return ok({ applied: true, browser: { digest: signed.grant.digest, zones: signed.grant.zones, signedBy: signed.grant.signedBy } }, [
+            `${flow.name} may start a browser. Approved by ${who}:`, ...browserTerms(signed.grant.zones).map(line => `  ${line}`), `Revoke: toolroll flows browser ${flow.id} off`,
+        ]);
+    }
     if (action === 'archive') {
         const cards = store.flowCards(flow.id, false).length, triggers = store.flowTriggers(flow.id).filter(one => one.state === 'active').length;
         if (!flags.has('yes'))
@@ -566,6 +607,7 @@ function zoneOf(stage, flow) {
         ...(stage.limit === undefined ? {} : { remindAfterMinutes: stage.limit.minutes, thenMoveTo: stage.limit.to }),
         ...(stage.kind === 'approval' ? { decider: deciderOf(stage, flow) } : {}),
         ...(stage.script === null ? {} : { script: stage.script }),
+        ...(stage.browser === true ? { browser: true } : {}),
         ...(stage.merge === undefined ? {} : { merge: stage.merge }),
         ...(stage.subagent === undefined ? {} : { subagent: stage.subagent }),
         ...(stage.options === undefined ? {} : { options: stage.options.map(one => ({ label: one.label, to: one.to })) }),
@@ -589,6 +631,8 @@ function describeFlow(store, flow, now) {
         }),
         cards: store.flowCards(flow.id, true).slice(0, 10).map(card => cardOf(definition, card)),
         unattended: unattendedJson(store, flow, now),
+        // 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. */
@@ -606,6 +650,7 @@ function showLines(flow) {
             ? `Runs on its own: no · turn on: toolroll flows unattended ${flow.id} on --days N`
             : `Runs on its own until ${untilWords(flow.unattended.until)} · revoke: toolroll flows unattended ${flow.id} off`,
         ...(flow.unattended === null ? [] : [`  Covers: ${flow.unattended.covers.join('; ')}`]),
+        ...(flow.browser === undefined ? [] : [`${flow.browser.words} · ${flow.browser.status === 'allowed' ? `turn off: toolroll flows browser ${flow.id} off` : `allow: toolroll flows browser ${flow.id} on`}`]),
         '', 'Zones',
         ...flow.zones.flatMap((zone, index) => [
             `  ${index + 1}. ${zone.title} (${zone.id}) — ${zone.does}${zone.id === flow.start ? ' · start' : ''}`,

package/dist/flows-ui.js

@@ -24,6 +24,7 @@ import { callWords, receiptWords } from "./subagent-tools.js";
 import { undoFor } from "./subagent-week.js";
 import { flowCardTaskLine } from "./flow-card-task.js";
 import { unattendedViewOf } from "./flow-unattended.js";
+import { browserViewOf } from "./flow-browser.js";
 import { readFlowSecrets } from "./flow-secrets.js";
 import { html, joinHtml, postForm } from "./html.js";
 const projectName = (repo) => repo.split(/[\\/]/).filter(Boolean).pop() ?? repo;
@@ -114,6 +115,8 @@ const historyText = (event, title, sorts = new Set()) => {
 export function flowView(store, flow, viewer, selectedCard, setup = { dir: null, repos: [] }) {
     const definition = flowDefinitionOf(flow);
     const stages = definition?.stages ?? [];
+    const browserNow = browserViewOf(store, flow);
+    const browser = browserNow === null ? null : { ...browserNow, canApprove: viewer.approver && store.accountOf(viewer.name)?.projects === null };
     const title = (id) => stages.find(one => one.id === id)?.title ?? id;
     const sortZones = new Set(stages.filter(one => one.kind === "sort").map(one => one.id));
     const decisions = sortZones.size === 0 ? new Map() : store.flowSortDecisions(flow.id);
@@ -179,10 +182,15 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             // 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 = 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`);
         return {
             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" : card.waiting,
+                ? 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).
                 ...(() => {
@@ -262,6 +270,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
         live: flowFingerprint(store, flow.id),
         canEdit: viewer.approver,
         unattended: unattendedViewOf(store, flow, viewer, setup.now ?? now),
+        browser,
         approvers: store.listApprovers().map(one => one.name).filter(name => store.accountCanAccess(name, flow.repo)),
         projects: [flow.repo, ...setup.repos.filter(one => one !== flow.repo)].map(path => ({ path, name: projectName(path) })),
         kinds: FLOW_STAGE_KINDS.map(kind => ({ kind, label: FLOW_KIND_WORDS[kind].label, about: FLOW_KIND_WORDS[kind].about })),
@@ -271,7 +280,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
 /** 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>`}<ol>${view.stages.map(stage => {
+    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 => {
         const cards = view.cards.filter(card => card.stage === stage.id && card.state === "active");
         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>`;

package/dist/flows.js

@@ -224,7 +224,9 @@ function canonicalStage(input, index) {
         close: kind === "update" ? stage["close"] !== false : null,
         script: kind === "check" ? said(stage["script"]) : null,
         // Left out, a script runs where every script ran before v90: in a copy of the card's work.
-        ...(kind === "check" ? { ...(runIn === undefined ? {} : { runIn }), ...(routes === undefined ? {} : { routes }), ...(secrets === undefined ? {} : { secrets }) } : {}),
+        ...(kind === "check" ? { ...(runIn === undefined ? {} : { runIn }), ...(routes === undefined ? {} : { routes }), ...(secrets === undefined ? {} : { secrets }),
+            // v144: a script that starts a browser says so; false or none is a script that doesn't (and keeps its digest).
+            ...(!given(stage["browser"]) || stage["browser"] === false ? {} : { browser: stage["browser"] }) } : {}),
         sort: kind === "sort" ? canonicalSort(stage["sort"]) : null,
         ...(kind === "request" ? { request: { method, url: said(request["url"]), headers: Object.fromEntries(Object.entries(isRecord(request["headers"]) ? request["headers"] : {}).flatMap(([name, value]) => { const one = said(value); return one === null ? [] : [[name, one]]; })), body: method === "GET" || method === "DELETE" ? null : said(request["body"]) } } : {}),
         ...(kind === "email" ? { email: { to: said(email["to"]), subject: said(email["subject"]), body: said(email["body"]) } } : {}),
@@ -732,6 +734,7 @@ export function flowFromSteps(input, previous = null) {
                 ...(step.runIn !== undefined ? { runIn: step.runIn } : old?.runIn === undefined ? {} : { runIn: old.runIn }),
                 ...(step.routes !== undefined ? routesOf(step.routes) : old?.routes === undefined ? {} : { routes: old.routes }),
                 ...(step.secrets !== undefined ? step.secrets.length === 0 ? {} : { secrets: step.secrets } : old?.secrets === undefined ? {} : { secrets: old.secrets }),
+                ...((step.browser ?? old?.browser) === true ? { browser: true } : {}),
             } : {}),
             sort: kind === "sort" ? sortFromStep(step, old?.sort ?? null, find) : null,
             ...(kind === "request" ? { request: { method: step.method ?? old?.request?.method ?? "POST", url: step.url ?? old?.request?.url ?? "", headers: step.headers ?? old?.request?.headers ?? {}, body: step.body ?? old?.request?.body ?? null } } : {}),
@@ -912,7 +915,7 @@ export function flowTerms(definition, previous) {
             lines.push("Opens a pull request for the card's built result, then waits for CI.", `Checks pass → ${stage.merge === undefined ? to(stage.next) : `merges it (${stage.merge}) and deletes its branch, only when a person approved it${approval === undefined ? "" : ` at ${approval.title}`} since it was built. Then → ${to(stage.next)}`}`, `Checks fail → ${stage.onFail === null ? "waits there, naming the failing check." : `${to(stage.onFail)} The failing check is named on the card.`}`);
         }
         else if (stage.kind === "check")
-            lines.push(`Runs the project's script “${stage.script}” with no AI.`, `Passes → ${to(stage.next)}${stage.onFail === null ? " Fails → waits there." : ` Fails → ${to(stage.onFail)}`}`);
+            lines.push(`Runs the project's script “${stage.script}” with no AI.`, ...(stage.browser === true ? ["Starts a browser (Playwright's Chromium): it runs only once a person approves browser use for this flow."] : []), `Passes → ${to(stage.next)}${stage.onFail === null ? " Fails → waits there." : ` Fails → ${to(stage.onFail)}`}`);
         else if (stage.kind === "wait" && stage.wait !== undefined)
             lines.push(stage.wait.for === "hours" ? `Waits until it's between ${stage.wait.from} and ${stage.wait.to}${stage.wait.timeZone === undefined ? "" : ` (${stage.wait.timeZone})`}; cards that arrive then go straight on. Then → ${to(stage.next)}`
                 : stage.wait.for === "time" ? `Waits ${durationWords(stage.wait.minutes)}. Then → ${to(stage.next)}`

package/dist/lead-tools.js

@@ -8,6 +8,7 @@ import { dirname, join } from 'node:path';
 import { projectOutcomes, projectOutcomesPage } from './project-outcomes.js';
 import { repositoryContextRead } from './repository-context.js';
 import { assignmentCatchUp } from './assignment-brief.js';
+import { browserViewOf } from './flow-browser.js';
 import { CHAT_ACTIONS, CHAT_ACTION_FIELDS, isChatAction, prepareSharedAction, sharedActionNeedsReview, sharedActionPayload } from './chat-actions.js';
 import { conversationSkills, skillsView } from "./project-skills.js";
 import { readAcceptanceEvidence } from "./chat-acceptance.js";
@@ -39,7 +40,8 @@ import { CHAT_TASK_ACTIONS, chatTaskRun, chatTaskStamp, isChatTaskAction } from
  * projects after scrubbing; full paths and arbitrary text remain redacted.
  */
 import { Buffer } from "node:buffer";
-import { LEAD_ASK_OTHER } from "./store.js";
+import { LEAD_ASK_OTHER, refArchived } from "./store.js";
+import { releaseFactsOf, tidyDigest, tidyGroups, tidyPreview, TIDY_DEFAULT_DAYS } from "./tidy.js";
 import { hasDisguisedText, hasForbiddenControls } from "./decision.js";
 import { readVerifiedArtifact, scanForSecrets } from "./evidence.js";
 import { parseAcceptanceCriteria } from "./scope.js";
@@ -913,13 +915,19 @@ const LEAD_TOOL_HANDLERS = {
                 const active = cards.filter(one => one.state === "active"), finished = cards.filter(one => one.state !== "active").slice(-10);
                 return { ok: true, body: {
                         flow: flow.id, name: flow.name, project: repoIdOf(ctx.who, flow.repo),
+                        // Browser use (flow-browser.ts), only for a flow whose script zones start one. Names never reach the model.
+                        ...(() => {
+                            const view = browserViewOf(ctx.store, flow);
+                            return view === null ? {} : { browser: view.status === "allowed" ? "allowed: its browser zones may start Chromium (turn_off_browser stops it)"
+                                    : `${view.status === "ended" ? "approval ended: the flow or a script changed" : "not allowed"}; its browser zones wait. Propose allow_browser: a person allows it with their own password in the secure screen.` };
+                        })(),
                         steps: definition.stages.map(stage => ({
                             id: stage.id, title: stage.title, does: FLOW_KIND_WORDS[stage.kind].label, kind: stage.kind,
                             ...(stage.instructions === null ? {} : { instructions: stage.instructions.slice(0, 600) }),
                             ...(stage.kind === "task" ? { planning: stage.planning } : {}),
                             ...(stage.kind === "approval" ? { decider: stage.toOwner === true ? `the flow's owner (${flow.owner === ctx.who.name ? "you" : "someone else"})` : stage.approver === null ? "anyone who approves" : stage.approver === ctx.who.name ? "you" : "someone else" } : {}),
                             ...(stage.message === null ? {} : { message: stage.message }),
-                            ...(stage.kind === "check" ? { script: stage.script, scriptExists: stage.script !== null && ctx.store.flowScript(flow.repo, stage.script) !== null } : {}),
+                            ...(stage.kind === "check" ? { script: stage.script, scriptExists: stage.script !== null && ctx.store.flowScript(flow.repo, stage.script) !== null, ...(stage.browser === true ? { startsBrowser: true } : {}) } : {}),
                             ...(stage.kind === "update" ? { closesIssue: stage.close === true } : {}),
                             ...(stage.request === undefined ? {} : { method: stage.request.method, url: stage.request.url, headers: Object.keys(stage.request.headers), ...(stage.request.body === null ? {} : { body: stage.request.body.slice(0, 600) }) }),
                             ...(stage.email === undefined ? {} : { to: stage.email.to, subject: stage.email.subject, body: stage.email.body.slice(0, 600) }),
@@ -985,7 +993,7 @@ const LEAD_TOOL_HANDLERS = {
         },
     },
     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 subagent and its flow in one card. Subagents: propose_subagent 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. Subagents 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_subagent 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 subagent has something wrong; a rule change it suggests is a question for the operator, answered only as they say. propose_subagent add_routine puts a card on its desk on a schedule; propose_subagent 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 subagent, 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). subagents (get_subagents): an approval step with subagent (its short name) is decided by that subagent within its rules, and it hands hard ones to the step's decider; a 'subagent' step (subagent, 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.",
+        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 subagent and its flow in one card. Subagents: propose_subagent 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. Subagents 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_subagent 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 subagent has something wrong; a rule change it suggests is a question for the operator, answered only as they say. propose_subagent add_routine puts a card on its desk on a schedule; propose_subagent 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 subagent, 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). subagents (get_subagents): an approval step with subagent (its short name) is decided by that subagent within its rules, and it hands hard ones to the step's decider; a 'subagent' step (subagent, 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. allow_browser (flow): when get_flows says a flow's browser zones wait, propose allowing them to start Chromium; the operator allows it with their own password in the secure screen, never on the card. turn_off_browser (flow) stops it.",
         // An edit's kept steps may leave their kind and name to the zone they keep: they are filled in before the call is read.
         prepare: (ctx, given) => {
             const editing = given["operation"] === "edit" && Number.isSafeInteger(given["flow"]) ? ctx.store.getFlow(Number(given["flow"])) : null;
@@ -1125,7 +1133,16 @@ const LEAD_TOOL_HANDLERS = {
                         operation = "flow_trigger_remove";
                         input = pick(["trigger"]);
                         break;
-                    default: return { ok: false, message: "Choose create, edit, add_card, move_card, approve, send_back, cancel_card, comment, assign, follow, unfollow, add_trigger, pause_trigger, resume_trigger or remove_trigger." };
+                    // Browser use in the flow's script zones: a proposal only; the person allows it with their own password.
+                    case "allow_browser":
+                        operation = "flow_browser";
+                        input = pick(["flow"]);
+                        break;
+                    case "turn_off_browser":
+                        operation = "flow_browser_off";
+                        input = pick(["flow"]);
+                        break;
+                    default: return { ok: false, message: "Choose create, edit, add_card, move_card, approve, send_back, cancel_card, comment, assign, follow, unfollow, add_trigger, pause_trigger, resume_trigger, remove_trigger, allow_browser or turn_off_browser." };
                 }
                 const action = prepareSharedAction(ctx.store, ctx.who, operation, input, ctx.evidenceRoot, ctx.now);
                 const id = ctx.draft("action", { ...action });
@@ -1608,11 +1625,12 @@ const LEAD_TOOL_HANDLERS = {
                 return { ok: false, message: "search needs a word that names the work, such as a page, feature or file" };
             // A search reads further back than the newest page, then ranks by how many of the words each task's title and goal hold.
             const listed = ctx.store.taskFamiliesAdmitted(repo === null ? ctx.who.repos : [repo], false, { limit: words.length === 0 ? limit + 1 : SEARCH_FAMILIES, order: words.length === 0 ? "created" : "updated", ...(args["state"] === undefined ? {} : { states: [args["state"]] }) });
-            const families = words.length === 0 ? listed : listed
+            // A put-away task (v145) is out of every list, the lead's included.
+            const families = (words.length === 0 ? listed : listed
                 .map((one, index) => ({ one, index, hits: searchHits(words, [one.root.id, one.root.title, one.current.title, ctx.store.getScope(one.current.id)?.goal ?? "", ctx.store.getScope(one.root.id)?.goal ?? ""]) }))
                 .filter(match => match.hits > 0)
                 .sort((a, b) => b.hits - a.hits || a.index - b.index)
-                .map(match => match.one);
+                .map(match => match.one)).filter(one => !refArchived(ctx.store, one.current.refId));
             const tasks = families.slice(0, limit).map(one => ({
                 repo: `r${ctx.who.repos.indexOf(one.current.repo) + 1}`, task: one.root.id, execution: one.current.id,
                 title: one.root.title, state: one.current.state, historyProblem: one.problem, otherActive: one.otherActive.map(version => version.id),
@@ -1622,6 +1640,17 @@ const LEAD_TOOL_HANDLERS = {
             return { ok: true, body: { tasks, truncated: families.length > limit } };
         },
     },
+    tidy_preview: {
+        description: "Read-only: what Put away old tasks would put away now and why, grouped (old releases, old routine runs, resolved CI notices, finished more than `days` days ago, default 14). Only a person puts tasks away; you can't.",
+        handle: (ctx, args) => {
+            const days = typeof args["days"] === "number" ? args["days"] : TIDY_DEFAULT_DAYS;
+            const items = tidyPreview(ctx.store, ctx.now, { releases: releaseFactsOf(ctx.store), days, access: { principal: "operator", repos: ctx.who.repos, includeUnplaced: false } });
+            const digest = tidyDigest(items, days);
+            return { ok: true, body: { count: items.length, days, digest,
+                    groups: tidyGroups(items, days).map(group => ({ label: group.label, tasks: group.items.map(one => ({ task: one.taskId, title: one.title, why: one.reason })) })),
+                    apply: items.length === 0 ? "Nothing to put away." : `A person puts these away: Tasks → Put away old tasks, or \`toolroll task tidy --apply --digest ${digest}${days === TIDY_DEFAULT_DAYS ? "" : ` --days ${days}`}\`.` } };
+        },
+    },
     get_task: {
         description: "Read currentExecution, state, dispatch, history, scope, dependencies, holds, queue, attempts, decisions and whether the agent has read your notes before acting.",
         handle: (ctx, args) => {