toolroll 0.9.79 → 0.9.82

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.9.82 — 2026-10-31
+
+- **A failing nightly holds your releases.** Turn it on with
+  `toolroll release nightly --github` (your password). When a lane of your
+  project's GitHub nightly fails on main, every deploy, the merge and the tag
+  of a release wait until a later nightly passes that lane, and Needs you
+  says which lane and why. A release whose own pull request re-ran that lane
+  after the failure, with the same CI files, goes through. A nightly that
+  can't be read gives a warning, never a pass.
+- **Every run and chat turn records the model and cost the provider
+  reported:** the exact model id, provider turns, cache-aware tokens, and
+  cost, with API dollars, subscription usage and unknown kept apart (unknown
+  is never shown as zero).
+- **Evals (groundwork).** `toolroll evals` runs repeatable test tasks in
+  throwaway worlds, graded by a separate checker process the agent can't
+  reach. Ten starter tasks ship as drafts; real comparison runs stay off
+  until they're validated.
+- **CI:** required checks report under their exact names on every pull
+  request; a slow git config read now says it timed out instead of blaming
+  the project's config.
+
+## 0.9.81 — 2026-10-30
+
+- **The release proof works after the merge.** GitHub empties a CI run's
+  pull-request link once the pull request merges and its branch is deleted,
+  so 0.9.80's tag could never prove its checks and wasn't published. A run
+  with no link now stands only when its branch has had exactly one pull
+  request, ever, and that pull request merged into main. 0.9.80's changes
+  ship in this release.
+
+## 0.9.80 — 2026-10-30
+
+- **Each test runs once, where it adds something** (docs/plans/test-matrix.md).
+  Pull requests run the unit suite on Node 24 (Linux and macOS) and every
+  area lane (Windows, Linux fence and cgroup, git 2.41 and 2.47); a pull
+  request that only changes Markdown under `docs/`, the changelog or the
+  README skips the area lanes. Node 22 runs on Linux and macOS once per
+  release, on the `release-*` branch's pull request, in the new
+  Release candidate workflow. Release tags no longer rerun the macOS suites:
+  a release proof reads GitHub's record that the tagged tree passed every
+  required check on its pull request before npm publication. A push to main
+  typechecks and builds, and runs the full CI only when it can't prove the
+  merge commit was tested. The nightly runs everything. A release now needs
+  every required check executed, never skipped, and refuses to merge while
+  main's branch protection doesn't require all of them. Hosted unit shards
+  require their platform's native fence attacks to run.
+
 ## 0.9.79 — 2026-10-29
 
 - **`toolroll release` rides out a short network failure instead of

package/dist/cli.js

