toolroll 0.9.84 → 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/integrations-ui.js

@@ -14,7 +14,7 @@ export const INTEGRATIONS_CSS = `.integrations{max-width:760px;min-width:0}.inte
     `.integrations .integration>:not(.integration-action),.integrations .integration-body>*{grid-column:1}.integrations .integration-body{display:contents}.integrations .integration:first-of-type{border-top:0}.integrations .integration-head{margin:0;display:flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}` +
     `.integrations .integration .integration-body>*{margin-left:calc(var(--brand-mark) + 10px)}.integrations .integration-head strong{overflow-wrap:anywhere}.integrations .integration p{margin:2px 0 0;min-width:0;overflow-wrap:anywhere}` +
     `.integrations .integration-action{grid-column:2;grid-row:1 / span 3;align-self:center;margin:0}.integrations .integration-action button,.integrations .integration-action .button-link{min-height:44px;white-space:nowrap}` +
-    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
+    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet,.integrations .integration .integration-action button.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
     `.integrations .integration-fix{color:var(--so-danger)}.integrations code{overflow-wrap:anywhere}.integrations details{margin-top:4px;font-size:.8125rem}.integrations summary{cursor:pointer;padding:4px 0}` +
     `.integration-state{display:inline-flex;align-items:center;gap:6px;font-size:.75rem;font-weight:500;padding:0 8px;border-radius:5px;line-height:20px;white-space:nowrap}` +
     `.integration-state i{width:6px;height:6px;border-radius:50%;background:currentColor}` +
@@ -33,6 +33,10 @@ function action(one, csrf) {
     if (a.kind === "test") {
         return csrf === "" ? "" : postForm("/settings/integrations/test", html `<button type="submit">Send test</button>`, { attrs: { class: "integration-action" }, hidden: { key: one.key } });
     }
+    // A project's youiyoux requests: one switch for that project.
+    if (a.kind === "switch") {
+        return csrf === "" ? "" : postForm("/settings/integrations/youiyoux", html `<button type="submit"${a.on ? "" : html ` class="integration-quiet"`}>${a.label}</button>`, { attrs: { class: "integration-action" }, hidden: { repo: a.repo, on: a.on ? "1" : "0" } });
+    }
     // A command is run where Toolroll runs; a page is linked. Fix and Set up both say which.
     // Fix is the one filled action on the page; Set up stays quiet so a list of unused services doesn't shout.
     if (a.href !== null)
@@ -50,12 +54,13 @@ function row(one, csrf) {
         ? html `<span class="integration-state integration-state--checking"><i aria-hidden="true"></i>Checking</span>`
         : html `<span class="integration-state integration-state--${one.state}"><i aria-hidden="true"></i>${STATE_WORDS[one.state]}</span>`;
     const facts = [one.account, one.detail, one.credentials].filter(Boolean).join(" · ");
-    const command = one.action.kind !== "test" ? one.action.command : null;
-    const fix = one.action.kind === "fix" ? html `<p class="integration-fix" role="status">${one.action.words}</p>` : "";
+    const command = one.action.kind === "setup" || one.action.kind === "fix" ? one.action.command : null;
+    const words = one.action.kind === "fix" || one.action.kind === "switch" ? one.action.words : null;
+    const fix = words !== null ? html `<p class="integration-fix" role="status">${words}</p>` : "";
     const run = command === null || (one.action.kind === "fix" && one.action.words.includes(command)) ? "" : html `<p class="meta">Run <code>${command}</code> on the computer running Toolroll.</p>`;
     const seen = [one.lastSuccessAt === null ? null : html `Last success ${when(one.lastSuccessAt)}`, one.usedBy.length === 0 ? null : html `Used by ${one.usedBy.join(", ")}`].filter(Boolean);
     const history = one.state === "not-set-up" || seen.length === 0 ? "" : html `<p class="meta">${joinHtml(seen, " · ")}</p>`;
-    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && one.action.kind === "fix" && one.action.words === one.lastError
+    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && words === one.lastError
         ? html `<p class="meta">Failed ${when(one.lastErrorAt ?? "")}</p>`
         : html `<details><summary>Last error ${one.lastErrorAt === null ? "" : when(one.lastErrorAt)}</summary><p class="meta">${one.lastError}</p></details>`;
     return html `<div class="integration" data-integration="${one.key}" data-state="${one.state}"><p class="integration-head">${brandMarkHtml(markFor(one), one.name, one.state === "connected")}<strong>${one.name}</strong> ${badge}</p>${action(one, csrf)}<div class="integration-body">${facts === "" ? "" : html `<p class="meta">${facts}</p>`}${fix}${run}${history}${lastError}</div></div>`;

package/dist/integrations.d.ts

@@ -18,7 +18,15 @@ export type IntegrationAction = ({
     kind: "fix";
     label: "Fix";
     words: string;
-} & IntegrationPlace);
+} & IntegrationPlace)
+/** A project's youiyoux requests: one switch, and the problem to fix when it is Broken. */
+ | {
+    kind: "switch";
+    label: "Turn off" | "Turn on";
+    repo: string;
+    on: boolean;
+    words: string | null;
+};
 export type Integration = {
     key: string;
     group: IntegrationGroup;

package/dist/integrations.js

@@ -31,6 +31,7 @@ import { LINEAR_URL, readHooksBase, readLinearKey } from "./flow-triggers.js";
 import { credentialModeOf, projectToolsOf, readToolSecrets, missingSecrets, secretsSetFor, testToolOf } from "./project-tools.js";
 import { origin, readMonitoring } from "./monitoring-settings.js";
 import { targetOf } from "./monitoring.js";
+import { youiyouxState } from "./youiyoux-intake.js";
 export const STATE_WORDS = { connected: "Connected", "not-set-up": "Not set up", broken: "Broken" };
 const NO_ACTIVITY = { okAt: null, error: null, errorAt: null, failing: false };
 const PROBE_MS = 8_000;
@@ -459,10 +460,46 @@ function combine(target, row) {
     }
     return { ...base, ...common, state: "connected", action: { kind: "test", label: "Send test" } };
 }
+/**
+ * youiyoux change requests, one row per project that uses youiyoux (youiyoux-intake.ts): Connected with how many of
+ * its requests are queued, Broken when the last pass couldn't read its folder or some of its files, or Not set up when
+ * a person turned it off; one row Not set up when no project uses it. Read from the store and the folders' presence.
+ */
+function youiyouxIntegrations(io) {
+    // In the order every other row's keys come (combine), so `--json` reads alike.
+    const row = (key, account, facts, state, action) => ({
+        key, group: "code", name: "youiyoux", usedBy: facts.usedBy ?? [], account, detail: facts.detail, checked: true, checkedAt: facts.checkedAt ?? null,
+        lastSuccessAt: facts.lastSuccessAt ?? null, lastError: facts.lastError ?? null, lastErrorAt: facts.lastErrorAt ?? null, state, action,
+    });
+    const rows = io.repos.flatMap((repo) => {
+        let state;
+        try {
+            state = youiyouxState(io.store, repo);
+        }
+        catch {
+            return [];
+        }
+        if (!state.uses)
+            return [];
+        const key = `youiyoux:${repo}`, account = basename(repo);
+        const turn = (on, words) => ({ kind: "switch", label: on ? "Turn on" : "Turn off", repo, on, words });
+        if (state.off)
+            return [row(key, account, { detail: "Turned off" }, "not-set-up", turn(true, null))];
+        const facts = { usedBy: [`Tasks in ${account}`], detail: `${plural(state.queued, "request")} queued`, checkedAt: state.checkedAt };
+        if (state.problem === null)
+            return [row(key, account, { ...facts, lastSuccessAt: state.checkedAt }, "connected", turn(false, null))];
+        const words = scrubIntegrationText(state.problem);
+        return [row(key, account, { ...facts, lastError: words, lastErrorAt: state.checkedAt }, "broken", turn(false, words))];
+    });
+    return rows.length > 0 ? rows : [row("youiyoux", null, { detail: "Starts by itself in a project with a youi.project.json" }, "not-set-up", { kind: "setup", label: "Set up", href: null, command: null })];
+}
 /** Every integration as it stands now, from files and saved history only: no network, no process, never slow. */
 export function integrationsNow(io) {
     const rows = readIntegrationChecks(io.store);
-    return targets(io).map(target => combine(target, rows.get(target.key)));
+    const list = targets(io).map(target => combine(target, rows.get(target.key)));
+    const linear = list.findIndex(one => one.key === "linear");
+    list.splice(linear + 1, 0, ...youiyouxIntegrations(io));
+    return list;
 }
 /** Run the checks (all, or the named ones), record each answer, and return the list. */
 export async function checkIntegrations(io, keys) {
@@ -512,7 +549,11 @@ export function renderIntegrations(list, secrets = null) {
                 lines.push(`${"".padEnd(width)}  last success ${whenText(one.lastSuccessAt)}${one.lastError === null ? "" : ` · last error ${whenText(one.lastErrorAt)}: ${one.lastError}`}`);
             if (one.action.kind === "fix")
                 lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}${one.action.command === null || one.action.words.includes(one.action.command) ? "" : ` (run ${one.action.command})`}`);
