toolroll 0.9.81 → 0.9.83

package/dist/exec.js

@@ -1847,6 +1847,11 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
         let initLine = null;
         let initIdentityLine = null;
         let conflictingInitLine = null;
+        /** v140: the first init's model, and the first top-level init naming another (the parser reads them as a conflict:
+         * unknown, never one of them). Kept even within one session id. */
+        let initModel = null;
+        let initModelLine = null;
+        let modelConflictLine = null;
         let initSessionId = null;
         let resultLine = null;
         let resultOverflowed = false;
@@ -1955,6 +1960,15 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
             if (type === "system" && String(event["subtype"] ?? "") === "init" && topLevelEvent(event)) {
                 if (initLine === null)
                     initLine = line;
+                const model = typeof event["model"] === "string" ? event["model"] : null;
+                if (model !== null) {
+                    if (initModel === null) {
+                        initModel = model;
+                        initModelLine = line;
+                    }
+                    else if (model !== initModel && modelConflictLine === null)
+                        modelConflictLine = line;
+                }
                 const id = transportSessionId(event["session_id"]);
                 let identityWitness = false;
                 if (id !== null) {
@@ -2052,7 +2066,7 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
             liveProviders.delete(child);
             framing.finish();
             live?.detach();
-            const lines = [initLine, initIdentityLine, conflictingInitLine, accountedResultLine(), overflowLine]
+            const lines = [initLine, initIdentityLine, conflictingInitLine, initModelLine, modelConflictLine, accountedResultLine(), overflowLine]
                 .filter((one) => one !== null)
                 .filter((line, index, all) => all.indexOf(line) === index);
             const settlement = container === null ? Promise.resolve(null) : settleContainer(container, options);

package/dist/first-tasks-child.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/first-tasks-child.js

@@ -0,0 +1,11 @@
+/**
+ * Started only by learning-look.ts: one project's first-task suggestions (first-run.ts findFirstTasks), in a process
+ * of its own so the hardened git's synchronous reads of the project's folder never hold the console's thread. Its one
+ * argument is JSON naming the project; it prints the suggestions as JSON and ends.
+ */
+import { findFirstTasks } from "./first-run.js";
+const input = JSON.parse(process.argv[2] ?? "null");
+if (input === null || typeof input.repo !== "string" || input.repo === "" || input.repo.includes("\0"))
+    process.exit(2);
+const found = await findFirstTasks(input.repo);
+process.stdout.write(JSON.stringify(found), () => process.exit(0));

package/dist/flow-draft.js

@@ -7,6 +7,7 @@
  * nothing is sent: a later zone shows it to a person, and a later step posts
  * it ({{stage.<id>}}).
  */
+import { inEvalWorld } from "./eval-gate.js";
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { run } from "./exec.js";
 import { CLAUDE_NO_TOOLS_ARGS, CLAUDE_SIGNED_OUT, claudeJsonBody, claudeModelArgs, inScratchDir } from "./claude-print.js";
@@ -59,6 +60,9 @@ export function keptDraft(text) {
 /** The production runner: Claude through the sign-in on this computer, with no tools, no MCP servers and no repository. */
 export function claudeDraftRunner(runner = run) {
     return request => inScratchDir("standing-orders-draft-", async (dir) => {
+        // An eval world makes no provider call it can't cap and record (eval-gate.ts).
+        if (inEvalWorld())
+            return { ok: false, said: "Drafts aren't written in an eval world." };
         const started = Date.now();
         const result = await runner("claude", [
             "-p", "--output-format", "json", ...CLAUDE_NO_TOOLS_ARGS, ...claudeModelArgs(request.model),

package/dist/flow-sort.js

@@ -7,6 +7,7 @@
  * second, with how sure it is. It never writes text, so nothing it returns
  * is instructions: an answer is only ever one of the zone's own options.
  */
+import { inEvalWorld } from "./eval-gate.js";
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { SORT_ROUTE_KEY, sortKeyOf, sortNoteKeyOf } from "./contracts/flow.js";
 import { readJevReply } from "./contracts/sort-answer.js";
@@ -51,6 +52,9 @@ export function sortRequest(sort, state) {
 }
 /** Ask Jev through OpenRouter. Trouble reaching it (or a refused key, or no credit) is a reason to try again, in words. */
 export async function askJev(fetcher, key, request) {
+    // An eval world makes no provider call it can't gate and record (eval-gate.ts), so nothing is sent.
+    if (inEvalWorld())
+        return { ok: false, said: "An eval world makes no Jev call." };
     const started = Date.now();
     let response;
     try {

package/dist/folder-look.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Reads of a person's own folders, kept off the console's thread.
+ *
+ * A folder can stop answering: a drive that disconnected without unmounting, a folder macOS keeps in iCloud (Desktop &
+ * Documents), or one behind a privacy prompt nobody has answered. Opening it then blocks until the system answers, and
+ * a synchronous read on the console's thread freezes every page with it (the 0.9.82 deploy, 2026-10-31: the console
+ * listened for twenty minutes without answering, its main thread inside a directory read). So every such read runs in a
+ * child process, the same read it always was, and the console waits for it only as long as a deadline allows: a folder
+ * that didn't answer degrades the one thing that needed it, in plain words, and the next look tries again.
+ *
+ * A look never goes into another mounted drive, /Volumes, or the protected folders under ~/Library, unless that is the
+ * folder the person chose. Its answers are filesystem data, read exactly as before (directory names, a repository's
+ * `.git/config` as a plain bounded file never followed through a link), and the caller still checks every path against
+ * its own ceiling.
+ */
+/** How long the console waits for a look before saying the folder didn't answer. */
+export declare const FOLDER_LOOK_MS = 4000;
+/** The `url` of `[remote "origin"]` in a git config's text. Plain JavaScript with no outside names: the look's child
+ * runs this same function (its source is sent along), so the parent and the child read a config one way. */
+export declare function originUrlIn(config: string): string | null;
+export type FolderLookRequest = 
+/** One folder's sub-folders, as the browse page shows them: at most 400 kept of 2,000 entries read, links resolved
+ * and kept only inside a root. */
+{
+    op: "list";
+    path: string;
+    roots: readonly string[];
+    home: string;
+}
+/** The origin of each registered project, and of each repository directly in a root (at most 400 folders a root). */
+ | {
+    op: "origins";
+    registered: readonly string[];
+    roots: readonly string[];
+    home: string;
+}
+/** Where each path really is (its real path, when that is a folder): a project's identity, resolved off the thread. */
+ | {
+    op: "identities";
+    paths: readonly string[];
+}
+/** A project's own `.mcp.json`, read as a plain bounded file and parsed (null when absent or not a JSON object). */
+ | {
+    op: "projectMcp";
+    path: string;
+};
+/** One look under way: its answer, and when its process has ended (a stuck child can outlive its answer). */
+export type FolderLookRun = {
+    answer: Promise<unknown>;
+    ended: Promise<void>;
+};
+/** Starts one look. Production starts a child process; tests pass their own. */
+export type FolderLookRunner = (request: FolderLookRequest, deadlineMs: number) => FolderLookRun;
+export type FolderLook<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    why: "no-answer" | "failed";
+};
+/** At most this many look processes at once, stuck ones included: a folder that never answers costs one each. */
+export declare const FOLDER_LOOK_CHILDREN = 8;
+/** The production look: the script above in a child process of this same Node (or Electron as Node), killed at its
+ * deadline. Its environment carries nothing of this process's (no NODE_OPTIONS, no secrets). At the deadline its pipe
+ * is closed and nothing of it keeps this process alive; `ended` settles only when the process has really gone. */
+export declare const childLook: FolderLookRunner;
+/** How many look processes are running now (stuck ones included). */
+export declare function folderLooksRunning(): number;
+/**
+ * One look, answered within `deadlineMs` whatever the folder does: its value, or that the folder didn't answer (it ran
+ * past the deadline, the same look is still stuck, or every child slot is held) or the look failed. A look already
+ * under way for the same request is joined, never started twice.
+ */
+export declare function lookFolders(request: FolderLookRequest, options?: {
+    runner?: FolderLookRunner;
+    deadlineMs?: number;
+}): Promise<FolderLook<unknown>>;
+export type FolderEntry = {
+    name: string;
+    path: string;
+    git: boolean;
+};
+export type FolderLookOptions = {
+    runner?: FolderLookRunner;
+    deadlineMs?: number;
+    home?: string;
+};
+/** A folder's sub-folders for the browse page (null `at`: outside every root, or not a folder). */
+export declare function listFolder(path: string, roots: readonly string[], options?: FolderLookOptions): Promise<FolderLook<{
+    at: string | null;
+    entries: FolderEntry[];
+}>>;
+/** The origin URL of each registered project, and the repositories directly in each root with theirs. */
+export declare function localOrigins(registered: readonly string[], roots: readonly string[], options?: FolderLookOptions): Promise<FolderLook<{
+    registered: {
+        path: string;
+        url: string | null;
+    }[];
+    found: {
+        path: string;
+        url: string | null;
+    }[];
+}>>;
+/** Each path's identity (its real path when that is a folder, else null), resolved off the thread. */
+export declare function lookIdentities(paths: readonly string[], options?: FolderLookOptions): Promise<FolderLook<Map<string, string | null>>>;
+/** A project's own `.mcp.json` (parsed object, or null when absent or not one), read off the thread. */
+export declare function lookProjectMcp(repo: string, options?: FolderLookOptions): Promise<FolderLook<Record<string, unknown> | null>>;

package/dist/folder-look.js

@@ -0,0 +1,302 @@
+/**
+ * Reads of a person's own folders, kept off the console's thread.
+ *
+ * A folder can stop answering: a drive that disconnected without unmounting, a folder macOS keeps in iCloud (Desktop &
+ * Documents), or one behind a privacy prompt nobody has answered. Opening it then blocks until the system answers, and
+ * a synchronous read on the console's thread freezes every page with it (the 0.9.82 deploy, 2026-10-31: the console
+ * listened for twenty minutes without answering, its main thread inside a directory read). So every such read runs in a
+ * child process, the same read it always was, and the console waits for it only as long as a deadline allows: a folder
+ * that didn't answer degrades the one thing that needed it, in plain words, and the next look tries again.
+ *
+ * A look never goes into another mounted drive, /Volumes, or the protected folders under ~/Library, unless that is the
+ * folder the person chose. Its answers are filesystem data, read exactly as before (directory names, a repository's
+ * `.git/config` as a plain bounded file never followed through a link), and the caller still checks every path against
+ * its own ceiling.
+ */
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+/** How long the console waits for a look before saying the folder didn't answer. */
+export const FOLDER_LOOK_MS = 4_000;
+/** The `url` of `[remote "origin"]` in a git config's text. Plain JavaScript with no outside names: the look's child
+ * runs this same function (its source is sent along), so the parent and the child read a config one way. */
+export function originUrlIn(config) {
+    let inOrigin = false;
+    for (const line of config.split("\n")) {
+        if (/^\s*\[/.test(line)) {
+            inOrigin = /^\s*\[remote "origin"\]\s*$/.test(line);
+            continue;
+        }
+        if (!inOrigin)
+            continue;
+        const url = /^\s*url\s*=\s*(.+)$/.exec(line)?.[1];
+        if (url !== undefined)
+            return url.trim();
+    }
+    return null;
+}
+/** At most this many look processes at once, stuck ones included: a folder that never answers costs one each. */
+export const FOLDER_LOOK_CHILDREN = 8;
+/**
+ * The child's script: plain CommonJS, given the request as its one argument, printing one JSON answer. Every file it
+ * reads is opened without following a link and without waiting on a FIFO, checked to be a regular file under its cap
+ * on the open descriptor, and read only up to its limit; every folder is read through a bounded iterator.
+ */
+const LOOK_SCRIPT = `"use strict";
+const fs = require("fs"), path = require("path");
+const originUrlIn = ${originUrlIn.toString()};
+const request = JSON.parse(process.argv[1]);
+const within = (p, root) => p === root || p.startsWith(root === "/" ? "/" : root + "/");
+const home = request.home || "/nonexistent";
+const fenced = [path.join(home, "Library"), "/Volumes", "/System/Volumes", "/Network", "/net", "/private/var/automount"];
+// A place the look never enters, unless the path is inside a folder the person chose there (that root itself, not any
+// root that happens to lie in the same protected tree).
+const offLimits = (p, roots) => fenced.some(one => within(p, one) && !roots.some(root => within(root, one) && within(p, root)));
+const rootOf = (p, roots) => roots.filter(root => within(p, root)).sort((a, b) => b.length - a.length)[0];
+// A plain file read bounded by construction (ghlist review, finding 1): never through a link (O_NOFOLLOW), never
+// waiting on a FIFO (O_NONBLOCK), a regular file under the cap by the opened descriptor, at most the limit read.
+function readBounded(file, cap, limit) {
+  let fd = null;
+  try {
+    fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > cap) return null;
+    const buffer = Buffer.alloc(Math.min(limit, stat.size));
+    const read = buffer.length === 0 ? 0 : fs.readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.toString("utf8", 0, read);
+  } catch { return null; }
+  finally { if (fd !== null) { try { fs.closeSync(fd); } catch {} } }
+}
+function origin(repo) {
+  const config = readBounded(path.join(repo, ".git", "config"), 1024 * 1024, 64 * 1024);
+  return config === null ? null : originUrlIn(config);
+}
+function children(folder, roots, links) {
+  const out = [];
+  const folderDev = fs.statSync(folder).dev;
+  const dir = fs.opendirSync(folder);
+  try {
+    for (let seen = 0; seen < 2000 && out.length < 400; seen++) {
+      const entry = dir.readSync();
+      if (entry === null) break;
+      if (!(entry.isDirectory() || (links && entry.isSymbolicLink()))) continue;
+      const spelled = path.join(folder, entry.name);
+      if (offLimits(spelled, roots)) continue;
+      let real, stat;
+      try { real = fs.realpathSync(spelled); } catch { continue; }
+      if (offLimits(real, roots) || !roots.some(root => within(real, root))) continue;
+      try { stat = fs.statSync(real); } catch { continue; }
+      if (!stat.isDirectory()) continue;
+      // Another drive mounted here: not entered unless it is itself a chosen folder.
+      if (stat.dev !== folderDev && !roots.includes(real)) continue;
+      out.push({ name: entry.name, path: real });
+    }
+  } finally { dir.closeSync(); }
+  return out;
+}
+function look() {
+  if (request.op === "projectMcp") {
+    const text = readBounded(path.join(request.path, ".mcp.json"), 1024 * 1024, 1024 * 1024);
+    if (text === null) return { config: null };
+    try { const parsed = JSON.parse(text); return { config: parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null }; }
+    catch { return { config: null }; }
+  }
+  if (request.op === "identities") {
+    return { paths: request.paths.slice(0, 500).map(one => {
+      try { const real = fs.realpathSync(path.resolve(one)); return { path: one, real: fs.statSync(real).isDirectory() ? real : null }; }
+      catch { return { path: one, real: null }; }
+    }) };
+  }
+  const roots = request.roots;
+  if (request.op === "list") {
+    const at = fs.realpathSync(request.path);
+    const root = rootOf(at, roots);
+    if (root === undefined || offLimits(at, roots) || !fs.statSync(at).isDirectory()) return { at: null, entries: [] };
+    // A folder on another drive than the root that allows it is not entered (the root itself may be one).
+    if (at !== root && fs.statSync(at).dev !== fs.statSync(root).dev) return { at: null, entries: [] };
+    const entries = children(at, roots, true)
+      .filter(one => !one.name.startsWith(".") && one.name !== "node_modules")
+      .map(one => ({ name: one.name, path: one.path, git: fs.existsSync(path.join(one.path, ".git")) }));
+    return { at, entries };
+  }
+  const registered = request.registered.slice(0, 500).map(repo => ({ path: repo, url: origin(repo) }));
+  const found = [];
+  for (const root of roots) {
+    let listed = [];
+    try { listed = children(root, roots, false); } catch { continue; }
+    for (const child of listed) {
+      if (!fs.existsSync(path.join(child.path, ".git"))) continue;
+      found.push({ path: child.path, url: origin(child.path) });
+    }
+  }
+  return { registered, found };
+}
+let answer;
+try { answer = { ok: true, value: look() }; } catch (error) { answer = { ok: false, code: error && error.code || null }; }
+process.stdout.write(JSON.stringify(answer));
+`;
+/** The production look: the script above in a child process of this same Node (or Electron as Node), killed at its
+ * deadline. Its environment carries nothing of this process's (no NODE_OPTIONS, no secrets). At the deadline its pipe
+ * is closed and nothing of it keeps this process alive; `ended` settles only when the process has really gone. */
+export const childLook = (request, deadlineMs) => {
+    const child = spawn(process.execPath, ["-e", LOOK_SCRIPT, JSON.stringify(request)], {
+        stdio: ["ignore", "pipe", "ignore"],
+        env: { PATH: process.env["PATH"] ?? "/usr/bin:/bin", ELECTRON_RUN_AS_NODE: "1" },
+        killSignal: "SIGKILL",
+    });
+    child.unref();
+    const ended = new Promise(resolveEnded => {
+        child.once("exit", () => resolveEnded());
+        child.once("error", () => resolveEnded());
+    });
+    const answer = new Promise((resolveAnswer, reject) => {
+        const chunks = [];
+        let size = 0;
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            // A child stuck in the kernel can't be reaped yet: its pipe is closed now, so it holds nothing here.
+            child.stdout.destroy();
+            reject(new Error("the look didn't answer"));
+        }, deadlineMs);
+        timer.unref();
+        child.stdout.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 8 * 1024 * 1024) {
+                child.kill("SIGKILL");
+                child.stdout.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        child.once("error", error => { clearTimeout(timer); reject(error); });
+        child.once("close", code => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`the look ended with ${code}`));
+                return;
+            }
+            try {
+                resolveAnswer(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+    answer.catch(() => { });
+    return { answer, ended };
+};
+/** Looks whose process hasn't ended, by request: callers asking the same thing share one; each holds a child slot
+ * until its process is gone. */
+const inFlight = new Map();
+/** The same request however its paths were spelled: resolved paths, roots in order. */
+function lookKey(request) {
+    const sorted = (paths) => paths.map(one => resolve(one)).sort();
+    switch (request.op) {
+        case "list": return JSON.stringify([request.op, resolve(request.path), sorted(request.roots), request.home]);
+        case "origins": return JSON.stringify([request.op, sorted(request.registered), sorted(request.roots), request.home]);
+        case "identities": return JSON.stringify([request.op, sorted(request.paths)]);
+        case "projectMcp": return JSON.stringify([request.op, resolve(request.path)]);
+    }
+}
+/** How many look processes are running now (stuck ones included). */
+export function folderLooksRunning() {
+    return inFlight.size;
+}
+/**
+ * One look, answered within `deadlineMs` whatever the folder does: its value, or that the folder didn't answer (it ran
+ * past the deadline, the same look is still stuck, or every child slot is held) or the look failed. A look already
+ * under way for the same request is joined, never started twice.
+ */
+export async function lookFolders(request, options = {}) {
+    const deadlineMs = options.deadlineMs ?? FOLDER_LOOK_MS;
+    const key = lookKey(request);
+    let run = inFlight.get(key);
+    if (run === undefined) {
+        if (inFlight.size >= FOLDER_LOOK_CHILDREN)
+            return { ok: false, why: "no-answer" };
+        try {
+            run = (options.runner ?? childLook)(request, deadlineMs);
+        }
+        catch {
+            return { ok: false, why: "failed" };
+        }
+        const mine = run;
+        inFlight.set(key, mine);
+        const forget = () => { if (inFlight.get(key) === mine)
+            inFlight.delete(key); };
+        mine.ended.then(forget, forget);
+    }
+    let timer;
+    const late = new Promise(resolveLate => { timer = setTimeout(() => resolveLate("late"), deadlineMs); });
+    try {
+        const first = await Promise.race([run.answer.then(value => ({ value }), () => "failed"), late]);
+        if (first === "late")
+            return { ok: false, why: "no-answer" };
+        if (first === "failed")
+            return { ok: false, why: "failed" };
+        const answer = first.value;
+        if (answer === null || typeof answer !== "object" || answer.ok !== true)
+            return { ok: false, why: "failed" };
+        return { ok: true, value: answer.value };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+const text = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0");
+/** A folder's sub-folders for the browse page (null `at`: outside every root, or not a folder). */
+export async function listFolder(path, roots, options = {}) {
+    const looked = await lookFolders({ op: "list", path, roots: [...roots], home: options.home ?? homedir() }, options);
+    if (!looked.ok)
+        return looked;
+    const value = looked.value;
+    if (value === null || typeof value !== "object" || !(value.at === null || text(value.at)) || !Array.isArray(value.entries))
+        return { ok: false, why: "failed" };
+    const entries = value.entries.flatMap((one) => {
+        const row = one;
+        return row !== null && typeof row === "object" && text(row.name) && text(row.path) && typeof row.git === "boolean" ? [{ name: row.name, path: row.path, git: row.git }] : [];
+    });
+    return { ok: true, value: { at: value.at, entries } };
+}
+/** The origin URL of each registered project, and the repositories directly in each root with theirs. */
+export async function localOrigins(registered, roots, options = {}) {
+    const looked = await lookFolders({ op: "origins", registered: [...registered], roots: [...roots], home: options.home ?? homedir() }, options);
+    if (!looked.ok)
+        return looked;
+    const value = looked.value;
+    if (value === null || typeof value !== "object" || !Array.isArray(value.registered) || !Array.isArray(value.found))
+        return { ok: false, why: "failed" };
+    const rows = (list) => list.flatMap((one) => {
+        const row = one;
+        return row !== null && typeof row === "object" && text(row.path) && (row.url === null || text(row.url)) ? [{ path: row.path, url: row.url }] : [];
+    });
+    return { ok: true, value: { registered: rows(value.registered), found: rows(value.found) } };
+}
+/** Each path's identity (its real path when that is a folder, else null), resolved off the thread. */
+export async function lookIdentities(paths, options = {}) {
+    const looked = await lookFolders({ op: "identities", paths: [...paths] }, options);
+    if (!looked.ok)
+        return looked;
+    const value = looked.value;
+    if (value === null || typeof value !== "object" || !Array.isArray(value.paths))
+        return { ok: false, why: "failed" };
+    const out = new Map();
+    for (const one of value.paths) {
+        const row = one;
+        if (row !== null && typeof row === "object" && text(row.path) && (row.real === null || text(row.real)))
+            out.set(row.path, row.real);
+    }
+    return { ok: true, value: out };
+}
+/** A project's own `.mcp.json` (parsed object, or null when absent or not one), read off the thread. */
+export async function lookProjectMcp(repo, options = {}) {
+    const looked = await lookFolders({ op: "projectMcp", path: repo }, options);
+    if (!looked.ok)
+        return looked;
+    const value = looked.value;
+    if (value === null || typeof value !== "object")
+        return { ok: false, why: "failed" };
+    const config = value.config;
+    return { ok: true, value: config !== null && typeof config === "object" && !Array.isArray(config) ? config : null };
+}

package/dist/github-jobs.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GitHub's own job records, read by the plane's gh (release-adapters.ts for a release's checks, nightly-github.ts for
+ * GitHub's nightly): what each step of a finished job did. Step numbers and outcomes are the runner's records; nothing
+ * the tested code prints is read.
+ */
+/** 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;

package/dist/github-jobs.js

@@ -0,0 +1,22 @@
+/**
+ * GitHub's own job records, read by the plane's gh (release-adapters.ts for a release's checks, nightly-github.ts for
+ * GitHub's nightly): what each step of a finished job did. Step numbers and outcomes are the runner's records; nothing
+ * the tested code prints is read.
+ */
+/**
+ * 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"));
+}

package/dist/invoke.d.ts

@@ -18,7 +18,7 @@
  */
 import { type AgentSpec, type Invocation, type ProviderRunner, type AgentEnding } from "./provider.js";
 import { type VersionProbe } from "./attest.js";
-import type { Store } from "./store.js";
+import { type Store } from "./store.js";
 import type { RunOptions } from "./exec.js";
 import type { Runner } from "./worktree.js";
 import { type NetworkFence, type SignInGrants } from "./agent-fence.js";

package/dist/invoke.js

@@ -16,6 +16,7 @@
  * (`adapterFor`), and only builder, planner, reviewer, and scout import
  * `invokeAgent`.
  */
+import { takeEvalDispatch } from "./eval-gate.js";
 import { adapterFor, auditOf, claudePluginEnv, isolationUnsupported, ALL_CREDENTIAL_ENV } from "./provider.js";
 import { readProviderKey, readAuthModeStrict, PROVIDER_KEY_ENV, OWN_KEY_ENV } from "./keys.js";
 import { ACP_AGENTS, isAcpProvider, isKeyedProvider } from "./acp-agents.js";
@@ -26,6 +27,7 @@ import { attestProvider } from "./attest.js";
 import { run as runCommand, runOwnerTag, streamsInput } from "./exec.js";
 import { spawnSync } from "node:child_process";
 import { currentContainment } from "./containment.js";
+import { recordRunBillingBasis, recordRunCostUnknown, recordRunModelReported } from "./store.js";
 import { witnessedRunner } from "./process-custody.js";
 import { underStopWatch } from "./task-control.js";
 import { childDatabaseEnv, isolatedChildDatabase, removeChildDatabase as removeAgentDatabase } from "./child-database.js";
@@ -153,6 +155,12 @@ export async function invokeAgent(store, runId, spec, invocation, options) {
     if (recordedSessionId !== null && requestedResumeSessionId === null && startSessionId !== recordedSessionId) {
         throw new Error(`run ${runId} already records session ${recordedSessionId} but this invocation neither resumes nor starts under it`);
     }
+    // An eval world (eval-gate.ts, docs/plans/evals-nightly.md part C): every dispatch takes one of the attempt's slots,
+    // named for this run so the runner can match it to the run's record; past the case's limit nothing spawns. Outside
+    // an eval world this changes nothing.
+    const evalSlot = takeEvalDispatch(`run:${runId}`);
+    if (evalSlot.active && !evalSlot.ok)
+        return { kind: "refused", reason: "containment", providerVersion: null, diagnostic: evalSlot.why };
     const adapter = adapterFor(spec.provider);
     const { startSessionId: _untrustedStartSessionId, streamInput: _untrustedStreamInput, ...invocationWithoutStart } = invocation;
     // Live input (live-input.ts): only Claude's builds, only through a transport that keeps stdin open. The brief is
@@ -715,6 +723,8 @@ export async function invokeAgent(store, runId, spec, invocation, options) {
     // An ACP run bills as its admission stamp says (store.acpBillingOfRun): its agent's own plan, or metered.
     const acpBilling = isAcpProvider(spec.provider) ? (store.acpBillingOfRun(runId)?.kind === "plan" ? "subscription" : "api-key") : null;
     store.fixRunBilling(runId, acpBilling ?? (authMode === "api-key" ? "api-key" : evidence ?? billingOf(spec.provider, store.handle)), new Date());
+    // v141: whether that billing is this run's own evidence or this computer's default (a guess: unknown money).
+    recordRunBillingBasis(store, runId, acpBilling !== null || authMode === "api-key" || evidence !== null ? "evidence" : "default");
     const envelope = adapter.parse(result.stdout);
     store.stampAgentReportedUsage(runId, envelope.agentReportedUsage ?? null);
     // An installed CLI too old for a build's own setup refuses its flags
@@ -765,6 +775,10 @@ export async function invokeAgent(store, runId, spec, invocation, options) {
         // How many agent turns it took, where the provider reports it (docs/plans/run-efficiency.md); unknown stays NULL.
         ...(envelope.ending?.turns == null ? {} : { agentTurns: envelope.ending.turns + (options.accumulateUsage ? run.agentTurns ?? 0 : 0) }),
     });
+    // v141: a turn whose cost wasn't reported leaves the run's money unknown for good (a sticky column, never the note).
+    recordRunCostUnknown(store, runId, envelope.costUnknown === true);
+    // v140: the exact model the provider's own events named (null: not reported); a resumed turn adds its own to the run's.
+    recordRunModelReported(store, runId, envelope.modelReported ?? null, options.accumulateUsage === true);
     // How the attempt ended, classified HERE where the structural terminal
     // still exists; a sign-in that no longer works pauses its provider.
     // A run that failed within seconds having produced nothing is read for

package/dist/lead.js

@@ -509,7 +509,10 @@ export async function runLeadTurn(input) {
             return fail("over-reservation", LEAD_FAILURE_COPY.overReserved, true);
         }
         finishStep({ state: "answered", tokensIn: answer.tokensIn, tokensOut: answer.tokensOut, settledMicrousd: stepSettled, replyBytes: Buffer.byteLength(answer.text, "utf8"),
-            cacheReadTokens: answer.cacheReadTokens ?? null, cacheWriteTokens: answer.cacheWriteTokens ?? null });
+            cacheReadTokens: answer.cacheReadTokens ?? null, cacheWriteTokens: answer.cacheWriteTokens ?? null,
+            // v140: what the provider itself reported for this request (absent: unreported, kept NULL).
+            modelReported: answer.modelReported ?? null, providerTurns: answer.providerTurns ?? null, reportedCostUsd: answer.reportedCostUsd ?? null,
+            billingReported: answer.billingReported ?? null });
         tokensIn += answer.tokensIn;
         tokensOut += answer.tokensOut;
         if (answer.cacheReadTokens === undefined)

package/dist/learning-child.d.ts

@@ -0,0 +1 @@
+export {};