@@ -108,6 +108,7 @@ export function parseArgs(argv) {
 /** The commands that operate the queue rather than report on the world. */
 export const OPERATE_COMMANDS = new Set([
     "up",
+    "evals",
     // Only `lead token` reaches here; the central service's lead verbs answer first.
     "lead",
     "onboard",

package/dist/commit-extract.d.ts

@@ -71,6 +71,11 @@ export type Verified<T> = {
 export type GitRunner = {
     git?: string;
     env?: NodeJS.ProcessEnv;
+    /** Each git call's time limit (default five minutes). */
+    timeoutMs?: number;
+    /** An absolute wall-clock deadline (ms): every git subprocess, setup included, gets only what is left of it, and a
+     * read past it fails (teardown-git.ts viewedGitSync). */
+    deadline?: number;
 };
 /** One commit, hashed here and parsed from its own bytes. */
 export declare function readVerifiedCommit(gitDir: string, sha: string): Verified<VerifiedCommit>;
@@ -114,4 +119,17 @@ export declare function verifiedRange(gitDir: string, from: string, to: string,
     max?: number;
     reach?: number;
 }): Verified<VerifiedCommit[]>;
+/**
+ * Whether `until` lies on `from`'s first-parent history, within a deadline (nightly-github.ts): "yes" when the walk
+ * reaches it; "no" only when it is PROVEN not to — `until` is itself a readable, verified commit and every commit from
+ * `from` back to the root was read and verified without meeting it; "unknown" for anything less certain (an object
+ * missing or unreadable, `max` commits walked, the deadline reached). Every git call is bounded by what is left of
+ * the deadline, at most `callMs`.
+ */
+export declare function verifiedFirstParentAncestry(gitDir: string, from: string, until: string, options: {
+    deadline: number;
+    now?: () => number;
+    max?: number;
+    callMs?: number;
+}): "yes" | "no" | "unknown";
 export {};

package/dist/commit-extract.js

@@ -212,7 +212,7 @@ function protectedGit(gitDir, runner, extra) {
         if (checkout === null)
             return { status: null, stdout: Buffer.alloc(0), refused: "it isn't a checkout's .git folder, which this git can only read through a view" };
         try {
-            const ran = viewedGitSync(checkout, [...base, ...args], { buffer: true, timeoutMs: 300_000, maxBuffer: MAX_BYTES, ...(input === undefined ? {} : { input }), ...(runner.git === undefined ? {} : { git: runner.git }) });
+            const ran = viewedGitSync(checkout, [...base, ...args], { buffer: true, timeoutMs: runner.timeoutMs ?? 300_000, ...(runner.deadline === undefined ? {} : { deadline: runner.deadline }), maxBuffer: MAX_BYTES, ...(input === undefined ? {} : { input }), ...(runner.git === undefined ? {} : { git: runner.git }) });
             return { status: ran.status, stdout: ran.stdout, refused: null };
         }
         catch (error) {
@@ -567,3 +567,41 @@ export function verifiedRange(gitDir, from, to, options = {}) {
     const unreached = wanted.find(one => !reached.has(one));
     return unreached === undefined ? { ok: true, value: commits } : { ok: false, message: `${unreached.slice(0, 7)} isn't verified as part of the last release's history.` };
 }
+/**
+ * Whether `until` lies on `from`'s first-parent history, within a deadline (nightly-github.ts): "yes" when the walk
+ * reaches it; "no" only when it is PROVEN not to — `until` is itself a readable, verified commit and every commit from
+ * `from` back to the root was read and verified without meeting it; "unknown" for anything less certain (an object
+ * missing or unreadable, `max` commits walked, the deadline reached). Every git call is bounded by what is left of
+ * the deadline, at most `callMs`.
+ */
+export function verifiedFirstParentAncestry(gitDir, from, until, options) {
+    const now = options.now ?? Date.now;
+    const left = () => options.deadline - now();
+    // Every answer is checked against the deadline as it is given: nothing past it is ever "yes" or "no".
+    const answer = (value) => left() > 0 ? value : "unknown";
+    if (left() <= 0)
+        return "unknown";
+    // The absolute deadline goes down to every subprocess (setup included); each call is also held to `callMs`.
+    const reader = verifiedReader(gitDir, { timeoutMs: options.callMs ?? 10_000, deadline: options.deadline });
+    if (!reader.ok)
+        return "unknown";
+    if (from === until)
+        return readCommitWith(reader.value, until).ok ? answer("yes") : "unknown";
+    if (left() <= 0 || !readCommitWith(reader.value, until).ok)
+        return "unknown";
+    let at = from;
+    for (let walked = 0; walked < (options.max ?? 20_000); walked++) {
+        if (left() <= 0)
+            return "unknown";
+        const commit = readCommitWith(reader.value, at);
+        if (!commit.ok)
+            return "unknown";
+        const parent = commit.value.parents[0];
+        if (parent === undefined)
+            return answer("no");
+        if (parent === until)
+            return answer("yes");
+        at = parent;
+    }
+    return "unknown";
+}

package/dist/converse.d.ts

@@ -132,6 +132,9 @@ export type ProviderAnswer = {
     /** OpenRouter reports the actual charge; settlement takes the HIGHER of
      * this and the pinned math — the ledger never undercounts. */
     reportedCostMicrousd: number | null;
+    /** v140: the exact model the response body names, and the cost it reported in dollars (absent or null: unreported). */
+    modelReported?: string | null;
+    reportedCostUsd?: number | null;
 };
 /** Strict parse of the PROVIDER response body (layer one). */
 /** A token count is a non-negative safe integer under a billion (mate arc,
@@ -184,6 +187,15 @@ export type LeadProviderAnswer = {
     reportedCostMicrousd: number | null;
     cacheWriteTokens?: number;
     cacheReadTokens?: number;
+    /** v140 (docs/plans/evals-nightly.md B1), each from the provider's own report and absent or null when it gave none
+     * (never 0): the exact model it says answered, its own turn count (`num_turns`), and the cost it reported in dollars.
+     * `reportedCostMicrousd` stays API money only; a subscription harness's reported cost is `reportedCostUsd` alone. */
+    modelReported?: string | null;
+    providerTurns?: number | null;
+    reportedCostUsd?: number | null;
+    /** v141: how a subscription harness's own events said this request was billed (its init's key source); null or
+     * absent when they didn't say (unknown money, never assumed to be the plan). */
+    billingReported?: "subscription" | "api-key" | null;
 };
 /** Anthropic prices a cache write at 1.25x and a cache read at 0.1x the input price (5-minute cache). */
 export declare const CACHE_WRITE_RATIO = 1.25;

package/dist/converse.js

@@ -19,10 +19,12 @@
  * micro-dollars per token, rounded up. A model without a pinned price
  * cannot be spoken to — the reservation math would be fiction.
  */
+import { takeEvalDispatch } from "./eval-gate.js";
 import { TASK_TEXT_LIMITS } from "./task-text.js";
 import { createHash } from "node:crypto";
 import { hasForbiddenControls, hasDisguisedText } from "./decision.js";
 import { parseAcceptanceCriteria } from "./scope.js";
+import { reportedCostUsdOf, reportedModelOf } from "./reported-usage.js";
 // ---------------------------------------------------------------- limits
 export const WRAPPER_CAP_BYTES = 262_144; // the provider response body
 export const ENVELOPE_CAP_BYTES = 65_536; // the assistant text inside it
@@ -481,6 +483,7 @@ export function parseLeadProviderWrapper(provider, bytes) {
         if (write === null || read === null)
             return { ok: false, problem: "no-usage" };
         return { ok: true, answer: { text, calls, tokensIn: usage.tokensIn + (write ?? 0) + (read ?? 0), tokensOut: usage.tokensOut, reportedCostMicrousd: null,
+                modelReported: reportedModelOf(body["model"]), providerTurns: null, reportedCostUsd: null,
                 ...(write === undefined ? {} : { cacheWriteTokens: write }), ...(read === undefined ? {} : { cacheReadTokens: read }) } };
     }
     const choices = body["choices"];
@@ -527,7 +530,8 @@ export function parseLeadProviderWrapper(provider, bytes) {
             return { ok: false, problem: "bad-cost" };
         reportedCostMicrousd = micro;
     }
-    return { ok: true, answer: { text, calls, tokensIn: usage.tokensIn, tokensOut: usage.tokensOut, reportedCostMicrousd } };
+    return { ok: true, answer: { text, calls, tokensIn: usage.tokensIn, tokensOut: usage.tokensOut, reportedCostMicrousd,
+            modelReported: reportedModelOf(body["model"]), providerTurns: null, reportedCostUsd: reportedCostUsdOf(rawCost) } };
 }
 /** The lead's request: system contract, the data document as the first
  * operator message, the history in provider-native shape, the tools. */
@@ -593,6 +597,10 @@ export function composeLeadRequest(args) {
 }
 /** The lead's network call: the same transport posture as fleet chat's, the tool-capable parser at the end. */
 export async function performLeadRequest(request, provider, signal, fetcher = fetch) {
+    // An eval world (eval-gate.ts): each request takes one of the attempt's dispatch slots. Past the limit nothing is sent.
+    const evalSlot = takeEvalDispatch(`lead:${provider}`);
+    if (evalSlot.active && !evalSlot.ok)
+        return { ok: false, problem: "status-eval-dispatch-limit" };
     let response;
     try {
         response = await fetcher(request.url, { method: "POST", headers: request.headers, body: request.body, redirect: "error", signal });
@@ -634,7 +642,7 @@ export function parseProviderWrapper(provider, bytes) {
         const tokensOut = usage === undefined ? NaN : Number(usage["output_tokens"]);
         if (!tokenCount(tokensIn) || !tokenCount(tokensOut))
             return { ok: false, problem: "no-usage" };
-        return { ok: true, answer: { text: block["text"], tokensIn, tokensOut, reportedCostMicrousd: null } };
+        return { ok: true, answer: { text: block["text"], tokensIn, tokensOut, reportedCostMicrousd: null, modelReported: reportedModelOf(body["model"]), reportedCostUsd: null } };
     }
     // openrouter-api (OpenAI-compatible)
     const choices = body["choices"];
@@ -660,6 +668,9 @@ export function parseProviderWrapper(provider, bytes) {
             tokensIn,
             tokensOut,
             reportedCostMicrousd: Number.isFinite(reportedCost) && reportedCost >= 0 ? Math.ceil(reportedCost * 1_000_000) : null,
+            modelReported: reportedModelOf(body["model"]),
+            // The body's own number only: Number(null) would read an unreported cost as 0.
+            reportedCostUsd: usage === undefined ? null : reportedCostUsdOf(usage["cost"]),
         },
     };
 }
@@ -801,6 +812,11 @@ export async function readCappedBody(response, cap) {
  * wall clock, streamed cap, wrapper strictness.
  */
 export async function performChatRequest(args, fetcher = fetch) {
+    // An eval world (eval-gate.ts, Codex round 1 #3): fleet chat's request takes a dispatch slot too; past the limit, or
+    // with a gate that can't be read, nothing is sent.
+    const evalSlot = takeEvalDispatch(`chat:${args.provider}`);
+    if (evalSlot.active && !evalSlot.ok)
+        return { ok: false, problem: "status-eval-dispatch-limit" };
     const request = composeRequest(args);
     let response;
     try {

package/dist/deploy-gate.js

@@ -9,6 +9,7 @@ import { assignmentOf } from "./assignment.js";
 import { liveReleaseOf, personApprovalOf, releaseApprovalOf } from "./scope.js";
 import { verificationEvidence } from "./verification-evidence.js";
 import { releaseCiRunningOf } from "./release-ci-hold.js";
+import { nightlyDebtHold } from "./nightly-github.js";
 /** Whether run `runId` is a deployable candidate now, read only from the plane's records and this runtime's code. */
 export function deploymentGate(store, input) {
     const refuse = (message) => ({ ok: false, message });
@@ -40,6 +41,13 @@ export function deploymentGate(store, input) {
         return refuse(`This release can't deploy: ${release.why}.`);
     const anchorPerson = release.applies && release.ok
         ? (input.releaseFlow === true ? releaseApprovalOf(store, release.authority.anchorTask, input.now) : personApprovalOf(store, release.authority.anchorTask)) : null;
+    // GitHub's nightly lane debt (nightly-github.ts) holds every deploy of the project, a person's approval or not,
+    // unless this exact candidate re-ran that lane after the failure and passed (an exemption read at the boundary).
+    if (ref.repo !== null) {
+        const nightly = nightlyDebtHold(store, { repo: ref.repo, taskId: ref.externalId, candidate: scope?.candidate ?? head, phase: "deploy", release: release.applies, now: input.now });
+        if (nightly !== null)
+            return refuse(nightly.why);
+    }
     const person = anchorPerson ?? personApprovalOf(store, ref.externalId);
     if (!person.ok)
         return refuse(`A person has to approve this candidate's scope: ${person.why}.`);

package/dist/eval-gate.d.ts

@@ -0,0 +1,51 @@
+export declare const EVAL_GATE_ENV = "TOOLROLL_EVAL_GATE";
+/** The gate's terms: how many provider dispatches the attempt may make. */
+export type EvalGateConfig = {
+    v: 2;
+    max: number;
+};
+/** One slot a dispatch took. */
+export type EvalGateSlot = {
+    n: number;
+    kind: string;
+    pid: number;
+    at: string;
+};
+export type EvalDispatch = {
+    active: false;
+} | {
+    active: true;
+    ok: true;
+    n: number;
+} | {
+    active: true;
+    ok: false;
+    why: string;
+};
+/** At most `limit` bodies at once; the others start in the order they asked, as each running one ends (provider-gate
+ * limiter). */
+export declare function limiter(limit: number): <T>(body: () => Promise<T>) => Promise<T>;
+/** Read a small regular file without following a link; null when it isn't one, is too big or can't be read. */
+export declare function readNoFollow(path: string, maxBytes: number): Buffer | null;
+/** Make a world's gate in `dir` (a fresh folder the runner owns): its terms, and an empty slots folder. Refuses a folder
+ * that already holds a gate. */
+export declare function openEvalGate(dir: string, config: EvalGateConfig): void;
+/** The world's gate, as this process's environment names it: null outside an eval world, its terms, or why it can't
+ * be read (which refuses every dispatch). */
+export declare function evalWorldGate(env?: Readonly<Record<string, string | undefined>>): {
+    dir: string;
+    config: EvalGateConfig;
+} | {
+    dir: string;
+    problem: string;
+} | null;
+/** Take one dispatch slot of this eval world, before a provider is called. Outside an eval world: `{ active: false }`. */
+export declare function takeEvalDispatch(kind: string, env?: Readonly<Record<string, string | undefined>>, now?: Date): EvalDispatch;
+/** Whether this process is in an eval world (any gate named, readable or not): the helpers that keep no record refuse
+ * there. */
+export declare function inEvalWorld(env?: Readonly<Record<string, string | undefined>>): boolean;
+/** Whether a dispatch in this world asked past its limit (and was refused). */
+export declare function evalGateOverLimit(dir: string): boolean;
+/** The slots a world's dispatches took, read back by the runner (never following a link). Null when the folder can't
+ * be read whole: the runner then counts the world's spending as unknown. */
+export declare function evalGateSlots(dir: string): EvalGateSlot[] | null;

package/dist/eval-gate.js

@@ -0,0 +1,199 @@
+/**
+ * The eval world's dispatch gate (docs/plans/evals-nightly.md, part C), and the provider-gate logic the runner needs
+ * at run time, ported from scripts/provider-gate.mjs so it ships in dist.
+ *
+ * An eval attempt runs in a world of its own (evals.ts). Before the world starts, the attempt's runner makes a gate
+ * folder in the world's state folder (which every agent fence in the world denies) holding `gate.json`: the case's
+ * dispatch limit. The world's processes find it through TOOLROLL_EVAL_GATE. Every provider dispatch the world makes
+ * takes one numbered slot first (an exclusive create, so two dispatches never take the same one):
+ *
+ *   - every agent run the invocation gateway (invoke.ts) spawns: builder, planner, repair, reviewer, scout;
+ *   - every lead request, which doesn't go through the gateway (direct API and subscription), and fleet chat's;
+ *   - the helpers that would call a provider and keep no record (task sizing, flow drafts, subagent turns, the
+ *     memory pass) refuse in an eval world instead.
+ *
+ * Past the limit the dispatch refuses and nothing is sent, and the gate remembers it was asked (the attempt then
+ * fails). There is no dollar cap (the owner, 2026-10-30): what each dispatch cost is recorded, not limited. Outside an
+ * eval world (no TOOLROLL_EVAL_GATE) nothing here changes anything; the variable only ever narrows, and a gate that
+ * can't be read refuses every dispatch (fail closed).
+ *
+ * The runner reads the slots back after the attempt (`evalGateSlots`) and matches them to the world's records; a slot
+ * no record accounts for, or a record no slot does, makes the attempt an error with unknown spending.
+ */
+import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readSync, writeSync } from "node:fs";
+import { join } from "node:path";
+export const EVAL_GATE_ENV = "TOOLROLL_EVAL_GATE";
+const CONFIG = "gate.json";
+const SLOTS = "slots";
+const OVER = "over-limit";
+const MAX_GATE_BYTES = 4096;
+/** At most `limit` bodies at once; the others start in the order they asked, as each running one ends (provider-gate
+ * limiter). */
+export function limiter(limit) {
+    if (!Number.isInteger(limit) || limit < 1)
+        throw new Error("a limiter takes a whole number, 1 or more");
+    let running = 0;
+    const queue = [];
+    const next = () => { if (running < limit && queue.length > 0) {
+        running += 1;
+        queue.shift()();
+    } };
+    return (body) => new Promise(start => { queue.push(start); next(); }).then(async () => {
+        try {
+            return await body();
+        }
+        finally {
+            running -= 1;
+            next();
+        }
+    });
+}
+/** Read a small regular file without following a link; null when it isn't one, is too big or can't be read. */
+export function readNoFollow(path, maxBytes) {
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | (constants.O_NONBLOCK ?? 0));
+    }
+    catch {
+        return null;
+    }
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > maxBytes)
+            return null;
+        const out = Buffer.alloc(stat.size);
+        let at = 0;
+        while (at < out.length) {
+            const got = readSync(fd, out, at, out.length - at, at);
+            if (got === 0)
+                break;
+            at += got;
+        }
+        return at === out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+const validConfig = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const one = value;
+    return one["v"] === 2 && Number.isInteger(one["max"]) && one["max"] >= 0 && one["max"] <= 50;
+};
+/** Make a world's gate in `dir` (a fresh folder the runner owns): its terms, and an empty slots folder. Refuses a folder
+ * that already holds a gate. */
+export function openEvalGate(dir, config) {
+    if (!validConfig(config))
+        throw new Error("an eval gate needs a whole dispatch limit");
+    mkdirSync(join(dir, SLOTS), { recursive: false, mode: 0o700 });
+    const fd = openSync(join(dir, CONFIG), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        writeSync(fd, JSON.stringify(config));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** The world's gate, as this process's environment names it: null outside an eval world, its terms, or why it can't
+ * be read (which refuses every dispatch). */
+export function evalWorldGate(env = process.env) {
+    const dir = env[EVAL_GATE_ENV];
+    if (dir === undefined || dir === "")
+        return null;
+    const bytes = readNoFollow(join(dir, CONFIG), MAX_GATE_BYTES);
+    if (bytes === null)
+        return { dir, problem: "this eval world's dispatch gate can't be read, so nothing is dispatched" };
+    let parsed;
+    try {
+        parsed = JSON.parse(bytes.toString("utf8"));
+    }
+    catch {
+        parsed = null;
+    }
+    return validConfig(parsed) ? { dir, config: parsed } : { dir, problem: "this eval world's dispatch gate is malformed, so nothing is dispatched" };
+}
+/** Take one dispatch slot of this eval world, before a provider is called. Outside an eval world: `{ active: false }`. */
+export function takeEvalDispatch(kind, env = process.env, now = new Date()) {
+    const gate = evalWorldGate(env);
+    if (gate === null)
+        return { active: false };
+    if ("problem" in gate)
+        return { active: true, ok: false, why: gate.problem };
+    const record = JSON.stringify({ kind: kind.slice(0, 80), pid: process.pid, at: now.toISOString() });
+    for (let n = 1; n <= gate.config.max; n++) {
+        let fd;
+        try {
+            fd = openSync(join(gate.dir, SLOTS, `${n}.json`), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                continue;
+            return { active: true, ok: false, why: "this eval world's dispatch gate can't be written, so nothing is dispatched" };
+        }
+        try {
+            writeSync(fd, record);
+        }
+        finally {
+            closeSync(fd);
+        }
+        return { active: true, ok: true, n };
+    }
+    // Remembered for the runner: an attempt that asked past its limit is a fail, whatever it built.
+    try {
+        const fd = openSync(join(gate.dir, OVER), constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+        closeSync(fd);
+    }
+    catch { /* the slots alone still hold the limit */ }
+    return { active: true, ok: false, why: `this eval case's limit of ${gate.config.max} provider dispatches is reached (eval-dispatch-limit)` };
+}
+/** Whether this process is in an eval world (any gate named, readable or not): the helpers that keep no record refuse
+ * there. */
+export function inEvalWorld(env = process.env) {
+    return evalWorldGate(env) !== null;
+}
+/** Whether a dispatch in this world asked past its limit (and was refused). */
+export function evalGateOverLimit(dir) {
+    try {
+        return lstatSync(join(dir, OVER)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** The slots a world's dispatches took, read back by the runner (never following a link). Null when the folder can't
+ * be read whole: the runner then counts the world's spending as unknown. */
+export function evalGateSlots(dir) {
+    let names;
+    try {
+        names = readdirSync(join(dir, SLOTS));
+    }
+    catch {
+        return null;
+    }
+    const slots = [];
+    for (const name of names) {
+        const match = /^([1-9][0-9]{0,2})\.json$/.exec(name);
+        if (match === null)
+            return null;
+        const bytes = readNoFollow(join(dir, SLOTS, name), MAX_GATE_BYTES);
+        if (bytes === null)
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            return null;
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)
+            || typeof parsed["kind"] !== "string" || parsed["kind"] === ""
+            || !Number.isSafeInteger(parsed["pid"]) || Number(parsed["pid"]) <= 0 || typeof parsed["at"] !== "string")
+            return null;
+        slots.push({ n: Number(match[1]), kind: typeof parsed["kind"] === "string" ? parsed["kind"] : "unknown", pid: Number(parsed["pid"]) || 0, at: typeof parsed["at"] === "string" ? parsed["at"] : "" });
+    }
+    return slots.sort((a, b) => a.n - b.n);
+}

package/dist/eval-hooks.d.ts

@@ -0,0 +1,39 @@
+/** One required call: in this file, inside this top-level function, a call to this name, the name bound as `from`
+ * says (a module specifier its un-renamed named import comes from; `self`: the file's own top-level function; `local`:
+ * declared inside `inside`). `args`: the call's arguments, as text, must stay as the base has them. */
+export type EvalHook = {
+    file: string;
+    inside: string;
+    calls: string;
+    from: string;
+    args?: true;
+    why: string;
+};
+/** One function whose body (its text, as the candidate has it) must stay as the base has it: a top-level function, or
+ * `Class#method`, a method of a top-level class. */
+export type EvalPinned = {
+    file: string;
+    fn: string;
+    why: string;
+};
+export declare const EVAL_HOOKS: readonly EvalHook[];
+export declare const EVAL_PINNED: readonly EvalPinned[];
+/** The Store methods pinned by body, which no file may write over (storeRewriteProblem, store.ts sealStoreMoneyMethods). */
+export declare const PINNED_STORE_METHODS: readonly string[];
+/**
+ * Why a candidate drops a required hook or changes a pinned body, or null. `candidate` gives a listed file's bytes at
+ * the candidate (null: missing or unreadable, which needs a person too). With `base` (the plane's own record of where
+ * the release started, which the candidate can't rewrite), only what the base holds is required: a project that isn't
+ * Toolroll holds none, and a hook not yet landed can't be dropped.
+ */
+export declare function evalHookProblem(candidate: (file: string) => Buffer | null, base?: (file: string) => Buffer | null, hooks?: readonly EvalHook[], pinned?: readonly EvalPinned[]): string | null;
+/** Every file the manifest reads, for one verified read of each tree. */
+export declare const EVAL_HOOK_FILES: readonly string[];
+/**
+ * Why a changed file could write over a pinned Store method, or null (PR #263 security scan). Each changed JavaScript
+ * or TypeScript file, store.ts included (its class's own method declarations exempt; their bodies are pinned), is held to
+ * storeRewrites: a construct the base's copy of that file didn't already have (counted, by the sha256 of its whole
+ * text) needs a person. A tree or file that can't be read, or a file that doesn't parse, needs one too; `paths` are the
+ * files the verified diff says exist at the candidate, so no bytes is a failed read, never a deletion.
+ */
+export declare function storeRewriteProblem(paths: readonly string[], candidate: ((file: string) => Buffer | null) | null, base: ((file: string) => Buffer | null) | null, pinned?: readonly string[]): string | null;