-            if (one.action.kind === "setup")
+            if (one.action.kind === "switch" && one.action.words !== null)
+                lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}`);
+            if (one.action.kind === "switch" && one.action.on)
+                lines.push(`${"".padEnd(width)}  Turn on: Settings → Integrations`);
+            if (one.action.kind === "setup" && (one.action.command !== null || one.action.href !== null))
                 lines.push(`${"".padEnd(width)}  Set up: ${one.action.command !== null ? `run ${one.action.command}` : `Settings (${one.action.href ?? "/settings"})`}`);
             return lines;
         }), ...note];

package/dist/landed-cleanup.d.ts

@@ -1,3 +1,4 @@
+import { type AssignmentSnapshot } from "./assignment.js";
 import type { RemoteMainRead, RemoteMains } from "./remote-main.js";
 import type { Store } from "./store.js";
 import { type Git } from "./teardown-git.js";
@@ -70,6 +71,9 @@ export type LandedCandidate = {
     targets: LandedTarget[];
     keeps: LandedKeep[];
 };
+/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
+ * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
+export declare function completionProblem(store: Store, assignment: AssignmentSnapshot, root: string): string | null;
 /**
  * Results in a project whose work landed, with what their teardown would remove and what stays. Reads only.
  * `limit` caps how many results are read against git (reconcile's bound; results read before and unchanged since

package/dist/landed-cleanup.js

@@ -237,8 +237,9 @@ function resultProblem(store, runId, head) {
         return "its result couldn't be read";
     return run.outcome === "no-change" || run.baseRevision === head ? "its result has no new work" : null;
 }
-/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. */
-function completionProblem(store, assignment, root) {
+/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
+ * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
+export function completionProblem(store, assignment, root) {
     if (assignment.state !== "ready-to-check" && assignment.state !== "complete")
         return "it needs a decision first";
     if (assignment.state === "complete")

package/dist/lead-capabilities.js

@@ -181,7 +181,8 @@ export function integrationCapabilities(list) {
     return list.map(one => {
         const link = one.group === "agents" ? "providers" : one.group === "tools" ? "tools" : INTEGRATION_LINK[one.key.replace(/^.*:/, "").toLowerCase()] ?? INTEGRATION_LINK[one.name.toLowerCase()] ?? "integrations";
         const lets = one.usedBy.length > 0 ? `use ${one.name} for ${one.usedBy.join(", ")}` : `use ${one.name}`;
-        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null;
+        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}`
+            : one.action.kind === "switch" ? (one.action.words !== null ? `Fix: ${one.action.words}` : one.action.on ? `Turned off: turn ${one.name} on in Settings → Integrations` : null) : null;
         return { name: one.name, kind: one.group, state: STATE_WORDS[one.state], ok: one.state === "connected", account: one.account, usedBy: one.usedBy, lastError: one.lastError, lets, next, link: next === null ? null : link };
     });
 }

