toolroll 0.9.65 → 0.9.67

package/dist/live-terminal.js

@@ -19,8 +19,6 @@ export const MAX_LIVE_TERMINALS = 8;
 export const MAX_KEPT_TERMINALS = 16;
 /** At most this many pages attached to one session (a desktop, a phone, a spare tab or two). */
 export const MAX_VIEWERS = 4;
-/** Raw output kept per session for a page that attaches later. */
-export const SCROLLBACK_BYTES = 1024 * 1024;
 /** After SIGHUP, the terminal's processes have this long before SIGKILL. */
 export const CLOSE_GRACE_MS = 2_000;
 /** Typed input not yet read by the program, per terminal: past this, more is refused until it reads. */
@@ -70,37 +68,45 @@ export function loadPtySpawn() {
         return null;
     }
 }
-/** Raw output, oldest dropped first, never more than `cap` bytes. */
-export class Scrollback {
-    cap;
-    chunks = [];
-    size = 0;
-    constructor(cap = SCROLLBACK_BYTES) {
-        this.cap = cap;
-    }
-    push(chunk) {
-        if (chunk.length >= this.cap) {
-            this.chunks = [chunk.subarray(chunk.length - this.cap)];
-            this.size = this.cap;
-            return;
-        }
-        this.chunks.push(chunk);
-        this.size += chunk.length;
-        while (this.size > this.cap) {
-            const first = this.chunks[0];
-            const over = this.size - this.cap;
-            if (first.length <= over) {
-                this.chunks.shift();
-                this.size -= first.length;
-            }
-            else {
-                this.chunks[0] = first.subarray(over);
-                this.size -= over;
-            }
+/** How many lines above the screen a terminal keeps for a page that attaches later. */
+export const SCREEN_SCROLLBACK_LINES = 5000;
+const require = createRequire(import.meta.url);
+/**
+ * The terminal as a page would see it now: every byte the program writes is parsed by a headless xterm here, so a page
+ * that attaches later gets the screen, its scrollback and its modes (the alternate screen of a full-screen program, the
+ * cursor, colours, bracketed paste, mouse reporting) — never a replay of raw output cut at an arbitrary byte, which
+ * could split an escape sequence or redraw a full-screen program garbled.
+ */
+export class ScreenMirror {
+    lines;
+    terminal;
+    serializer;
+    constructor(cols, rows, lines = SCREEN_SCROLLBACK_LINES) {
+        this.lines = lines;
+        const { Terminal } = require("@xterm/headless");
+        const { SerializeAddon } = require("@xterm/addon-serialize");
+        this.terminal = new Terminal({ cols, rows, scrollback: lines, allowProposedApi: true });
+        this.serializer = new SerializeAddon();
+        this.terminal.loadAddon(this.serializer);
+    }
+    write(data) { this.terminal.write(data); }
+    resize(cols, rows) { try {
+        this.terminal.resize(cols, rows);
+    }
+    catch { /* sizes are clamped before this */ } }
+    /** The screen as of this call (after everything written before it), handed to `done` once parsed. */
+    snapshot(done) {
+        this.terminal.write("", () => { let screen = ""; try {
+            screen = this.serializer.serialize({ scrollback: this.lines });
         }
+        catch {
+            screen = "";
+        } done(screen); });
+    }
+    dispose() { try {
+        this.terminal.dispose();
     }
-    bytes() { return Buffer.concat(this.chunks, this.size); }
-    get length() { return this.size; }
+    catch { /* already */ } }
 }
 const NO_LEDGER = { reserve() { }, running() { }, release() { }, forget() { } };
 export class TerminalError extends Error {
@@ -237,7 +243,7 @@ export class TerminalHost {
             }
             let resolveExited;
             const session = { id, owner, generation, repo, program, branch, worktree, startedAt: this.clock().toISOString(), endedAt: null, exit: null, endedBy: null, cleanup: null,
-                pty, leader: pty.pid, tty: pty.tty, known: new Map(), exitedAt: null, worktreeReal: realpathSync(worktree), startedMs: Date.now(), residentsOnly: false, residentsSeen: new Map(), cols, rows, scrollback: new Scrollback(this.options.scrollbackBytes), viewers: new Set(), closing: null,
+                pty, leader: pty.pid, tty: pty.tty, known: new Map(), exitedAt: null, worktreeReal: realpathSync(worktree), startedMs: Date.now(), residentsOnly: false, residentsSeen: new Map(), cols, rows, screen: new ScreenMirror(cols, rows, this.options.scrollbackLines), viewers: new Set(), closing: null,
                 exited: new Promise(resolve => { resolveExited = resolve; }) };
             this.sessions.set(id, session);
             this.ledger.running(id);
@@ -246,7 +252,7 @@ export class TerminalHost {
             pty.onData(data => {
                 this.noteSoon();
                 const chunk = Buffer.from(data, "utf8");
-                session.scrollback.push(chunk);
+                session.screen.write(data);
                 for (const viewer of session.viewers) {
                     try {
                         viewer.output(chunk);
@@ -280,21 +286,50 @@ export class TerminalHost {
                 this.ledger.release(id, null);
         }
     }
-    /** Attach a page: it gets the scrollback, then `hello`, then live output. Returns its detach. */
+    /**
+     * Attach a page: it gets the screen as it is now (ScreenMirror), then `hello`, then live output — what the program
+     * writes meanwhile is held and sent after the screen, in order. Returns its detach.
+     */
     attach(id, viewer) {
         const session = this.sessions.get(id);
         if (session === undefined)
             throw new TerminalError("No such terminal.");
         if (session.viewers.size >= MAX_VIEWERS)
             throw new TerminalError(`This terminal is open in ${MAX_VIEWERS} places already. Close one of them.`);
-        const replay = session.scrollback.bytes();
-        if (replay.length > 0)
-            viewer.output(replay);
-        viewer.control({ t: "hello", cols: session.cols, rows: session.rows, program: session.program, ended: session.endedAt !== null });
-        if (session.exit !== null)
-            viewer.control({ t: "exit", code: session.exit.code, signal: session.exit.signal });
-        session.viewers.add(viewer);
-        return () => { session.viewers.delete(viewer); };
+        const held = [];
+        let live = false;
+        const gate = {
+            output: data => { if (live)
+                viewer.output(data);
+            else
+                held.push({ output: data }); },
+            control: message => { if (live)
+                viewer.control(message);
+            else
+                held.push({ control: message }); },
+        };
+        session.viewers.add(gate);
+        session.screen.snapshot(screen => {
+            if (!session.viewers.has(gate))
+                return;
+            try {
+                if (screen !== "")
+                    viewer.output(Buffer.from(screen, "utf8"));
+                viewer.control({ t: "hello", cols: session.cols, rows: session.rows, program: session.program, ended: session.endedAt !== null });
+                if (session.exit !== null && !held.some(one => "control" in one && one.control.t === "exit"))
+                    viewer.control({ t: "exit", code: session.exit.code, signal: session.exit.signal });
+                for (const one of held) {
+                    if ("output" in one)
+                        viewer.output(one.output);
+                    else
+                        viewer.control(one.control);
+                }
+            }
+            catch { /* the viewer's own close handles it */ }
+            held.length = 0;
+            live = true;
+        });
+        return () => { session.viewers.delete(gate); };
     }
     /** How many pages are attached now. */
     viewerCount(id) { return this.sessions.get(id)?.viewers.size ?? 0; }
@@ -319,6 +354,7 @@ export class TerminalHost {
             session.pty.resize(session.cols, session.rows);
         }
         catch { /* it exited between */ }
+        session.screen.resize(session.cols, session.rows);
     }
     noteTimer = null;
     /** Activity (output, typing) usually means a command started: note processes shortly after, at most every 250 ms. */
@@ -487,6 +523,7 @@ export class TerminalHost {
             catch { /* gone */ }
         }
         session.viewers.clear();
+        session.screen.dispose();
         const result = await (this.options.git ?? teardownGit())(session.repo, ["worktree", "remove", "--force", "--", session.worktree]);
         this.options.record?.("remove", this.summary(session));
         if (result.code !== 0 && existsSync(session.worktree)) {

package/dist/operate.d.ts

@@ -162,3 +162,5 @@ export declare function readUpConsoleUrl(dir: string): string | null;
  * missing credentials stay a usage refusal, exactly as before.
  */
 export declare const PROPOSALS_ACTIONS: readonly ["list", "confirm", "dismiss"];
+/** The value flags a verb reads under a global switch's name, for parseOperateArgs. */
+export declare function ownValueFlags(command: string, argv: readonly string[]): ReadonlySet<string> | undefined;

package/dist/operate.js

@@ -111,6 +111,7 @@ import { BRANCH_PREFIX, envTwins, envValue, existingOrFirst, taskBranches } from
 import { claimActor, currentActor, withActor } from "./actor.js";
 import { parseLeadToken } from "./api-tokens.js";
 import { MAX_NETWORK_HOSTS, normalizeHost } from "./egress.js";
+import { isWritesMode, writesWords } from "./writes-mode.js";
 import { CLI_PASSWORD_SOURCE, withPasswordSource } from "./sign-in-guard.js";
 import { admissionRecorded, admitProject, commandLineActor } from "./project-admission.js";
 import { leadClaim, leadSay, noteLeadWork } from "./lead-voice.js";
@@ -260,6 +261,10 @@ export const OPERATE_HELP = `toolroll — operating the queue
   toolroll project network --repo <p> [--allow h,…] [--remove h,…] [--open|--allowlist] [--local any|none]
                                         what the project's builds may reach on the network; an approver changes it
                                         (new scopes seal it; approved ones keep theirs)
+  toolroll project writes --repo <p> [workspace|anywhere]
+                                        where the project's builds may write: only their checkout, caches and temp
+                                        (workspace, the default), or anywhere outside Toolroll's fenced folders;
+                                        an approver changes it (new scopes seal it; approved ones keep theirs)
   toolroll config unconfined-agents [allow|refuse]
                                         whether builds run where this machine can't confine them (instance operator)
   toolroll project concurrency [<n>] --repo <p>
@@ -688,6 +693,8 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     "no-open", "remove", "no-verify", "no-follow", "end", "report", "off", "tmux",
     "self-heal", "plan-auto", "chat-approve", "full-access", "repair-auto", "review-retry-auto", "no-local",
     "html", "csv", "alerts-only",
+    // project network: what its builds may reach (--open | --allowlist).
+    "open", "allowlist",
     // v105: the full export.
     "zip",
     // Settings → Integrations: the last checks, without checking again.
@@ -709,6 +716,9 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     // task steer: pause the running Claude build, then send the note.
     "now",
 ]);
+/** `project network` reads --remove <hosts> and --local any|none as values, where every other verb's --remove and
+ * --local are switches. */
+const PROJECT_NETWORK_VALUE_FLAGS = new Set(["remove", "local"]);
 export function parseOperateArgs(argv, ownValues = new Set()) {
     const positional = [];
     const flags = new Map();
@@ -767,7 +777,7 @@ export async function runOperate(command, argv, write, options = {}) {
     return withPasswordSource(CLI_PASSWORD_SOURCE, () => rememberedLogin.run({ login: null }, () => runOperateLocal(command, argv, write, options)));
 }
 async function runOperateLocal(command, argv, write, options = {}) {
-    const parsed = parseOperateArgs(argv, command === "flows" ? FLOWS_VALUE_FLAGS : undefined);
+    const parsed = parseOperateArgs(argv, ownValueFlags(command, argv));
     // A parse error precedes the flags map, so JSON mode is read from the raw
     // argv — the envelope contract holds even for the earliest refusal.
     if ("error" in parsed)
@@ -979,7 +989,7 @@ export async function runOperateAs(argv, opts) {
     const scope = REMOTE_SCOPES.get(row.invocation);
     if (row.remote !== "yes" || scope === undefined)
         return refuse("not-remote", REMOTE_MESSAGES.no);
-    const parsed = parseOperateArgs(rest, root === "flows" ? FLOWS_VALUE_FLAGS : undefined);
+    const parsed = parseOperateArgs(rest, ownValueFlags(root, rest));
     if ("error" in parsed)
         return refuse("usage", parsed.error);
     // The parser's positionals must spell the same row (a value flag can't hide a subcommand).
@@ -1159,6 +1169,8 @@ async function dispatch(command, positional, flags, context) {
                 return projectConcurrencyCommand(positional, flags, context);
             if (positional[0] === "network")
                 return projectNetworkCommand(positional, flags, context);
+            if (positional[0] === "writes")
+                return projectWritesCommand(positional, flags, context);
             if (positional[0] === "checks")
                 return projectChecksCommand(positional, flags, context);
             if (positional[0] === "demo")
@@ -10970,6 +10982,43 @@ async function projectNetworkCommand(positional, flags, context) {
         "Scopes written from now on use this; scopes already approved keep the network they were approved with.",
     ]);
 }
+/**
+ * `project writes --repo <p> [workspace|anywhere]`: where the project's builds may write (writes-mode.ts). `workspace`:
+ * only their checkout and its Git data, their caches, their temp folder and the provider state their CLI needs;
+ * `anywhere`: anywhere outside Toolroll's fenced folders. New scopes seal it; approved ones keep theirs. Changing it is
+ * an approver's act with a password typed now, kept in the ledger as before → after.
+ */
+async function projectWritesCommand(positional, flags, context) {
+    const command = "project writes";
+    const allowed = new Set(["repo", "as", "token", "token-file", "token-env", "db", "json"]);
+    for (const name of flags.keys())
+        if (!allowed.has(name))
+            return fail(context.write, context.json, command, "usage", `--${name} is not a project writes option.`, EXIT.usage);
+    const repoFlag = text(flags, "repo");
+    const wanted = positional[1];
+    if (positional.length > 2 || repoFlag === undefined || (wanted !== undefined && !isWritesMode(wanted))) {
+        return fail(context.write, context.json, command, "usage", "Use project writes --repo <project path> [workspace | anywhere].", EXIT.usage);
+    }
+    const registered = await loadRepos(registryPathOf(context)).catch(() => ({ error: "unreadable" }));
+    const known = [...new Set([...context.store.knownRepos(), ...context.store.listProjects().map(one => one.path), ...("error" in registered ? [] : registered.repos)])];
+    const repo = known.find(one => one === repoFlag || one === resolve(repoFlag) || one === canonicalProject(repoFlag));
+    if (repo === undefined)
+        return fail(context.write, context.json, command, "not-found", "That isn't a project Toolroll knows.", EXIT.refused);
+    const words = (one) => [`${repo}: builds write ${writesWords(one)}.`];
+    const current = context.store.projectWrites(repo);
+    if (wanted === undefined)
+        return succeed(context.write, context.json, command, { repo, writes: current }, () => words(current));
+    const acting = await askCredentials(flags, context);
+    const verified = acting === null ? null : credentialApprover(context.store, acting.name, acting.token, repo);
+    if (acting === null || verified === null || !verified.ok || !context.store.accountCanAccess(acting.name, repo)) {
+        return fail(context.write, context.json, command, "refused", "An approver for this project changes where its builds may write, with their password: pass --as and --token.", EXIT.refused);
+    }
+    const changed = context.store.setProjectWrites(repo, wanted, acting.name, context.clock());
+    return succeed(context.write, context.json, command, { repo, before: changed.before, writes: changed.after }, () => [
+        ...words(changed.after),
+        "Scopes written from now on use this; scopes already approved keep what they were approved with.",
+    ]);
+}
 /** `config unconfined-agents [allow|refuse]`: whether a build may run on a machine that can't confine it at the OS
  * (no macOS sandbox, no working bubblewrap). Refused unless an instance operator allows it, with a password. */
 async function unconfinedAgentsCommand(positional, flags, context) {
@@ -11876,3 +11925,12 @@ function databaseFailure(write, json, command, file, error) {
         return fail(write, json, command, "database", describe(error), EXIT.failed);
     return fail(write, json, command, "database-busy", `The database ${file} stayed busy for ${CONCURRENT_WRITER_WAIT_MS / 1_000} seconds. Wait for the other Toolroll process to finish, then try again.`, EXIT.failed);
 }
+// Last in the file, so the password tripwire's function positions (password-freshness.test.ts) stay as reviewed.
+/** The value flags a verb reads under a global switch's name, for parseOperateArgs. */
+export function ownValueFlags(command, argv) {
+    if (command === "flows")
+        return FLOWS_VALUE_FLAGS;
+    if (command === "project" && argv.find(arg => !arg.startsWith("-")) === "network")
+        return PROJECT_NETWORK_VALUE_FLAGS;
+    return undefined;
+}

package/dist/project-delete-ui.d.ts

@@ -5,6 +5,7 @@
  * sign-in with the identity provider). The repository itself stays.
  */
 import type { ProjectNetwork } from "./egress.js";
+import type { WritesMode } from "./writes-mode.js";
 import { type Html } from "./html.js";
 import { type ProjectHoldings } from "./project-delete.js";
 export declare const PROJECT_DELETE_CSS: string;
@@ -44,6 +45,11 @@ export type ProjectSettingsView = {
         setting: ProjectNetwork;
         canChange: boolean;
     };
+    /** Where its builds may write (writes-mode.ts), and whether this person may change it. */
+    writes?: {
+        setting: WritesMode;
+        canChange: boolean;
+    };
 };
 /** The project's page: its path, what Toolroll holds for it, and (for an instance operator) Delete project. */
 export declare function projectSettingsHtml(view: ProjectSettingsView, notice: {

package/dist/project-delete-ui.js

@@ -14,6 +14,25 @@ export const PROJECT_DELETE_CSS = `.project-settings,.project-delete{max-width:7
     `.project-settings .build-access ul{margin:0 0 4px;padding-left:20px;font:var(--so-typography-body);color:var(--so-ink)}.project-settings .build-access li{margin:2px 0}.project-settings .build-access li .meta{color:var(--so-muted)}` +
     `.project-settings .build-access a.manage-tools{display:inline-flex;align-items:center;justify-content:center;min-height:44px;margin-top:4px;padding:0 14px;white-space:nowrap;background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line);border-radius:var(--so-radius-md);font:var(--so-typography-label);text-decoration:none}` +
     `.project-settings .build-access a.manage-tools:hover{background:var(--so-raised)}.project-settings .build-access a.manage-tools:focus-visible,.project-settings .build-access summary:focus-visible{outline:2px solid var(--so-ink);outline-offset:2px}`;
+/** Where builds may write, said plainly; an approver changes it with their password. */
+function writesHtml(view) {
+    const writes = view.writes;
+    if (writes === undefined)
+        return "";
+    const said = writes.setting === "workspace"
+        ? html `<p>Builds write <strong>only their own checkout</strong>, its caches and its temp folder. Your shell profile, login items, agent settings and the repository's Git config and hooks stay as they are.</p>`
+        : html `<p>Builds may write <strong>anywhere</strong> outside Toolroll's own folders, your credentials and other projects.</p>`;
+    if (!writes.canChange)
+        return html `<section class="build-access writes-setting" id="writes" aria-labelledby="writes-title"><h2 id="writes-title">Where builds write</h2>${said}<p class="meta">An approver for this project can change this.</p></section>`;
+    const option = (value, label, detail) => html `<label class="check"><input type="radio" name="writes" value="${value}"${writes.setting === value ? html ` checked` : ""}> ${label}</label><p class="meta">${detail}</p>`;
+    const form = postForm("/settings/project/writes", html `
+    ${option("workspace", "Only their workspace (recommended)", "The checkout and its Git data, the project's own package caches, the build's temp folder, and what its agent needs to keep its session.")}
+    ${option("anywhere", "Anywhere outside Toolroll's fenced folders", "For a project whose tools must write elsewhere in your home folder or the shared temp folder. Credentials, Toolroll's own folders and other projects stay fenced.")}
+    <p class="meta">Tasks scoped from now on use this; tasks already approved keep what they were approved with.</p>
+    ${reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>`)}
+    <button type="submit">Save</button>`, { hidden: { repo: view.repo } });
+    return html `<section class="build-access writes-setting" id="writes" aria-labelledby="writes-title"><h2 id="writes-title">Where builds write</h2>${said}<details><summary>Change</summary>${form}</details></section>`;
+}
 /** Network: what the project's builds may reach, said plainly; an approver changes it with their password. */
 function networkHtml(view) {
     const network = view.network;
@@ -92,7 +111,7 @@ export function projectSettingsHtml(view, notice) {
     const remote = html `<section class="build-access recorded-remote" aria-labelledby="recorded-remote-title"><h2 id="recorded-remote-title">Recorded remote</h2>${view.remoteUrl
         ? html `<p class="path">${view.remoteUrl}</p>`
         : html `<p>No remote recorded. Landed work waits for your review.</p>`}<details><summary>Change remote</summary><p>An owner or instance operator can run:</p><p class="path">toolroll repos add &lt;project&gt; --remote &lt;url&gt;</p></details></section>`;
-    const head = html `${note(notice)}<p class="path">${view.repo}</p>${held}${remote}${buildsHtml(view)}${accessHtml(view)}${networkHtml(view)}${liveViewHtml(view)}`;
+    const head = html `${note(notice)}<p class="path">${view.repo}</p>${held}${remote}${buildsHtml(view)}${accessHtml(view)}${networkHtml(view)}${writesHtml(view)}${liveViewHtml(view)}`;
     if (!view.canDelete)
         return html `<section class="project-settings">${head}<p class="meta">An instance operator can delete a project.</p></section>`;
     const body = view.running.length > 0

package/dist/release-adapters.d.ts

@@ -55,6 +55,12 @@ export type AdapterOptions = {
     sleep?: (ms: number) => Promise<void>;
 };
 export declare function releaseAdapters(options: AdapterOptions): ReleaseAdapters;
+/**
+ * Whether a workflow's triggers (its top-level `on:` as a name, a list or a map) include a change to the repository.
+ * A file that doesn't parse, or whose triggers aren't one of those shapes, counts as running, so the release waits
+ * rather than skipping checks it owes.
+ */
+export declare function workflowRunsOnChange(text: string): boolean;
 /** The formula with its first `url` and `sha256` replaced; anything else is left exactly as it was. */
 export declare function bumpFormula(text: string, url: string, sha256: string): string;
 export {};

package/dist/release-adapters.js

@@ -10,6 +10,7 @@ import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, delimiter, dirname, join } from "node:path";
 import { createRequire } from "node:module";
+import { parse as parseYaml } from "yaml";
 // Loaded on first use, like the store: a static import prints Node's SQLite warning before the CLI can quiet it.
 const sqlite = () => createRequire(import.meta.url)("node:sqlite");
 import { activeUpdateWork } from "./desktop-update-gate.js";
@@ -225,7 +226,14 @@ export function releaseAdapters(options) {
                     return;
                 if (current !== head)
                     throw new Error(`${branch} moved after merging; its new head was not deleted.`);
-                await must(git("push", `--force-with-lease=${ref}:${head}`, "origin", `:${ref}`), `deleting merged branch ${branch}`);
+                const pushed = await git("push", `--force-with-lease=${ref}:${head}`, "origin", `:${ref}`);
+                if (pushed.code === 0)
+                    return;
+                // GitHub may delete a merged branch itself between the look and the push; gone is what was wanted.
+                const after = (await must(git("ls-remote", "origin", ref), "git ls-remote")).trim().split(/\s+/)[0] || null;
+                if (after === null)
+                    return;
+                throw new Error(`deleting merged branch ${branch} failed: ${pushed.stderr.trim() || `exit ${pushed.code}`}`);
             },
             async tree(sha) { return (await must(git("rev-parse", `${sha}^{tree}`), `git rev-parse ${sha.slice(0, 7)}^{tree}`)).trim(); },
             async fileAt(sha, path) {
@@ -338,10 +346,10 @@ export function releaseAdapters(options) {
                 return prs.find(one => one.state === "open") ?? prs.filter(one => one.state === "merged").sort((a, b) => b.number - a.number)[0] ?? null;
             },
             async checks(repo, sha) {
-                const out = await must(gh("api", "--paginate", `repos/${repo}/commits/${sha}/check-runs?per_page=100`, "--jq", ".check_runs[] | {id, name, status, conclusion}"), "gh api check-runs");
+                const out = await must(gh("api", "--paginate", `repos/${repo}/commits/${sha}/check-runs?per_page=100`, "--jq", ".check_runs[] | {id, name, status, conclusion, app: .app.slug}"), "gh api check-runs");
                 const runs = out.split("\n").filter(Boolean).map(line => object(JSON.parse(line)));
                 // Oldest first, so a rerun's attempt is the last one listed for its name.
-                return runs.sort((a, b) => Number(a["id"]) - Number(b["id"])).map((one) => ({ name: String(one["name"]), status: String(one["status"]), conclusion: textOr(one["conclusion"]) }));
+                return runs.sort((a, b) => Number(a["id"]) - Number(b["id"])).map((one) => ({ name: String(one["name"]), status: String(one["status"]), conclusion: textOr(one["conclusion"]), app: textOr(one["app"]) }));
             },
             async merge(repo, pr, head) {
                 const merged = object(await ghJson("gh api pulls merge", "api", "-X", "PUT", `repos/${repo}/pulls/${pr}/merge`, "-f", "merge_method=squash", "-f", `sha=${head}`));
@@ -379,6 +387,37 @@ export function releaseAdapters(options) {
         },
         homebrew: {
             repo: tap,
+            async checked(head) {
+                // Only a workflow that runs on pull requests (or pushes) puts checks on the tap's change; apps that open a
+                // check suite and never run it don't count. Workflows are read as the change has them and as the tap's default
+                // branch has them (pull_request_target runs from there); a file this can't read counts as checking.
+                for (const ref of [head, await defaultBranch()]) {
+                    const listed = await gh("api", `repos/${tap}/contents/.github/workflows?ref=${encodeURIComponent(ref)}`, "--jq", ".[] | select(.type == \"file\") | .path");
+                    if (listed.code !== 0) {
+                        if (/Not Found|HTTP 404/.test(listed.stderr + listed.stdout))
+                            continue;
+                        throw new Error(`listing ${tap}'s workflows at ${ref}: ${listed.stderr.trim()}`);
+                    }
+                    for (const path of listed.stdout.split("\n").filter(Boolean)) {
+                        if (!/\.ya?ml$/.test(path))
+                            continue;
+                        const file = await gh("api", `repos/${tap}/contents/${path}?ref=${encodeURIComponent(ref)}`, "--jq", ".content");
+                        if (file.code !== 0)
+                            return true;
+                        if (workflowRunsOnChange(Buffer.from(file.stdout.replace(/\\n|\s/g, ""), "base64").toString("utf8")))
+                            return true;
+                    }
+                }
+                return false;
+            },
+            async statuses(head) {
+                // The older commit-status API, which some CI reports through instead of checks; newest first, so reversed.
+                const out = await must(gh("api", "--paginate", `repos/${tap}/commits/${head}/statuses?per_page=100`, "--jq", ".[] | {context, state}"), "gh api statuses");
+                return out.split("\n").filter(Boolean).map(line => object(JSON.parse(line))).reverse().map((one) => {
+                    const state = String(one["state"]);
+                    return { name: `status: ${String(one["context"])}`, status: state === "pending" ? "in_progress" : "completed", conclusion: state === "pending" ? null : state === "success" ? "success" : "failure" };
+                });
+            },
             async state(version) {
                 const branch = await defaultBranch();
                 const current = await formulaAt(branch);
@@ -427,6 +466,34 @@ export function releaseAdapters(options) {
     }
 }
 const brewBranch = (version) => `toolroll-${version}`;
+/** The events that put checks on a change. */
+const CHANGE_EVENTS = new Set(["pull_request", "pull_request_target", "push", "merge_group"]);
+/**
+ * Whether a workflow's triggers (its top-level `on:` as a name, a list or a map) include a change to the repository.
+ * A file that doesn't parse, or whose triggers aren't one of those shapes, counts as running, so the release waits
+ * rather than skipping checks it owes.
+ */
+export function workflowRunsOnChange(text) {
+    let parsed;
+    try {
+        parsed = parseYaml(text);
+    }
+    catch {
+        return true;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return true;
+    const workflow = parsed;
+    // YAML 1.1 readers take a bare `on` for true; either key names the triggers.
+    const on = "on" in workflow ? workflow["on"] : workflow["true"];
+    const events = typeof on === "string" ? [on]
+        : Array.isArray(on) ? on
+            : on !== null && typeof on === "object" ? Object.keys(on)
+                : null;
+    if (events === null || !events.every(one => typeof one === "string"))
+        return true;
+    return events.some(one => CHANGE_EVENTS.has(one));
+}
 /** The formula with its first `url` and `sha256` replaced; anything else is left exactly as it was. */
 export function bumpFormula(text, url, sha256) {
     if (!/^\s*url "[^"]*"/m.test(text) || !/^\s*sha256 "[0-9a-f]{64}"/m.test(text))

package/dist/release.d.ts

@@ -17,7 +17,7 @@
  * skipped or failed never merges. merge
  * squash-merges with the head pinned to the gated commit, tree proves main's new commit has exactly the gated tree,
  * and only then tag pushes the version tag, whose macOS matrix must pass before npm publication (publish.yml). publish
- * waits for npm, the GitHub release and the macOS checks; homebrew updates the tap's formula and merges it.
+ * waits for npm, the GitHub release and the macOS checks; homebrew updates the tap's formula and merges it (after its checks, when the tap runs any).
  *
  * A private journal (mode 0600, written whole then renamed) records what each step is about to do before it does
  * anything outside this machine, and what it saw after. A stop — a time limit, a failure, a crash, Ctrl-C — leaves the
@@ -38,10 +38,12 @@ export type ReleaseStep = typeof RELEASE_STEPS[number];
 type WaitingStep = "approval" | "check" | "quiet" | "deploy" | "ci" | "publish" | "homebrew";
 /** How long each waiting step may take, in minutes, before the release stops there (rerunning continues from it). */
 export declare const RELEASE_LIMITS: Readonly<Record<WaitingStep, number>>;
+/** One check attempt; `app` is the GitHub App that made it (github-actions for a workflow), when known. */
 export type CheckRun = {
     name: string;
     status: string;
     conclusion: string | null;
+    app?: string | null;
 };
 export type PullRequest = {
     number: number;
@@ -195,6 +197,10 @@ export type ReleaseAdapters = {
     };
     homebrew: {
         repo: string;
+        /** Whether any of the tap's workflows, at the change or its base, runs on a change; if none does, no checks are owed. */
+        checked(head: string): Promise<boolean>;
+        /** The change's commit statuses, as check runs oldest first. */
+        statuses(head: string): Promise<CheckRun[]>;
         state(version: string): Promise<HomebrewState>;
         propose(version: string): Promise<{
             pr: number;

package/dist/release.js

@@ -17,7 +17,7 @@
  * skipped or failed never merges. merge
  * squash-merges with the head pinned to the gated commit, tree proves main's new commit has exactly the gated tree,
  * and only then tag pushes the version tag, whose macOS matrix must pass before npm publication (publish.yml). publish
- * waits for npm, the GitHub release and the macOS checks; homebrew updates the tap's formula and merges it.
+ * waits for npm, the GitHub release and the macOS checks; homebrew updates the tap's formula and merges it (after its checks, when the tap runs any).
  *
  * A private journal (mode 0600, written whole then renamed) records what each step is about to do before it does
  * anything outside this machine, and what it saw after. A stop — a time limit, a failure, a crash, Ctrl-C — leaves the
@@ -454,15 +454,28 @@ export async function runRelease(options, adapters) {
                         const proposed = state;
                         j.homebrew = { pr: proposed.pr, head: proposed.head, merged: false };
                         save();
+                        // Whatever checks do register are always judged; an empty set passes only for a tap whose workflows never run
+                        // on a change, and only when it's still empty a poll later.
+                        const checked = await brew.checked(proposed.head);
+                        let emptyLooks = 0;
                         await waitFor("homebrew", `the Homebrew change's checks (${brew.repo} #${proposed.pr})`, async () => {
-                            const runs = await adapters.github.checks(brew.repo, proposed.head);
+                            // Check runs and commit statuses are judged apart, so neither stands in for the other or hides its failure.
+                            // Two apps may name a check alike; each app's attempts stand for themselves.
+                            const runs = (await adapters.github.checks(brew.repo, proposed.head)).map(run => ({ ...run, name: `${run.app ?? "unknown app"}: ${run.name}` }));
+                            const statuses = await brew.statuses(proposed.head);
+                            const verdicts = [runs, statuses].filter(one => one.length > 0).map(one => checksVerdict(one, [...new Set(one.map(run => run.name))]));
+                            const failed = verdicts.flatMap(one => one.state === "failed" ? one.failed : []);
+                            if (failed.length > 0)
+                                throw new Stop("homebrew-failed", `The Homebrew change's checks failed: ${failed.join(", ")}.`);
+                            if (verdicts.some(one => one.state === "pending"))
+                                return null;
                             // GitHub registers checks asynchronously; an empty set says nothing about success.
-                            if (runs.length === 0)
+                            // A workflow is owed: only its own run counts, not another app's green check.
+                            if (checked && !runs.some(run => run.app === "github-actions"))
                                 return null;
-                            const verdict = checksVerdict(runs, [...new Set(runs.map(one => one.name))]);
-                            if (verdict.state === "failed")
-                                throw new Stop("homebrew-failed", `The Homebrew change's checks failed: ${verdict.failed.join(", ")}.`);
-                            return verdict.state === "passed" ? true : null;
+                            if (runs.length === 0 && statuses.length === 0)
+                                return ++emptyLooks >= 2 ? true : null;
+                            return true;
                         });
                         await brew.merge(proposed.pr, proposed.head);
                     }

package/dist/result-follow-ups.js

@@ -9,6 +9,7 @@
  *
  * Add tests files a small task, unapproved like any other filing, to write
  * tests for that change. */
+import { fencedCheckoutCommands } from "./invoke.js";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -201,7 +202,7 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
             let ready = true;
             if (setup !== null) {
                 const shell = approvedCommandShell(setup.command);
-                const prepared = await runWithIsolatedDatabase(runner, shell.file, shell.args, { cwd: checkout, timeoutMs: setup.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
+                const prepared = await runWithIsolatedDatabase(fencedCheckoutCommands(store, target.repo, checkout, runner), shell.file, shell.args, { cwd: checkout, timeoutMs: setup.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
                 note("Approved project setup", setup.command, prepared);
                 if (prepared.code !== 0 || prepared.timedOut || prepared.notFound) {
                     ready = false;
@@ -216,7 +217,7 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
                 }
                 else {
                     const shell = approvedCommandShell(live.command);
-                    const ran = await runWithIsolatedDatabase(runner, shell.file, shell.args, { cwd: checkout, timeoutMs: live.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
+                    const ran = await runWithIsolatedDatabase(fencedCheckoutCommands(store, target.repo, checkout, runner), shell.file, shell.args, { cwd: checkout, timeoutMs: live.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
                     note(`${CHECK_LEVEL_WORDS[target.level]} check`, live.command, ran);
                     result = ran.timedOut ? { ran: false, failure: "The check ran out of time." } : ran.notFound ? { ran: false, failure: "The check couldn't start." } : { ran: true, exitCode: ran.code };
                 }