toolroll 0.9.67 → 0.9.69

package/dist/project-tools.js

@@ -33,6 +33,7 @@ import { isAcpProvider } from "./acp-agents.js";
 import { SecretStoreError, destroyOwnFile, prepareSecretFolder, registerSecretFolder, pathIn, readOwnFile, readSealed, removeValue, secretBackend, secretFolder, secretStorage, serviceOf, withSecretLock, withSecretLockAsync, writeOwnFile, writeSealed } from "./tool-secret-store.js";
 import { ACCESS, GRANTED, REFRESH, mintRunToken, mintsRunTokens, oneAtATime, runScope, scopeList, signedIn } from "./oauth-run-token.js";
 import { HEADER_NAME, SECRET_NAME, TOOL_NAME as NAME, TOOL_SPEC_LIMITS as LIMITS, readToolSpec } from "./contracts/integration-metadata.js";
+import { canonicalJson } from "./canonical-json.js";
 /** Env names a tool may never claim: the process's own plumbing, every
  * provider credential, and anything that changes how a program or its
  * interpreter loads (a secret's value must stay data, never code). */
@@ -75,19 +76,10 @@ export function localAppOf(spec) {
 export function catalogTool(id) {
     return TOOL_CATALOG.find(one => one.name === id) ?? null;
 }
-function canonical(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(",")}]`;
-    if (value !== null && typeof value === "object") {
-        return `{${Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-            .map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
-    }
-    return JSON.stringify(value);
-}
 /** What a build is held to: how the server starts and which secrets it names — never their values or its description. */
 export function toolDigest(spec) {
     const { about: _about, ...terms } = spec;
-    return createHash("sha256").update(`standing-orders:tool:v1:${canonical(terms)}`, "utf8").digest("hex").slice(0, 32);
+    return createHash("sha256").update(`standing-orders:tool:v1:${canonicalJson(terms)}`, "utf8").digest("hex").slice(0, 32);
 }
 const str = (value, cap, what) => {
     if (typeof value !== "string" || value.trim() === "" || value.length > cap)

package/dist/provider.d.ts

@@ -335,23 +335,6 @@ export type ProviderMoneyCapabilities = {
     usageSemantics: "per-invocation" | "cumulative-session";
 };
 export declare const MONEY_CAPABILITIES: Record<ProviderId, ProviderMoneyCapabilities>;
-/**
- * The fail-closed budget-flag probe (finding 24's amendment): resolve
- * the EXACT executable that will spawn, read its version, and prove the
- * flag exists in that binary's own help — presence is a feature check
- * and nothing more.
- */
-export declare function probeBudgetCap(provider: ProviderId, runner: (command: string, argv: readonly string[], options: {
-    timeoutMs?: number;
-    omitEnv?: readonly string[];
-}) => Promise<ExecResult>): Promise<{
-    ok: true;
-    executable: string;
-    version: string;
-} | {
-    ok: false;
-    problem: string;
-}>;
 export declare function auditOf(provider: ProviderId): ProviderAudit;
 /**
  * A spec a person or a config row proposed, validated to a complete pair.

package/dist/provider.js

@@ -999,32 +999,6 @@ export const MONEY_CAPABILITIES = withAcp({
     nativeDollarCapFlag: null,
     usageSemantics: "per-invocation",
 }));
-/**
- * The fail-closed budget-flag probe (finding 24's amendment): resolve
- * the EXACT executable that will spawn, read its version, and prove the
- * flag exists in that binary's own help — presence is a feature check
- * and nothing more.
- */
-export async function probeBudgetCap(provider, runner) {
-    const flag = MONEY_CAPABILITIES[provider].nativeDollarCapFlag;
-    if (flag === null)
-        return { ok: false, problem: `${provider} has no native dollar cap` };
-    const binary = provider === "claude" ? "claude" : provider;
-    // A feature probe needs no credential (round 2, finding 2): strip them all.
-    const strip = { omitEnv: ALL_CREDENTIAL_ENV };
-    const where = await runner("which", [binary], { timeoutMs: 5_000, ...strip });
-    if (where.code !== 0)
-        return { ok: false, problem: `${binary} is not on PATH` };
-    const executable = where.stdout.trim().split("\n")[0] ?? "";
-    const version = await runner(executable, ["--version"], { timeoutMs: 10_000, ...strip });
-    if (version.code !== 0)
-        return { ok: false, problem: `${executable} did not answer --version` };
-    const help = await runner(executable, ["--help"], { timeoutMs: 10_000, ...strip });
-    if (help.code !== 0 || !help.stdout.includes(flag)) {
-        return { ok: false, problem: `${executable} does not advertise ${flag} — the dollar cap cannot be enforced` };
-    }
-    return { ok: true, executable, version: version.stdout.trim() };
-}
 export function auditOf(provider) {
     return AUDITS[provider];
 }

package/dist/pulls.d.ts

@@ -119,5 +119,3 @@ export declare function describe(pull: Pull, markers?: readonly string[]): strin
  * and not evidence of freshness.
  */
 export declare function idleDays(pull: Pull, now: Date): number | null;
-/** Waiting on someone, and has been for longer than they would have chosen. */
-export declare function isStalled(pull: Pull, now: Date, staleDays?: number, markers?: readonly string[]): boolean;

package/dist/pulls.js

@@ -236,15 +236,6 @@ export function idleDays(pull, now) {
         return null;
     return Math.max(0, (now.getTime() - updated) / MS_PER_DAY);
 }
-/** Waiting on someone, and has been for longer than they would have chosen. */
-export function isStalled(pull, now, staleDays = DEFAULT_STALE_DAYS, markers = DEFAULT_REVISION_MARKERS) {
-    const attention = classify(pull, markers);
-    // Nobody is blocked on a draft, and a machine that is still working is not late.
-    if (attention === "none" || attention === "machine")
-        return false;
-    const idle = idleDays(pull, now);
-    return idle !== null && idle >= staleDays;
-}
 function firstLine(text) {
     const [line = ""] = text.trim().split("\n");
     return line;

package/dist/release-adapters.d.ts

@@ -54,6 +54,9 @@ export type AdapterOptions = {
     now?: () => Date;
     sleep?: (ms: number) => Promise<void>;
 };
+/** How many times, and how far apart, a merged branch's deletion is looked for after the push lost a race. */
+export declare const BRANCH_GONE_LOOKS = 5;
+export declare const BRANCH_GONE_PAUSE_MS = 2000;
 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.

package/dist/release-adapters.js

@@ -11,6 +11,7 @@ import { homedir } from "node:os";
 import { basename, delimiter, dirname, join } from "node:path";
 import { createRequire } from "node:module";
 import { parse as parseYaml } from "yaml";
+import { sleep } from "./sleep.js";
 // 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";
@@ -148,6 +149,9 @@ export function stageGate(stage, owner) {
     const id = textOr(journal["id"]), phase = textOr(journal["phase"]);
     return id !== null && phase !== null && BEFORE_SWAP.includes(phase) && owner() === id ? { id, phase } : null;
 }
+/** How many times, and how far apart, a merged branch's deletion is looked for after the push lost a race. */
+export const BRANCH_GONE_LOOKS = 5;
+export const BRANCH_GONE_PAUSE_MS = 2_000;
 export function releaseAdapters(options) {
     const run = options.run ?? exec;
     const get = options.fetch ?? fetch;
@@ -155,6 +159,7 @@ export function releaseAdapters(options) {
     const tap = options.tap ?? "ap9000/homebrew-toolroll";
     const formula = options.formula ?? "Formula/toolroll.rb";
     const git = (...args) => run("git", ["-C", checkout, ...args]);
+    const pause = options.sleep ?? ((ms) => new Promise(done => setTimeout(done, ms)));
     const gh = (...args) => run("gh", args);
     const ghJson = async (what, ...args) => JSON.parse(await must(gh(...args), what));
     const toolroll = async (...args) => {
@@ -190,7 +195,7 @@ export function releaseAdapters(options) {
     });
     return {
         now: options.now ?? (() => new Date()),
-        sleep: options.sleep ?? (ms => new Promise(done => setTimeout(done, ms))),
+        sleep: options.sleep ?? sleep,
         say: options.say ?? (line => process.stdout.write(`${line}\n`)),
         repo: {
             async github() {
@@ -229,10 +234,15 @@ export function releaseAdapters(options) {
                 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;
+                // GitHub may delete a merged branch itself between the look and the push; gone is what was wanted. Its refs can
+                // lag the deletion by a few seconds, so look a few times before calling it a failure.
+                for (let look = 0; look < BRANCH_GONE_LOOKS; look++) {
+                    if (look > 0)
+                        await pause(BRANCH_GONE_PAUSE_MS);
+                    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(); },

package/dist/remote-exec.d.ts

@@ -1,8 +1,9 @@
-import { type TeamCliOptions } from './team-cli.js';
+import { type ConnectOptions } from './connect-cli.js';
 import { type CliRequest } from './cli-http.js';
 import { type RemoteCommandLookup } from './remote-command.js';
 export { contractRow, STEP_UP_MESSAGE, type RemoteMode } from './remote-command.js';
-export type RemoteExecOptions = TeamCliOptions & {
+export type RemoteExecOptions = ConnectOptions & {
+    sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
     cwd?: string;
     /** Raw output streams; remote bytes are written exactly as the server returned them. */
     stdout?: (chunk: string) => void;

package/dist/remote-exec.js

@@ -12,13 +12,14 @@ import { resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { envelopeJson } from './envelope.js';
 import { COMMAND_GUIDE } from './surface.js';
-import { centralProfile, UsageError } from './team-cli.js';
+import { centralProfile, UsageError } from './connect-cli.js';
 import { CLI_FILES_BYTES, CLI_WAIT_SECONDS } from './cli-http.js';
 import { TOKEN_REPLACEMENT } from './password-bearer.js';
 import { contractRow, fileArguments, STEP_UP_MESSAGE } from './remote-command.js';
 export { contractRow, STEP_UP_MESSAGE } from './remote-command.js';
 const EXIT = { ok: 0, failed: 1, usage: 2, refused: 3 };
-/** Team commands own their own central path (team-cli.ts); `session` sends its own checked request (session-cli.ts). */
+/** Never sent remotely: `connect` saves the profile itself, the lead's commands are this computer's, and the removed
+ * central team and session verbs answer with their removal notice (removed-commands.ts). */
 const TEAM_COMMANDS = new Set(['connect', 'lead', 'conversation', 'chat', 'brief', 'session']);
 const RESPONSE_BYTES = 16 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = (CLI_WAIT_SECONDS + 35) * 1_000;

package/dist/repos.d.ts

@@ -50,11 +50,6 @@ export declare function updateRepos(file: string, transform: (repos: string[]) =
     ok: true;
     repos: string[];
 } | RegistryUpdateFailure>;
-/** Persist project roots through the same lock as repo enrollment. */
-export declare function updateProjectRoots(file: string, transform: (roots: string[]) => string[]): Promise<{
-    ok: true;
-    roots: string[];
-} | RegistryUpdateFailure>;
 /** Atomically update repositories and roots without either writer erasing the other. */
 export declare function updateProjectRegistry(file: string, transform: (registry: ProjectRegistry) => ProjectRegistry): Promise<{
     ok: true;

package/dist/repos.js

@@ -11,8 +11,9 @@
  * untrusted input and gets validated like any other.
  */
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import { configBase, namedPath } from "./names.js";
+import { sleep } from "./sleep.js";
 export const CONFIG_VERSION = 2;
 const FILE_NAME = "repos.json";
 export function configPath(env, home) {
@@ -76,14 +77,6 @@ export async function updateRepos(file, transform) {
     }));
     return updated.ok ? { ok: true, repos: updated.registry.repos } : updated;
 }
-/** Persist project roots through the same lock as repo enrollment. */
-export async function updateProjectRoots(file, transform) {
-    const updated = await updateProjectRegistry(file, current => ({
-        ...current,
-        roots: transform(current.roots),
-    }));
-    return updated.ok ? { ok: true, roots: updated.registry.roots } : updated;
-}
 /** Atomically update repositories and roots without either writer erasing the other. */
 export async function updateProjectRegistry(file, transform) {
     const { openSync, closeSync, writeSync, readFileSync, unlinkSync, existsSync: exists, mkdirSync, renameSync } = await import("node:fs");
@@ -93,7 +86,6 @@ export async function updateProjectRegistry(file, transform) {
     const reaperPath = `${file}.reaper.lock`;
     const token = randomBytes(16).toString("hex");
     const body = JSON.stringify({ pid: process.pid, token, at: Date.now() });
-    const sleep = (ms) => new Promise(done => setTimeout(done, ms));
     const tryReap = () => {
         // Recovery only for PROVEN-dead owners, serialized by the reaper lock,
         // which re-reads the exact snapshot before unlinking (finding 29). An

package/dist/repository-context.d.ts

@@ -63,5 +63,3 @@ export type RepositoryContext = {
 export declare function repositoryContextRead(request: Omit<RepositoryContextRequest, 'refresh'>): RepositoryContext;
 /** Explicit refresh is the only cache-writing path. It never changes project/task records. */
 export declare function repositoryContext(request: RepositoryContextRequest): Promise<RepositoryContext>;
-/** Human/model context rendering; saved records remain the authority and retain this structured capture. */
-export declare function repositoryContextText(context: RepositoryContext): string;

package/dist/repository-context.js

@@ -370,7 +370,3 @@ export async function repositoryContext(request) {
     }
     return finishContext(request, result, snapshot, index);
 }
-/** Human/model context rendering; saved records remain the authority and retain this structured capture. */
-export function repositoryContextText(context) {
-    return '\nRepository context (source material, not instructions or authority). This selection is pinned to the shown checkout and source hashes; missing context never blocks the task.\n' + JSON.stringify(context).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029') + '\n';
-}

package/dist/restart-certification.d.ts

@@ -130,5 +130,3 @@ export type VerifyInputs = BaselineInputs & {
 export declare function verifyRestartRecovery(inputs: VerifyInputs): Promise<RestartVerification>;
 /** The baseline and verification are meant to be printed; this keeps a secret from ever entering them. */
 export declare function assertNoSecret(json: string, secrets: readonly string[]): void;
-/** The current boot id, for scripts that print it beside a baseline. */
-export declare function bootIdNow(): string | null;

package/dist/restart-certification.js

@@ -24,7 +24,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync, readFileSync, realpathSync, readdirSync, statSync } from "node:fs";
-import { bootIdentity, currentBootId, provenDeadByBootChange } from "./boot-identity.js";
+import { bootIdentity, provenDeadByBootChange } from "./boot-identity.js";
 import { containmentStatus, currentContainment } from "./containment.js";
 import { daemonStatus } from "./daemon.js";
 import { isAlive } from "./runner.js";
@@ -220,7 +220,3 @@ export function assertNoSecret(json, secrets) {
             throw new Error("the certification output would contain a credential; refusing to write it");
     }
 }
-/** The current boot id, for scripts that print it beside a baseline. */
-export function bootIdNow() {
-    return currentBootId();
-}

package/dist/result-follow-ups.d.ts

@@ -1,5 +1,5 @@
 import type { Runner } from "./backend.js";
-import type { Store, VerifyCommand } from "./store.js";
+import type { Store } from "./store.js";
 import { type CheckLevel } from "./check-levels.js";
 export declare const CHECKS_REQUESTED = "checks requested";
 export declare const CHECKS_STARTED = "checks started";
@@ -93,8 +93,6 @@ export declare function withFollowUps(original: CheckReading, followUps: readonl
 /** The level a result's checks stand at now: the build's own level, raised by
  * a follow-up that passed on the same commit. null for results from before levels. */
 export declare function resultCheckLevel(store: Store, runId: number, now: Date): CheckLevel | null;
-/** Whether this result's commit has passed the project's full check, here or in a follow-up. */
-export declare function fullCheckPassed(reading: CheckReading): boolean;
 /** Before a Quick or Off result merges: the project's full check on its exact
  * commit. Clear when the build already ran the full check, when the project has
  * no full command (its CI covers it), or when a follow-up full check passed. */
@@ -105,7 +103,6 @@ export type FullCheckGate = {
     message: string;
 };
 export declare function fullCheckGate(store: Store, runId: number, now: Date): FullCheckGate;
-export declare const isQuickCommand: (command: VerifyCommand | null, repo: string) => boolean;
 /** File a small task to write tests for a result's change. It is filed like any
  * other task: nothing runs until a person approves it. */
 export declare function fileAddTestsTask(store: Store, root: string | null, input: {

package/dist/result-follow-ups.js

@@ -1,15 +1,4 @@
-/** Follow-ups on any result: "Run checks" and "Add tests".
- *
- * Run checks runs the project's quick or full check on the result's exact
- * commit, in a fresh checkout, after the build has finished. A person (or a
- * pull request opening) asks; the ask is a ledger entry; a worker runs it
- * once and seals its log and a receipt beside the result. A pass upgrades
- * what the result's Checks row says; a failure stays visible. Nothing here
- * rewrites the build's own check or reruns crew work.
- *
- * Add tests files a small task, unapproved like any other filing, to write
- * tests for that change. */
-import { fencedCheckoutCommands } from "./invoke.js";
+import { checkoutRunner, ranAtLine, widestRan } from "./invoke.js";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -17,7 +6,7 @@ import { run as execRun } from "./exec.js";
 import { approvedCommandShell, SETUP_ENV_ALLOWLIST, SETUP_ENV_DENYLIST } from "./builder.js";
 import { runWithIsolatedDatabase } from "./child-database.js";
 import { boundStreamHeadTail, readVerifiedArtifact, redactSecretLines, scanForSecrets, storeEvidence } from "./evidence.js";
-import { CHECK_LEVEL_WORDS, checkCommandFor, quickVerifyKey, repoClause, repoOfRun, runCheckLevel } from "./check-levels.js";
+import { CHECK_LEVEL_WORDS, checkCommandFor, repoClause, repoOfRun, runCheckLevel } from "./check-levels.js";
 import { fileTaskProposal } from "./proposal.js";
 export const CHECKS_REQUESTED = "checks requested";
 export const CHECKS_STARTED = "checks started";
@@ -188,6 +177,8 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
     const folder = mkdtempSync(join(deps.scratch ?? tmpdir(), "toolroll-checks-"));
     const checkout = join(folder, "checkout");
     const log = [];
+    // How each command actually ran (check-access.ts): the widest is on the receipt and in the log.
+    const ranAt = [];
     const bound = (text) => { const hits = scanForSecrets(text); return boundStreamHeadTail(hits.length > 0 ? redactSecretLines(text, hits) : text, 24 * 1024); };
     const note = (label, command, result) => log.push(`=== ${label} ===\n$ ${command}\n(exit ${result.code}${result.notFound ? ", could not start" : ""}${result.timedOut ? ", timed out" : ""})\n\n--- stdout ---\n${bound(result.stdout)}\n\n--- stderr ---\n${bound(result.stderr)}`);
     let result;
@@ -199,10 +190,11 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
         }
         else {
             const setup = store.liveWorktreeSetup(target.repo);
+            // Worked out again right before each command (check-access.ts): a narrowing meanwhile applies to the next one.
             let ready = true;
             if (setup !== null) {
                 const shell = approvedCommandShell(setup.command);
-                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 });
+                const prepared = await runWithIsolatedDatabase(checkoutRunner(store, target.repo, checkout, runner, [runId], level => ranAt.push(level)), 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;
@@ -217,7 +209,7 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
                 }
                 else {
                     const shell = approvedCommandShell(live.command);
-                    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 });
+                    const ran = await runWithIsolatedDatabase(checkoutRunner(store, target.repo, checkout, runner, [runId], level => ranAt.push(level)), 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 };
                 }
@@ -231,10 +223,13 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
         rmSync(folder, { recursive: true, force: true });
     }
     const at = now();
+    const ranLine = ranAtLine(widestRan(ranAt));
+    if (ranLine !== null)
+        log.push(ranLine);
     const text = log.length === 0 ? "No command started." : log.join("\n\n");
     const logId = storeEvidence(store, root, runId, "structured-output", `follow-up-check-${request}.log`, Buffer.from(text, "utf8"), FOLLOW_UP_LOG, at, { captureStatus: "ok" });
     const logArtifact = store.getArtifact(logId);
-    const receipt = JSON.stringify({ version: 1, request, run: runId, head: target.head, tested: target.head, level: target.level,
+    const receipt = JSON.stringify({ version: 1, request, run: runId, head: target.head, tested: target.head, level: target.level, checkAccess: widestRan(ranAt),
         command: { repo: target.command.repo, command: target.command.command, digest: target.command.digest, approvedBy: target.command.approvedBy },
         result, log: { artifactId: logArtifact.id, sha256: logArtifact.sha256, bytesStored: logArtifact.bytesStored, truncated: logArtifact.truncated } }, null, 1);
     storeEvidence(store, root, runId, "structured-output", `follow-up-check-${request}.json`, Buffer.from(receipt, "utf8"), FOLLOW_UP_RECEIPT, at, { captureStatus: "ok" });
@@ -284,10 +279,6 @@ export function resultCheckLevel(store, runId, now) {
     const read = withFollowUps({ status: level === "off" ? "not-run" : "passed", level, exitCode: null, head: run?.headRevision ?? null }, follows);
     return read.level;
 }
-/** Whether this result's commit has passed the project's full check, here or in a follow-up. */
-export function fullCheckPassed(reading) {
-    return reading.status === "passed" && (reading.level === "full" || reading.level === null);
-}
 export function fullCheckGate(store, runId, now) {
     const level = runCheckLevel(store, runId);
     const repo = repoOfRun(store, runId);
@@ -310,7 +301,6 @@ export function fullCheckGate(store, runId, now) {
         return { state: "not-run", message: `The full check didn't finish on this commit${last.note === null ? "" : `: ${last.note}`} Run it again, or merge anyway.` };
     return { state: "waiting", message: "The full check is still running on this commit. Merge once it passes, or merge anyway." };
 }
-export const isQuickCommand = (command, repo) => command !== null && command.repo === quickVerifyKey(repo);
 // ---- Add tests --------------------------------------------------------------
 /** File a small task to write tests for a result's change. It is filed like any
  * other task: nothing runs until a person approves it. */

package/dist/result-review.d.ts

@@ -182,8 +182,6 @@ export declare function parseRevisionBatch(raw: string | null | undefined): numb
 /** The source binding the revision form carries: the scope digest the
  * page was rendered against, or "none". */
 export declare function revisionSourceOf(scopeDigest: string | null): string;
-export declare const REVIEW_DRAFT_PREFIX = "standing-orders:review-draft:";
-export declare const RESULT_SCROLL_PREFIX = "standing-orders:result-scroll:";
 /** The in-page half of the result presentation. Everything it does is
  * presentational or a bounded draft: no fetch, no endpoint, no submit.
  *

package/dist/result-review.js

@@ -210,8 +210,6 @@ export function parseRevisionBatch(raw) {
 export function revisionSourceOf(scopeDigest) {
     return scopeDigest === null ? "none" : scopeDigest;
 }
-export const REVIEW_DRAFT_PREFIX = "standing-orders:review-draft:";
-export const RESULT_SCROLL_PREFIX = "standing-orders:result-scroll:";
 /** The in-page half of the result presentation. Everything it does is
  * presentational or a bounded draft: no fetch, no endpoint, no submit.
  *

package/dist/retention.d.ts

@@ -12,7 +12,6 @@ export declare const RETENTION_KINDS: readonly {
 }[];
 export declare const PERIOD_CHOICES: Readonly<Record<RetentionKind, readonly (number | null)[]>>;
 export declare const MIN_DAYS: 1;
-export declare const MAX_DAYS: 3650;
 /** A sweep is due once a day. */
 export declare const SWEEP_EVERY_MS = 86400000;
 /** At most this many runs, messages, notifications or records go per kind per sweep; the next sweep takes the rest. */

package/dist/retention.js

@@ -69,7 +69,6 @@ export const PERIOD_CHOICES = {
     evidence: [1, 7, 14, 28, null], checkouts: LONG_CHOICES, chat: LONG_CHOICES, notifications: LONG_CHOICES,
 };
 export const MIN_DAYS = RETENTION_DAYS.min;
-export const MAX_DAYS = RETENTION_DAYS.max;
 const DAY_MS = 86_400_000;
 /** A sweep is due once a day. */
 export const SWEEP_EVERY_MS = DAY_MS;

package/dist/review-context.d.ts

@@ -32,7 +32,6 @@ export declare const REVIEW_CONTEXT_LIMITS: {
 /** Only this compact projection enters prompts. Full bytes remain sealed in
  * the artifact and are materialized under generated, flat scratch names. */
 export declare function reviewContextFileName(id: string): string;
-export declare function reviewContextManifest(inventory: ReviewContextInventory): string;
 export type ContextGapReason = "source-missing" | "source-unverified" | "source-proof-missing" | "source-scope-changed" | "criterion-changed" | "stale-ancestry" | "missing-at-head" | "not-a-file" | "binary" | "over-limit" | "aggregate-limit" | "item-cap" | "secret-redacted" | "capture-failed";
 export type ContextItemWhy = "source-criterion-evidence" | "source-changed-path" | "candidate-changed-path";
 export type ReviewContextItem = {

package/dist/review-context.js

@@ -1,5 +1,5 @@
 // Assignment direct assessments reuse custody checks; gaps remain explicit.
-import { readObservationEvidence, OBSERVATION_CAPTURE, OBSERVATION_FILE } from "./observations.js";
+import { readObservationEvidence, OBSERVATION_CAPTURE } from "./observations.js";
 import { isVerificationReceipt } from "./verification-evidence.js";
 /**
  * Inherited review context (v51, contract handoff task 3): the bounded,
@@ -75,17 +75,6 @@ export function reviewContextFileName(id) {
         throw new Error("invalid context item id");
     return `REVIEW-CONTEXT-${id}.txt`;
 }
-export function reviewContextManifest(inventory) {
-    return JSON.stringify({
-        ...inventory,
-        ...(inventory.handoff === undefined ? {} : { handoff: { artifact: inventory.handoff.artifact, sha256: inventory.handoff.sha256, file: "REVIEW-BUILDER-NOTES.json" } }),
-        ...(inventory.observations === undefined ? {} : { observations: { artifact: inventory.observations.artifact, sha256: inventory.observations.sha256, file: OBSERVATION_FILE } }),
-        format: "review-context-manifest-v1",
-        items: inventory.items.map(({ content: _content, ...item }) => ({
-            ...item, file: reviewContextFileName(item.id),
-        })),
-    });
-}
 const CONTEXT_INPUT_KINDS = new Set(["terminal-diff", "diff-stat", "proof", "check-log", "screenshot", "review-context"]);
 /** A shortened check log is the exact bounded log the reviewer saw.
  * Completeness of patches, proofs and other structured inputs is still

package/dist/reviewer.d.ts

@@ -8,22 +8,6 @@ import { type BuildFinding } from "./contracts/review-findings.js";
  * screenshots only when this run actually has one (v40) — a grandfathered
  * run (no rubric) writes exactly what it always has, byte for byte. */
 export declare const REVIEW_PATCH_NAME = "REVIEW-DIFF.patch";
-export declare const REVIEW_RUBRIC_NAME = "REVIEW-RUBRIC.json";
-export declare const REVIEW_PROOF_NAME = "REVIEW-PROOF.json";
-/** Audit hardening (still evidence-review-v1, unreleased): the repository's
- * approved verification command's own captured stdout/stderr — a
- * criterion citing `check` evidence was previously judged from the proof's
- * bare claim, never the actual output. */
-export declare const REVIEW_CHECK_LOG_NAME = "REVIEW-CHECK-LOG.txt";
-/** v51 (inherited review context): a REVISION's sealed source-and-ancestry
- * inventory — bounded files at the exact sealed head, bound to the source
- * run, plus prior review provenance as context. Materialized only when
- * the run captured one; every other run writes exactly what it always has. */
-export declare const REVIEW_CONTEXT_NAME = "REVIEW-CONTEXT.json";
-/** One claimed screenshot's name in the scratch — stable per artifact id,
- * so a reviewer's own tool output naming it is reproducible across a
- * retried materialization within the same pass. */
-export declare function reviewScreenshotName(artifactId: number, kind: "png" | "jpeg"): string;
 export declare const REVIEW_LIMITS: {
     readonly comments: 40;
     readonly criteria: 12;

package/dist/reviewer.js

@@ -6,24 +6,6 @@ import { readBuildFindings } from "./contracts/review-findings.js";
  * screenshots only when this run actually has one (v40) — a grandfathered
  * run (no rubric) writes exactly what it always has, byte for byte. */
 export const REVIEW_PATCH_NAME = "REVIEW-DIFF.patch";
-export const REVIEW_RUBRIC_NAME = "REVIEW-RUBRIC.json";
-export const REVIEW_PROOF_NAME = "REVIEW-PROOF.json";
-/** Audit hardening (still evidence-review-v1, unreleased): the repository's
- * approved verification command's own captured stdout/stderr — a
- * criterion citing `check` evidence was previously judged from the proof's
- * bare claim, never the actual output. */
-export const REVIEW_CHECK_LOG_NAME = "REVIEW-CHECK-LOG.txt";
-/** v51 (inherited review context): a REVISION's sealed source-and-ancestry
- * inventory — bounded files at the exact sealed head, bound to the source
- * run, plus prior review provenance as context. Materialized only when
- * the run captured one; every other run writes exactly what it always has. */
-export const REVIEW_CONTEXT_NAME = "REVIEW-CONTEXT.json";
-/** One claimed screenshot's name in the scratch — stable per artifact id,
- * so a reviewer's own tool output naming it is reproducible across a
- * retried materialization within the same pass. */
-export function reviewScreenshotName(artifactId, kind) {
-    return `REVIEW-SCREENSHOT-${artifactId}.${kind === "png" ? "png" : "jpg"}`;
-}
 export const REVIEW_LIMITS = {
     ...REVIEW_OUTPUT_LIMITS,
     /** The mailbox read cap: 40 maximal comments plus 12 judgements fit with headroom. */

package/dist/run-closeout.js

@@ -18,6 +18,7 @@ import { existsSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
 import { hostname } from "node:os";
 import { basename, sep } from "node:path";
 import { ownedProcessCount, runOwnerTag } from "./exec.js";
+import { sleep as defaultSleep } from "./sleep.js";
 /** How long a process has after SIGTERM before SIGKILL. */
 export const STOP_GRACE_MS = 10_000;
 /** `ps` reports age in whole seconds: a process born this close after the run saw its pid is still that process. */
@@ -86,7 +87,7 @@ export async function stopProcesses(targets, options = {}) {
     const graceMs = options.graceMs ?? STOP_GRACE_MS;
     const census = options.census ?? (() => processCensus());
     const signal = options.signal ?? ((pid, name) => process.kill(pid, name));
-    const sleep = options.sleep ?? (ms => new Promise(done => setTimeout(done, ms)));
+    const sleep = options.sleep ?? defaultSleep;
     const send = (rows, name) => {
         for (const row of rows) {
             try {

package/dist/scope.d.ts

@@ -4,6 +4,7 @@ import { isAcpProfile, type AcpProviderId } from "./acp-agents.js";
 export { isAcpProfile };
 import { type NetworkProfile } from "./egress.js";
 import { type WritesMode } from "./writes-mode.js";
+import { type CheckAccess } from "./check-access.js";
 import { type EvidenceKind } from "./contracts/acceptance-terms.js";
 import { type AcceptanceCriterion, type AcceptanceProblem, type ScopeTerms } from "./contracts/scope.js";
 import type { Store, Mutation } from "./store.js";
@@ -78,6 +79,8 @@ export type ClaudeProfile = {
     /** Where the build may write (writes-mode.ts), resolved when the scope was written; absent on approvals sealed before
      * write allowlists, which keep writing anywhere their fence allows. */
     writes?: WritesMode;
+    /** How far its checks reach beyond the check fence (check-access.ts), sealed when wider than sandboxed; absent: sandboxed. */
+    checkAccess?: Exclude<CheckAccess, "sandboxed">;
 };
 export type CodexShapedProfile = {
     provider: "codex" | "openrouter";
@@ -98,6 +101,8 @@ export type CodexShapedProfile = {
     /** Where the build may write (writes-mode.ts), resolved when the scope was written; absent on approvals sealed before
      * write allowlists, which keep writing anywhere their fence allows. */
     writes?: WritesMode;
+    /** How far its checks reach beyond the check fence (check-access.ts), sealed when wider than sandboxed; absent: sandboxed. */
+    checkAccess?: Exclude<CheckAccess, "sandboxed">;
 };
 export type GeminiProfile = {
     provider: "gemini";
@@ -120,6 +125,8 @@ export type GeminiProfile = {
     /** Where the build may write (writes-mode.ts), resolved when the scope was written; absent on approvals sealed before
      * write allowlists, which keep writing anywhere their fence allows. */
     writes?: WritesMode;
+    /** How far its checks reach beyond the check fence (check-access.ts), sealed when wider than sandboxed; absent: sandboxed. */
+    checkAccess?: Exclude<CheckAccess, "sandboxed">;
 };
 /**
  * An agent over the Agent Client Protocol (acp-agents.ts, docs/plans/acp-adapter.md).
@@ -143,6 +150,8 @@ export type AcpProfile = {
     /** Where the build may write (writes-mode.ts), resolved when the scope was written; absent on approvals sealed before
      * write allowlists, which keep writing anywhere their fence allows. */
     writes?: WritesMode;
+    /** How far its checks reach beyond the check fence (check-access.ts), sealed when wider than sandboxed; absent: sandboxed. */
+    checkAccess?: Exclude<CheckAccess, "sandboxed">;
 };
 export type ExecutionProfile = ClaudeProfile | CodexShapedProfile | GeminiProfile | AcpProfile;
 /** Whether a profile's clock is a no-progress window (an ACP profile has both clocks; its overall one is a deadline). */