package/dist/lead-cli.js

@@ -1,3 +1,4 @@
+import { parseFeedbackImage } from "./result-review.js";
 import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 import { closedQuestionWords } from "./decision.js";
 /**
@@ -104,7 +105,8 @@ export function proposalBlock(store, proposal, repos, number) {
         const snapshot = proposal.payload["snapshot"];
         const selected = Array.isArray(proposal.payload["notes"]) ? proposal.payload["notes"] : [];
         const notes = snapshot?.notes.filter(one => selected.includes(one.id)) ?? [];
-        return [line, ...notes.map(one => `     ${one.path === null ? "" : `${one.path}${one.line === null ? "" : `:${one.line}`}: `}${one.note}`),
+        const image = parseFeedbackImage(proposal.payload["image"]);
+        return [line, ...(image ? [`     Screenshot ${image.artifact} · result #${image.run}`] : []), ...notes.map(one => `     ${one.image ? `Screenshot ${one.image.artifact} · result #${one.image.run}: ` : ""}${one.path === null ? "" : `${one.path}${one.line === null ? "" : `:${one.line}`}: `}${one.note}`),
             proposal.payload["operation"] === "revise" ? "     Creates a revision of the same task; approval is separate." : "     Saves feedback; no work starts."];
     }
     return proposal.kind === "answer" ? [line, ...answerContextLines(store, proposal.payload)] : [line];

package/dist/lead-tools.d.ts

@@ -1,3 +1,4 @@
+import { type FeedbackImage } from "./result-review.js";
 import { type CommitmentChannel } from "./lead-commitments.js";
 import { type Integration } from "./integrations.js";
 import type { AuthMode } from "./keys.js";
@@ -23,6 +24,7 @@ export type LeadToolContext = {
         step: number;
         snapshot: ReviewSnapshot;
     }>;
+    replyImage?: FeedbackImage;
     /** Where evidence lives, when the surface knows — a scout's report reads from here. */
     evidenceRoot?: string;
     /** Records the screenshots this turn selected, under the turn, for a channel that delivers files; returns how many are recorded. Absent: nothing durable is kept. */