toolroll 0.9.81 → 0.9.83

package/dist/project-identity.js

@@ -0,0 +1,106 @@
+/**
+ * Project identities as the console uses them, without touching a person's folders on its thread.
+ *
+ * A project's identity is its real path (project.ts canonicalProject). Resolving one reads the folder, and a folder can
+ * stop answering (folder-look.ts), so the console never resolves one on a page or at startup on its own thread:
+ *
+ * - `hot` (display and grouping only): the last answer, else the path as saved. Nothing is started by asking.
+ * - `strict` (visibility and authorization): only a resolved identity; an unknown one fails closed until the next
+ *   refresh resolves it, so a stored path that leads outside its root never passes on its spelling.
+ * - `vouched` (a path a request names): only a path whose identity is known, or one that is exactly a saved identity.
+ *   Anything else is refused this time and resolved by the next background pass, never resolved inline.
+ * - `resolveNow` (an action that needs a path checked now, a POST): resolved off the thread under the look's deadline.
+ * - `refresh` (the console's start and its background pass): resolves what was asked about and what has gone stale.
+ *
+ * An embedder or test that passes no identities gets `syncProjectIdentities`: the old synchronous reads, unchanged.
+ */
+import { resolve } from "node:path";
+import { lookIdentities } from "./folder-look.js";
+import { canonicalProject } from "./project.js";
+/** How long an answer stands before the background pass resolves the path again. */
+const STALE_MS = 60_000;
+export function projectIdentities(look = {}, now = Date.now) {
+    const answers = new Map();
+    const wanted = new Set();
+    const known = (path) => answers.get(resolve(path))?.real;
+    const store = (found) => {
+        const at = now();
+        for (const [path, real] of found) {
+            answers.set(resolve(path), { real, at });
+            wanted.delete(resolve(path));
+            // A real path is its own identity.
+            if (real !== null)
+                answers.set(real, { real, at });
+        }
+    };
+    const resolveNow = async (path) => {
+        const looked = await lookIdentities([resolve(path)], look);
+        if (!looked.ok)
+            return "no-answer";
+        store(looked.value);
+        return looked.value.get(resolve(path)) ?? null;
+    };
+    return {
+        hot: path => {
+            const key = resolve(path);
+            const answer = answers.get(key);
+            if (answer === undefined)
+                wanted.add(key);
+            return answer?.real ?? key;
+        },
+        known,
+        strict: path => {
+            const key = resolve(path);
+            const answer = answers.get(key);
+            if (answer === undefined)
+                wanted.add(key);
+            return answer?.real ?? null;
+        },
+        vouched: (path, saved) => {
+            const key = resolve(path);
+            const answer = answers.get(key);
+            if (answer !== undefined && answer.real !== null)
+                return answer.real;
+            for (const one of saved())
+                if (one === key)
+                    return key;
+            wanted.add(key);
+            return undefined;
+        },
+        resolveNow,
+        refresh: async (paths) => {
+            const at = now();
+            const due = new Set(wanted);
+            for (const one of paths) {
+                const key = resolve(one);
+                const answer = answers.get(key);
+                if (answer === undefined || at - answer.at >= STALE_MS)
+                    due.add(key);
+            }
+            for (const [key, answer] of answers)
+                if (at - answer.at >= STALE_MS)
+                    due.add(key);
+            if (due.size === 0)
+                return true;
+            const batch = await lookIdentities([...due], look);
+            if (batch.ok) {
+                store(batch.value);
+                return true;
+            }
+            // One folder that doesn't answer mustn't hold the others: each on its own, in parallel (the looks are capped).
+            const each = await Promise.all([...due].map(one => resolveNow(one)));
+            return each.every(one => one !== "no-answer");
+        },
+    };
+}
+/** The synchronous reads, as before: for embedders and tests that pass no identities. */
+export function syncProjectIdentities() {
+    return {
+        hot: path => canonicalProject(path) ?? path,
+        known: path => canonicalProject(path),
+        strict: path => canonicalProject(path),
+        vouched: path => canonicalProject(path) ?? undefined,
+        resolveNow: async (path) => canonicalProject(path),
+        refresh: async () => true,
+    };
+}

package/dist/project-knowledge.d.ts

@@ -22,19 +22,17 @@ export type KnowledgeView = ReturnType<typeof knowledgeView>;
 export declare function knowledgeVersion(store: Store, repo: string, actor: string, revision: number): Knowledge;
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
-    title?: never;
     history?: never;
     revision: number;
     stale: boolean;
     notice: string;
     decision?: never;
+    title?: never;
     content?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
 } | {
-    title?: never;
-    revision?: never;
     history?: never;
     stale?: never;
     decision: {
@@ -52,7 +50,9 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
         id: number;
     };
     notice: string;
+    title?: never;
     content?: never;
+    revision?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
@@ -68,9 +68,9 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     references?: never;
     decisions?: never;
 } | {
-    title?: never;
     stale?: never;
     decision?: never;
+    title?: never;
     content?: never;
     revision: number;
     history: {

package/dist/project-tools.d.ts

@@ -103,7 +103,7 @@ export type FoundTool = {
  * Codex's (from `codex mcp list --json`, passed in). The first of each
  * name wins; unusable entries are left out.
  */
-export declare function discoverTools(repo: string, codexServers: unknown[] | null, home?: string, environment?: NodeJS.ProcessEnv): FoundTool[];
+export declare function discoverTools(repo: string, codexServers: unknown[] | null, home?: string, environment?: NodeJS.ProcessEnv, projectConfig?: Record<string, unknown> | null): FoundTool[];
 /** Start the server once, ask for its tools, and stop it: the proof a build can use it. */
 export declare function testTool(spec: ToolSpec, values: Record<string, string>, options: {
     timeoutMs?: number;
@@ -313,3 +313,6 @@ export declare function toolServerFor(store: ToolServerStore, repo: string, opti
     home?: string;
     available?: () => boolean;
 }): ToolServer;
+/** Each project's `.mcp.json` as the console last read it off its thread (its background pass): what its pages and the
+ * lead offer, so neither reads a project folder on the console's thread. */
+export declare const savedProjectMcp: Map<string, Record<string, unknown> | null>;

package/dist/project-tools.js

@@ -496,7 +496,7 @@ function fromCodexEntry(raw, environment) {
  * Codex's (from `codex mcp list --json`, passed in). The first of each
  * name wins; unusable entries are left out.
  */
-export function discoverTools(repo, codexServers, home = homedir(), environment = process.env) {
+export function discoverTools(repo, codexServers, home = homedir(), environment = process.env, projectConfig) {
     const found = [];
     const add = (one) => { if (one !== null && !found.some(other => other.spec.name === one.spec.name))
         found.push(one); };
@@ -509,7 +509,9 @@ export function discoverTools(repo, codexServers, home = homedir(), environment
             return null;
         }
     };
-    const project = readJson(join(repo, ".mcp.json"));
+    // The project's own file as given (the console reads it off its thread: folder-look.ts), else as last read there
+    // (savedProjectMcp), else read here (the CLI and the worker).
+    const project = projectConfig !== undefined ? projectConfig : savedProjectMcp.has(repo) ? savedProjectMcp.get(repo) ?? null : readJson(join(repo, ".mcp.json"));
     for (const [name, raw] of Object.entries((project?.["mcpServers"] ?? {})))
         add(fromClaudeEntry(name, raw, "this project's .mcp.json"));
     const claude = readJson(join(home, ".claude.json"));
@@ -1149,3 +1151,6 @@ export function toolServerFor(store, repo, options = {}) {
     const untrusted = existsSync(cache) ? [realpathSync(cache)] : [];
     return { fence: fenceFor("tool-server", { databaseFile, worktree: null, home, boundary: null, binding: null, runFolders: runFolders(null), poolRoots, extra: untrusted }) };
 }
+/** Each project's `.mcp.json` as the console last read it off its thread (its background pass): what its pages and the
+ * lead offer, so neither reads a project folder on the console's thread. */
+export const savedProjectMcp = new Map();

package/dist/project.d.ts

@@ -29,6 +29,9 @@ export type ProjectCeiling = {
     repos: readonly string[];
     /** Canonical directories: any git repo under one is authorized. */
     roots: readonly string[];
+    /** How this ceiling resolves a path it is asked about (project-identity.ts): the console's saved identities, which
+     * read no folder. Absent: canonicalProject, a synchronous read. */
+    canon?: (path: string) => string | null;
 };
 /**
  * Resolve the startup configuration once. A configured path that does not
@@ -36,7 +39,7 @@ export type ProjectCeiling = {
  * dropping would silently *widen* the server toward unscoped mode, and a
  * ceiling that loosens itself when a disk is unmounted is not a ceiling.
  */
-export declare function resolveCeiling(repos: readonly string[], roots: readonly string[]): {
+export declare function resolveCeiling(repos: readonly string[], roots: readonly string[], canon?: (path: string) => string | null | undefined): {
     ceiling: ProjectCeiling;
     unresolved: string[];
 };

package/dist/project.js

@@ -67,10 +67,10 @@ export async function projectSelection(paths, exec = run) {
  * dropping would silently *widen* the server toward unscoped mode, and a
  * ceiling that loosens itself when a disk is unmounted is not a ceiling.
  */
-export function resolveCeiling(repos, roots) {
+export function resolveCeiling(repos, roots, canon = canonicalProject) {
     const unresolved = [];
     const keep = (paths) => [...new Set(paths.map(path => {
-            const canonical = canonicalProject(path);
+            const canonical = canon(path) ?? null;
             if (canonical !== null)
                 return canonical;
             unresolved.push(path);
@@ -90,7 +90,7 @@ export function unscoped(ceiling) {
 export async function authorizedProject(ceiling, path, exec = run) {
     if (unscoped(ceiling))
         return true;
-    const canonical = canonicalProject(path);
+    const canonical = (ceiling.canon ?? canonicalProject)(path);
     if (canonical === null)
         return false;
     if (ceiling.repos.includes(canonical))
@@ -114,8 +114,15 @@ export function rowVisible(ceiling, repo) {
         return true;
     // Exact saved identities are common. Check the whole set before resolving
     // aliases, so the hundredth project does not stat the other99 directories.
-    if (ceiling.repos.includes(repo) || ceiling.repos.some(one => sameRepo(one, repo)))
+    const canon = ceiling.canon;
+    if (ceiling.repos.includes(repo) || ceiling.repos.some(one => canon === undefined ? sameRepo(one, repo) : (canon(one) ?? null) !== null && canon(one) === canon(repo)))
         return true;
+    // With a resolver (the console's saved identities), an identity it can't vouch for fails closed before any root is
+    // matched: a path's spelling never stands in for where it leads.
+    if (canon !== undefined) {
+        const resolved = canon(repo);
+        return resolved !== null && ceiling.roots.some(root => resolved.startsWith(root + sep));
+    }
     const canonical = canonicalProject(repo) ?? repo;
     return ceiling.roots.some(root => canonical.startsWith(root + sep));
 }

package/dist/provider.d.ts

@@ -177,6 +177,9 @@ export type ParsedEnvelope = {
     structuralTerminal: import("./exhaustion.js").StructuralTerminal | null;
     /** What an ACP agent itself reported it used — kept on the run, never priced. Absent for every other dialect. */
     agentReportedUsage?: string | null;
+    /** v140: the exact model the provider itself reported for this turn (Claude: its session's init, or a buffered
+     * result's one `modelUsage` model). Absent or null: not reported — every other dialect today. */
+    modelReported?: string | null;
     /** An ACP conversation's facts the conformance check reads (acp-client.ts AcpEnvelope): nothing else does. */
     acp?: {
         offered: string[];

package/dist/provider.js

@@ -30,6 +30,7 @@ import { ACP_AGENTS, isAcpProvider, withAcp } from "./acp-agents.js";
 import { acpParse } from "./acp-client.js";
 import { agentSpecSchema, MODEL_ID, modelIdSchema, PROVIDER_ID_VALUES, providerIdSchema } from "./contracts/provider.js";
 import { primaryResultEvent, topLevelEvent } from "./stream-scope.js";
+import { claudeResultReport, reportedModelOf } from "./reported-usage.js";
 export const PROVIDER_IDS = PROVIDER_ID_VALUES;
 export function isProviderId(value) {
     return providerIdSchema.safeParse(value).success;
@@ -293,7 +294,7 @@ function claudeFinalMessage(result) {
     }
     return typeof result.result === "string" ? result.result : null;
 }
-function claudeEnvelopeOf(result, sessionFromInit, initObserved, initSessionConflict = false) {
+function claudeEnvelopeOf(result, sessionFromInit, initObserved, initSessionConflict = false, initModel = { model: null, conflict: false }) {
     const input = result?.usage?.input_tokens;
     const output = result?.usage?.output_tokens;
     const cost = result?.total_cost_usd;
@@ -322,6 +323,8 @@ function claudeEnvelopeOf(result, sessionFromInit, initObserved, initSessionConf
         costUsd: typeof cost === "number" && cost >= 0 ? cost : null,
         ...(result !== null && result[CLAUDE_COST_UNKNOWN] === true ? { costUnknown: true } : {}),
         usageRaw: result?.usage === undefined ? null : JSON.stringify(result.usage).slice(0, USAGE_JSON_CAP),
+        // The model only when the session's own events name it (never the agent's words); no result, no report.
+        modelReported: result === null ? (initModel.conflict ? null : initModel.model) : claudeResultReport(result, initModel).modelReported,
         initObserved,
         // Structural, never prose (finding 15): consumed means the primary
         // result says SUCCESS. An error result keeps its text as diagnostics
@@ -354,6 +357,7 @@ function claudeParse(stdout) {
     let initSeen = false;
     let sessionFromInit = null;
     let initSessionConflict = false;
+    const initModels = new Set();
     let primary = null;
     let transportFailure = null;
     for (const line of stdout.split("\n")) {
@@ -379,6 +383,9 @@ function claudeParse(stdout) {
         }
         if (String(type) === "system" && String(event["subtype"] ?? "") === "init") {
             initSeen = true;
+            const model = reportedModelOf(event["model"]);
+            if (model !== null)
+                initModels.add(model);
             const id = sessionIdOf(event["session_id"]);
             if (id !== null) {
                 if (sessionFromInit === null)
@@ -402,7 +409,7 @@ function claudeParse(stdout) {
                 primary = result;
         }
     }
-    const envelope = claudeEnvelopeOf(primary, sessionFromInit, initSeen, initSessionConflict);
+    const envelope = claudeEnvelopeOf(primary, sessionFromInit, initSeen, initSessionConflict, { model: initModels.size === 1 ? [...initModels][0] : null, conflict: initModels.size > 1 });
     if (transportFailure === null)
         return envelope;
     return {

package/dist/release-adapters.d.ts

@@ -8,6 +8,8 @@ import type { CheckRun, GateState, Installed, MainProtection, ReleaseAdapters }
 import { Store } from "./store.js";
 import { type CiObservation } from "./release-auto.js";
 import { type BuildRunner } from "./release-carry.js";
+import { type GhRead } from "./nightly-github.js";
+export { failedBeforeTests, type JobRecord } from "./github-jobs.js";
 import { type ReleaseRepo, type ReleaseTools } from "./release-git.js";
 export { RELEASE_PATH, RELEASE_REMOTE, releaseConfigProblem, releaseGitArgs, releaseGitEnv, releaseRemote, releaseTools, type ReleaseRepo, type ReleaseTools } from "./release-git.js";
 export type Exec = (command: string, args: readonly string[], options?: {
@@ -112,7 +114,10 @@ export declare function bumpFormula(text: string, url: string, sha256: string):
 export declare function storeReleaseAdapter(open: () => Store, done: (store: Store) => void, now: () => Date, runner?: BuildRunner, 
 /** Releases that approve themselves (auto-approve-green.md): the plane's own look at CI on a commit, and where the
  * check receipts are kept. Absent: no automatic approval, every release asks a person. */
-auto?: AutoObservers): NonNullable<ReleaseAdapters["release"]>;
+auto?: AutoObservers, 
+/** GitHub's nightly (nightly-github.ts): the plane's own gh reads for a boundary's one bounded read. Absent: nothing
+ * is read at the boundary, and the stored debt still holds inside every reservation. */
+nightlyReads?: GhRead): NonNullable<ReleaseAdapters["release"]>;
 /** What the plane itself reads for an automatic release approval. */
 export type AutoObservers = {
     /** The plane's executor policy, never a report field or project setting. Unknown refuses. Production currently
@@ -135,28 +140,23 @@ export declare function readCheckRuns(run: Exec, gh: string, repo: string, sha:
 options?: {
     tag?: string;
 }): Promise<CheckRun[]>;
-/** One job's step outcomes as GitHub's Actions API reports them. */
-export type JobRecord = {
-    id: number;
-    status: string;
-    conclusion: string | null;
-    steps: {
-        number: number;
-        name: string;
-        status: string;
-        conclusion: string | null;
-    }[];
-};
-/**
- * Whether a finished, unsuccessful job ended before any of the workflow's own steps ran: every step after GitHub's own
- * first one ("Set up job", always number 1) never ran (no conclusion, or skipped) — leaving out only GitHub's own
- * closing "Complete job" when it is the last step. Step numbers and outcomes are the runner's records; nothing the
- * candidate prints is read. A job with no steps never reached one. Anything else (a step that ran, even the checkout)
- * is not confirmed infrastructure.
- */
-export declare function failedBeforeTests(job: JobRecord): boolean;
 /** GitHub's job record for one check run (its job), read strictly: null when it can't be read whole. */
 export declare function readJobBeforeTests(run: Exec, gh: string, repo: string, id: number): Promise<boolean | null>;
+/**
+ * GitHub's REST API as GitHub's nightly reads it (nightly-github.ts): GET only, github.com only, a repository path, the
+ * plane's own gh with the allowlisted environment, each call bounded by its caller's deadline. A background read rides
+ * out a short network failure (release-net.ts, within that call's own share of the deadline); a boundary's read is
+ * plain exec. Never an answer that isn't GitHub's whole JSON.
+ */
+export declare function githubReads(run: Exec, gh: string, options?: {
+    retry?: boolean;
+}): (path: string, timeoutMs: number) => Promise<{
+    ok: true;
+    body: unknown;
+} | {
+    ok: false;
+    why: string;
+}>;
 /** GitHub lists check runs from at most the latest 1000 check suites of a commit: the history is whole only below that. */
 export declare const CHECK_SUITE_CEILING = 1000;
 export declare function readSuitesComplete(run: Exec, gh: string, repo: string, sha: string): Promise<boolean>;

package/dist/release-adapters.js

@@ -28,6 +28,9 @@ import { autoPublishHeld, holdAutoPublish, liftCiHold, authorizeAutoCheck, giveU
 import { proveCarry } from "./release-carry.js";
 import { randomBytes, randomUUID } from "node:crypto";
 import { deploymentGate } from "./deploy-gate.js";
+import { failedBeforeTests } from "./github-jobs.js";
+import { mainHistoryOf, nightlyBoundary } from "./nightly-github.js";
+export { failedBeforeTests } from "./github-jobs.js";
 import { extractCommit } from "./commit-extract.js";
 import { teardownGit, refusal as gitRefusal } from "./teardown-git.js";
 import { RELEASE_REMOTE, releaseConfigProblem, releaseGitArgs, releaseGitEnv, releaseRemote, releaseTools } from "./release-git.js";
@@ -422,7 +425,9 @@ export function releaseAdapters(options) {
         upToDateRequired: () => readUpToDateRequired(reads, ciGh, releaseRepo().slug), evidenceRoot: join(dirname(database), "evidence"),
         // A successful Actions job authenticates the job, not the candidate-writable JSON it uploads. Until the
         // executor protects that reporting channel, production releases must take the person's approval road.
-        reportsProtected: false });
+        reportsProtected: false }, 
+    // A boundary's one bounded read of GitHub's nightly: plain exec, never the release's long retries (20 s in all).
+    githubReads(run, ciGh));
     return {
         ...(existsSync(database) ? { release } : {}),
         now: options.now ?? (() => new Date()),
@@ -925,7 +930,10 @@ function personAnswerOf(value) {
 export function storeReleaseAdapter(open, done, now, runner, 
 /** Releases that approve themselves (auto-approve-green.md): the plane's own look at CI on a commit, and where the
  * check receipts are kept. Absent: no automatic approval, every release asks a person. */
-auto) {
+auto, 
+/** GitHub's nightly (nightly-github.ts): the plane's own gh reads for a boundary's one bounded read. Absent: nothing
+ * is read at the boundary, and the stored debt still holds inside every reservation. */
+nightlyReads) {
     const withStore = (body) => { const store = open(); try {
         return body(store);
     }
@@ -962,6 +970,20 @@ auto) {
         async live(taskId, action) {
             return withStore(store => { const live = liveReleaseOf(store, taskId, action, now()); return live.applies ? { applies: true, ok: live.ok, why: live.ok ? null : live.why } : { applies: false, ok: false, why: null }; });
         },
+        ...(nightlyReads === undefined ? {} : {
+            async nightly(input) {
+                const store = open();
+                try {
+                    const repo = store.lookupRef(input.taskId)?.repo ?? null;
+                    if (repo === null)
+                        return { ok: false, why: `Task ${input.taskId} is in no project, so GitHub's nightly debt can't be read for it.`, warning: null };
+                    return await nightlyBoundary(store, { repo, taskId: input.taskId, candidate: input.candidate, pr: input.pr, phase: input.phase }, { ...mainHistoryOf(store, repo, now()), gh: nightlyReads, now });
+                }
+                finally {
+                    done(store);
+                }
+            },
+        }),
         async lease(authority, owner) { return withStore(store => takeReleaseLease(store, authority, owner, now())); },
         async renew(authority, owner, epoch) { return withStore(store => renewReleaseLease(store, authority, owner, epoch, now())); },
         async carry(authority, to, requestId, epoch) {
@@ -1169,23 +1191,6 @@ options = {}) {
     }
     return runs.sort((a, b) => a.id - b.id);
 }
-/**
- * Whether a finished, unsuccessful job ended before any of the workflow's own steps ran: every step after GitHub's own
- * first one ("Set up job", always number 1) never ran (no conclusion, or skipped) — leaving out only GitHub's own
- * closing "Complete job" when it is the last step. Step numbers and outcomes are the runner's records; nothing the
- * candidate prints is read. A job with no steps never reached one. Anything else (a step that ran, even the checkout)
- * is not confirmed infrastructure.
- */
-export function failedBeforeTests(job) {
-    if (job.status !== "completed" || job.conclusion === "success" || job.conclusion === null)
-        return false;
-    const steps = [...job.steps].sort((a, b) => a.number - b.number);
-    if (new Set(steps.map(one => one.number)).size !== steps.length)
-        return false;
-    const last = steps.at(-1);
-    const own = steps.filter(one => one.number > 1 && !(one === last && one.name === "Complete job" && steps.length > 1));
-    return own.every(one => one.status !== "in_progress" && (one.conclusion === null || one.conclusion === "skipped"));
-}
 /** GitHub's job record for one check run (its job), read strictly: null when it can't be read whole. */
 export async function readJobBeforeTests(run, gh, repo, id) {
     if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo) || !Number.isSafeInteger(id) || id <= 0)
@@ -1214,6 +1219,34 @@ export async function readJobBeforeTests(run, gh, repo, id) {
     return failedBeforeTests({ id, status: String(job["status"]), conclusion: textOr(job["conclusion"]),
         steps: steps.map(one => ({ number: Number(one["number"]), name: String(one["name"]), status: String(one["status"]), conclusion: textOr(one["conclusion"]) })) });
 }
+/**
+ * GitHub's REST API as GitHub's nightly reads it (nightly-github.ts): GET only, github.com only, a repository path, the
+ * plane's own gh with the allowlisted environment, each call bounded by its caller's deadline. A background read rides
+ * out a short network failure (release-net.ts, within that call's own share of the deadline); a boundary's read is
+ * plain exec. Never an answer that isn't GitHub's whole JSON.
+ */
+export function githubReads(run, gh, options = {}) {
+    return async (path, timeoutMs) => {
+        if (!/^repos\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_./?&=%-]+$/.test(path) || timeoutMs <= 0)
+            return { ok: false, why: "not a read this makes" };
+        const exec = options.retry === true ? retryingExec(run, { say: () => { }, sleep, budgetMs: timeoutMs }) : run;
+        let result;
+        try {
+            result = await exec(gh, ["api", "--hostname", "github.com", "--method", "GET", path], { cwd: "/", env: ciEnv(), timeoutMs });
+        }
+        catch (error) {
+            return { ok: false, why: String(error?.message ?? error).slice(0, 200) };
+        }
+        if (result.code !== 0)
+            return { ok: false, why: result.code === 124 ? "GitHub didn't answer in time" : result.code === 127 ? "gh isn't installed" : (result.stderr || result.stdout).trim().split("\n").slice(-1)[0].slice(0, 200) || `gh exited ${result.code}` };
+        try {
+            return { ok: true, body: JSON.parse(result.stdout) };
+        }
+        catch {
+            return { ok: false, why: "GitHub's answer couldn't be read" };
+        }
+    };
+}
 /** GitHub lists check runs from at most the latest 1000 check suites of a commit: the history is whole only below that. */
 export const CHECK_SUITE_CEILING = 1000;
 export async function readSuitesComplete(run, gh, repo, sha) {

package/dist/release-auto.js

@@ -17,6 +17,7 @@ import { fullCheckProblem, projectGitDir } from "./check-report.js";
 import { sealedRun } from "./release-recheck.js";
 import { runCheckLevel } from "./check-levels.js";
 import { readVerifiedCommit, verifiedBlobs, verifiedTreeDiff, verifiedTreeEntries } from "./commit-extract.js";
+import { EVAL_HOOK_FILES, evalHookProblem, storeRewriteProblem } from "./eval-hooks.js";
 import { mightName, testInfrastructure } from "./test-infra.js";
 import { chatControlHref } from "./chat-controls.js";
 import { INFRA_RERUNS_PER_CANDIDATE, REQUIRED_PR_CHECKS, REQUIRED_PR_CHECKS_WORKFLOW, prChecksVerdict } from "./release.js";
@@ -27,6 +28,7 @@ import { autoReleaseApprovalOf, personApprovalOf } from "./scope.js";
 import { releaseOperations, revokeRelease } from "./store.js";
 import { RELEASE_CI_HELD_ACTION, RELEASE_CI_PASSED_ACTION, RELEASE_CI_RUNNING_WORDS, releaseCiHoldOf, releaseCiRunningOf } from "./release-ci-hold.js";
 import { verificationEvidence } from "./verification-evidence.js";
+import { nightlyDebtHold } from "./nightly-github.js";
 export { RELEASE_APPROVAL_ACTION, releaseApprovalSetting, releaseAutoApproves };
 /** The setting's words, one place. */
 export const RELEASE_APPROVAL_WORDS = { ask: "Ask me", auto: "Approve automatically when checks pass" };
@@ -177,6 +179,11 @@ export function authorizeAutoCheck(store, input) {
 const SRC_TEST_INFRA = /^src\/(fixtures\/|(.*\/)?(test-[^/]*|[^/]*-test-support[^/]*|[^/]*fixtures?[^/]*)\.[cm]?[jt]sx?$)/;
 /** A test file (normalized path): `*.test.ts`, never inside a fixtures folder. */
 const TEST_FILE = /^(?!.*(^|\/)fixtures?\/)[^]*\.test\.ts$/;
+/** The eval set's and GitHub nightly's policy code (docs/plans/evals-nightly.md, part C, finding 10): the cases and
+ * oracles, the evaluator, its gate, hooks and world, reviewer scoring, nightly ingestion, their contracts, and the
+ * accounting readings evals trust (reported-usage.ts, run-efficiency.ts). Where they are called from, and the store's
+ * accounting reads, are held by eval-hooks.ts instead (evalHookProblem). */
+const EVAL_POLICY = /^(evals\/|src\/evals[^/]*\.ts$|src\/eval-[^/]*\.ts$|src\/reviewer-evals\.ts$|src\/nightly-github\.ts$|src\/contracts\/evals[^/]*\.ts$|src\/reported-usage\.ts$|src\/run-efficiency\.ts$)/;
 /** Build or type configuration anywhere: a person approves it. */
 const BUILD_CONFIG = /(^|\/)(tsconfig[^/]*\.json|[^/]*\.config\.[cm]?[jt]s|\.npmrc|\.nvmrc|\.node-version)$/;
 /**
@@ -201,6 +208,8 @@ export function autoPathProblem(path) {
     }
     // Test files under test/ carry the same trust as src's (Alex: test authors are trusted) — only the `.test.ts` files
     // themselves, never a helper, fixture, setup or config file beside them, nor one inside a fixtures folder.
+    if (EVAL_POLICY.test(normal))
+        return "it's eval or nightly policy code";
     if (testUnderTest)
         return null;
     if (BUILD_CONFIG.test(normal))
@@ -312,6 +321,19 @@ function changeProblem(repo, base, candidate) {
         scans.push(found);
     }
     const infra = new Set(scans.flatMap(one => [...one.infra]));
+    // The eval and nightly enforcement calls the base holds must all still be in place at the candidate (eval-hooks.ts).
+    // One verified read of every listed file per tree (an unreadable tree reads as every file missing: a person decides).
+    const blobAt = (tree) => { const blobs = verifiedBlobs(gitDir, tree, EVAL_HOOK_FILES); return (file) => blobs.ok ? blobs.value.get(file)?.bytes ?? null : null; };
+    const hooks = evalHookProblem(blobAt(after.value.tree), blobAt(before.value.tree));
+    if (hooks !== null)
+        return `${hooks}: a person decides`;
+    // No changed file may write over a pinned Store method from outside store.ts (eval-hooks.ts storeRewriteProblem).
+    const changed = diff.value.filter(change => change.after !== null).map(change => change.path);
+    // A failed read is no reader at all (a person decides), never files that read as absent.
+    const changedAt = (tree) => { const blobs = verifiedBlobs(gitDir, tree, changed); return blobs.ok ? (file) => blobs.value.get(file)?.bytes ?? null : null; };
+    const rewrites = storeRewriteProblem(changed, changedAt(after.value.tree), changedAt(before.value.tree));
+    if (rewrites !== null)
+        return `${rewrites}: a person decides`;
     for (const change of diff.value) {
         const modes = [change.before?.mode, change.after?.mode].filter((one) => one !== undefined);
         if (modes.includes("120000") || modes.includes("160000"))
@@ -461,6 +483,10 @@ export function sealAutoGreen(store, input) {
         if (changed !== null)
             return refuse(changed);
         // GitHub CI, as the plane's own gh saw it moments ago, on exactly this commit.
+        // GitHub's nightly lane debt (evals-nightly.md, part A2): dormant while automatic approval is refused, held here too.
+        const nightly = nightlyDebtHold(store, { repo: facts.repo, taskId: input.taskId, candidate: input.candidate, phase: "auto", release: true, now: input.now });
+        if (nightly !== null)
+            return refuse(nightly.why);
         const ci = ciVerdict(input.ci, input.candidate, input.now);
         if (!ci.ok)
             return refuse(`CI: ${ci.problem}`);

package/dist/release-card.js

@@ -27,6 +27,7 @@ import { routeFromJson } from "./phase-routing.js";
 import { projectName } from "./project.js";
 import { RELEASE_CI_RUNNING_WORDS, releaseCiRunningOf } from "./release-ci-hold.js";
 import { RELEASE_PATH, releaseConfigProblem, releaseGitEnv, releaseRemote, releaseTools } from "./release-git.js";
+import { nightlyReleaseLines } from "./nightly-github.js";
 const NONE = "none";
 /** A budget in dollars from integer micro-dollars, in integer arithmetic: cents when it is whole cents, else every digit. */
 const money = (micro) => {
@@ -258,6 +259,8 @@ export function releaseCardOf(store, scope, formDigest, words) {
         ...(terms !== null && terms.policy.carry && terms.access !== "sandboxed" ? ["This project's checks don't run in the sandbox: later test-only commits will run outside the sandbox without being shown to you first."] : []),
         // Filed while CI runs (Alex, 2026-10-29): a person may approve now, and is told plainly what still waits.
         ...(releaseCiRunningOf(store, scope.taskId) === null ? [] : [RELEASE_CI_RUNNING_WORDS]),
+        // GitHub's nightly (nightly-github.ts): what holds this release, or why it can't be read. Not a signed term.
+        ...(terms === null ? [] : nightlyReleaseLines(store, { repo: terms.repo, taskId: scope.taskId, candidate: scope.candidate ?? null, now: new Date() })),
         "",
         ...changeWords(changes, terms, 5),
         "",