toolroll 0.9.81 → 0.9.83

package/dist/subscription-chat.js

@@ -10,6 +10,7 @@
  * are still interpreted and executed by lead.ts, where every act remains a
  * proposal that needs a human confirmation card.
  */
+import { takeEvalDispatch } from "./eval-gate.js";
 import { Buffer } from "node:buffer";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -22,6 +23,7 @@ import { ALL_CREDENTIAL_ENV } from "./provider.js";
 import { claudeLimitsOf, noteLimits } from "./provider-limits.js";
 import { claudeBillingFrom } from "./spend.js";
 import { primaryResultEvent, topLevelEvent } from "./stream-scope.js";
+import { claudeResultReport, codexUsageReport, reportedModelOf } from "./reported-usage.js";
 const RESPONSE_CAP_BYTES = 65_536;
 function outputSchema(tools) {
     return {
@@ -108,12 +110,29 @@ export function parseSubscriptionLeadAnswer(text, usage = {}) {
     }
     const tokensIn = typeof usage.tokensIn === "number" && tokenCount(usage.tokensIn) ? usage.tokensIn : 0;
     const tokensOut = typeof usage.tokensOut === "number" && tokenCount(usage.tokensOut) ? usage.tokensOut : 0;
-    return { ok: true, answer: { text: body["text"], calls, tokensIn, tokensOut, reportedCostMicrousd: null } };
+    return { ok: true, answer: { text: body["text"], calls, tokensIn, tokensOut, reportedCostMicrousd: null, ...reportFields(usage.report ?? null) } };
+}
+/** The harness's own report on the answer (v140): every field null when it gave none, cache counts only when it
+ * reported them. Never `reportedCostMicrousd`: a subscription's reported cost is usage, not API dollars. */
+function reportFields(report) {
+    return {
+        modelReported: report?.modelReported ?? null,
+        providerTurns: report?.providerTurns ?? null,
+        reportedCostUsd: report?.reportedCostUsd ?? null,
+        ...(report?.cacheReadTokens == null ? {} : { cacheReadTokens: report.cacheReadTokens }),
+        ...(report?.cacheWriteTokens == null ? {} : { cacheWriteTokens: report.cacheWriteTokens }),
+    };
+}
+/** Input tokens are everything the model read, cache included, when the harness reported every part (usageOf);
+ * otherwise its plain input count as before. */
+function tokensInOf(report, plain) {
+    return report.tokensIn !== null && tokenCount(report.tokensIn) ? report.tokensIn : plain;
 }
 function codexOutput(stdout) {
     let text = null;
     let tokensIn = 0;
     let tokensOut = 0;
+    let report = null;
     let completed = 0;
     let invalid = false;
     for (const line of stdout.split("\n")) {
@@ -148,27 +167,31 @@ function codexOutput(stdout) {
                 tokensIn = usage["input_tokens"];
             if (typeof usage?.["output_tokens"] === "number" && tokenCount(usage["output_tokens"]))
                 tokensOut = usage["output_tokens"];
+            report = codexUsageReport(usage);
         }
     }
     // A partial answer is not authority to run host tools. Process exit zero
     // alone is insufficient; the harness must finish this one turn successfully.
-    return { text: !invalid && completed === 1 ? text : null, tokensIn, tokensOut };
+    return { text: !invalid && completed === 1 ? text : null, tokensIn: report === null ? tokensIn : tokensInOf(report, tokensIn), tokensOut, report };
 }
-function claudeOutput(stdout) {
+/** The closing `result` (the buffered run's whole output, or the streamed run's last primary result line), with the
+ * session's init model when the stream carried one. */
+function claudeOutput(stdout, init) {
     const parsed = strictJsonParse(Buffer.from(stdout, "utf8"), RESPONSE_CAP_BYTES, 12);
     if (!parsed.ok || typeof parsed.value !== "object" || parsed.value === null || Array.isArray(parsed.value))
-        return { text: null, tokensIn: 0, tokensOut: 0 };
+        return { text: null, tokensIn: 0, tokensOut: 0, report: null };
     const body = parsed.value;
     if (body["type"] !== "result" || body["subtype"] !== "success" || body["is_error"] !== false) {
-        return { text: null, tokensIn: 0, tokensOut: 0 };
+        return { text: null, tokensIn: 0, tokensOut: 0, report: null };
     }
     const usage = body["usage"];
-    const tokensIn = typeof usage?.["input_tokens"] === "number" && tokenCount(usage["input_tokens"]) ? usage["input_tokens"] : 0;
+    const report = claudeResultReport(body, init);
+    const tokensIn = tokensInOf(report, typeof usage?.["input_tokens"] === "number" && tokenCount(usage["input_tokens"]) ? usage["input_tokens"] : 0);
     const tokensOut = typeof usage?.["output_tokens"] === "number" && tokenCount(usage["output_tokens"]) ? usage["output_tokens"] : 0;
     const structured = body["structured_output"];
     if (typeof structured === "object" && structured !== null)
-        return { text: JSON.stringify(structured), tokensIn, tokensOut };
-    return { text: typeof body["result"] === "string" ? body["result"] : null, tokensIn, tokensOut };
+        return { text: JSON.stringify(structured), tokensIn, tokensOut, report };
+    return { text: typeof body["result"] === "string" ? body["result"] : null, tokensIn, tokensOut, report };
 }
 /** The streamed run's closing `result` event: the same body the buffered
  * `--output-format json` run prints. */
@@ -190,6 +213,11 @@ function lastResultLine(stdout) {
 }
 /** Production runner; injectable so tests never consume a subscription turn. */
 export async function performSubscriptionLeadRequest(request, runner = run) {
+    // An eval world (eval-gate.ts): each request takes one of the attempt's dispatch slots; past the limit nothing is
+    // sent ("status-": nothing billed).
+    const evalSlot = takeEvalDispatch(`chat:${request.provider}`);
+    if (evalSlot.active && !evalSlot.ok)
+        return { ok: false, problem: "status-eval-dispatch-limit" };
     const dir = mkdtempSync(join(tmpdir(), "standing-orders-mate-"));
     try {
         const prompt = composeSubscriptionLeadPrompt(request);
@@ -237,12 +265,16 @@ export async function performSubscriptionLeadRequest(request, runner = run) {
         if (result.notFound)
             return { ok: false, problem: "not-found" };
         // v105: a streamed Claude turn says its plan's usage windows, and (once it answered) how this computer's Claude bills
-        // with no key from us: the chat ran with every key left out.
+        // with no key from us: the chat ran with every key left out. v140: its session's init names the exact model.
+        let init = { model: null, conflict: false };
+        // v141: how this request was billed, as its own events said (streamed Claude only); null when they didn't say.
+        let billingReported = null;
         if (command === "claude" && streaming) {
             const seen = { keySource: null, model: null, planWindows: false };
+            const initModels = new Set();
             let answered = false;
             for (const line of result.stdout.split("\n")) {
-                if (!line.includes('"rate_limit_event"') && !line.includes('"apiKeySource"') && !line.includes('"type":"result"'))
+                if (!line.includes('"rate_limit_event"') && !line.includes('"apiKeySource"') && !line.includes('"init"') && !line.includes('"type":"result"'))
                     continue;
                 let event;
                 try {
@@ -259,23 +291,30 @@ export async function performSubscriptionLeadRequest(request, runner = run) {
                 else if (event["type"] === "system" && event["subtype"] === "init" && topLevelEvent(event)) {
                     seen.keySource = typeof event["apiKeySource"] === "string" ? event["apiKeySource"] : null;
                     seen.model = typeof event["model"] === "string" ? event["model"] : null;
+                    // Every init the session sent names its model; inits that disagree leave it unknown, never chosen.
+                    const named = reportedModelOf(event["model"]);
+                    if (named !== null)
+                        initModels.add(named);
                 }
                 else if (primaryResultEvent(event))
                     answered = true;
             }
+            init = { model: initModels.size === 1 ? [...initModels][0] : null, conflict: initModels.size > 1 };
             const billing = answered ? claudeBillingFrom(seen) : null;
             if (billing !== null)
                 noteLimits({ provider: "claude", plan: null, windows: [], partial: true, billing });
+            billingReported = billing;
         }
         if (result.code !== 0)
             return { ok: false, problem: `status-${result.code}` };
-        const output = request.provider === "codex-subscription" ? codexOutput(result.stdout) : claudeOutput(streaming ? lastResultLine(result.stdout) : result.stdout);
+        const output = request.provider === "codex-subscription" ? codexOutput(result.stdout) : claudeOutput(streaming ? lastResultLine(result.stdout) : result.stdout, init);
         if (output.text === null)
             return { ok: false, problem: "malformed-reply" };
         if (request.outputSchema !== undefined) {
-            return { ok: true, answer: { text: output.text, calls: [], tokensIn: output.tokensIn, tokensOut: output.tokensOut, reportedCostMicrousd: null } };
+            return { ok: true, answer: { text: output.text, calls: [], tokensIn: output.tokensIn, tokensOut: output.tokensOut, reportedCostMicrousd: null, ...reportFields(output.report), billingReported } };
         }
-        return parseSubscriptionLeadAnswer(output.text, output);
+        const parsed = parseSubscriptionLeadAnswer(output.text, output);
+        return parsed.ok ? { ok: true, answer: { ...parsed.answer, billingReported } } : parsed;
     }
     finally {
         rmSync(dir, { recursive: true, force: true });

package/dist/task-sizing.js

@@ -15,6 +15,7 @@
  * The task text is data to the classifier, never instructions, and all it
  * can return is one of three sizes, a yes/no, and a short reason.
  */
+import { inEvalWorld } from "./eval-gate.js";
 import { randomUUID } from "node:crypto";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -75,6 +76,9 @@ export function claudeSizer(runner = run, model = SIZING_CLAUDE_MODEL, budgetMs
     return async (input, signal) => {
         if (signal.aborted)
             return null;
+        // An eval world makes no provider call it can't cap and record (eval-gate.ts): the task goes unsized.
+        if (inEvalWorld())
+            return null;
         const owner = `sizing:${randomUUID()}`;
         const stop = () => { terminateOwnedProcesses(owner); };
         signal.addEventListener("abort", stop, { once: true });

package/dist/teardown-git.d.ts

@@ -38,7 +38,11 @@ export declare function teardownGit(runner?: Runner, binding?: GitBinding, lockT
  * git at any file, a pipe that never ends among them. Each file is read only as the regular file it is, bounded; one
  * that can't be read so counts as including.
  */
-export declare function checkoutIncludes(checkout: string, gitFile?: string): boolean;
+/** What is left of a caller's deadline, in ms (viewedGitSync's `deadline`): absent, no deadline. */
+type Limit = () => number;
+export declare function checkoutIncludes(checkout: string, gitFile?: string, limit?: Limit): boolean;
+/** What includeIn answers when Git didn't finish parsing the file in time: still a refusal, named as what it is. */
+export declare const INCLUDE_PARSE_TIMED_OUT = "Git didn't finish reading it in time";
 export type GitBinding = {
     repo?: string | null;
 };
@@ -50,7 +54,7 @@ export declare const WRITE_VIEW_FLAGS: readonly string[];
 /** Whether the checkout's .lfsconfig (read as git parses it, that file only) sets any git-lfs key that could name a
  * program (anything but INERT_LFS). A file that
  * isn't a plain one, or doesn't parse, counts as naming one. */
-export declare function lfsExtensionIn(checkout: string, gitFile?: string): boolean;
+export declare function lfsExtensionIn(checkout: string, gitFile?: string, limit?: Limit): boolean;
 /** Every command runs against a view of the checkout's repository (gitView) whose config and info are copies the
  * plane made, inspected there, so neither can change between the inspection and the run. `mode` "read" is for reading
  * a checkout an agent may still be writing (the code page): every command also takes readFlags(), and the view holds
@@ -88,6 +92,7 @@ export declare function checkoutGitSync(cwd: string, args: readonly string[], op
  */
 export declare function viewedGitSync(cwd: string, args: readonly string[], options: {
     timeoutMs?: number;
+    deadline?: number;
     maxBuffer?: number;
     binding?: GitBinding;
 }): {
@@ -96,6 +101,7 @@ export declare function viewedGitSync(cwd: string, args: readonly string[], opti
 };
 export declare function viewedGitSync(cwd: string, args: readonly string[], options: {
     timeoutMs?: number;
+    deadline?: number;
     maxBuffer?: number;
     binding?: GitBinding;
     buffer: true;
@@ -137,3 +143,4 @@ export declare function lazyFetchSetting(listing: string): string | null;
  * command and protocol settings refused, a partial clone refused) is the config git then runs with.
  */
 export declare function lazyFetchSafeGit(inner?: Runner): Runner;
+export {};

package/dist/teardown-git.js

@@ -290,28 +290,19 @@ export function teardownGit(runner = run, binding = {}, lockTimeoutMs, gitFile =
         }, !removal, lockTimeoutMs, gitFile);
     }, true, lockTimeoutMs, gitFile);
 }
-/**
- * Git on a build's checkout, as the plane runs it outside every fence (staging, committing and inspecting the build's
- * work): the same fixed hardening as teardown (no hooks, fsmonitor, ext transport, credential helpers or automatic
- * maintenance, no submodule recursion, no signing), refused outright when the checkout's own config includes a file
- * or names a command — a filter, an external diff, a textconv, a pager — which a build could have planted. It reads no
- * global or system config: only their values (identity, line endings, a standard git-lfs install) are carried over.
- * It never enters a submodule or nested repository (whose config it never read).
- */
-/**
- * Whether a checkout's own git config (its repository's config and its worktree's config.worktree) includes another
- * file, read without git: every git command follows includes as it starts, so an include of the build's could point
- * git at any file, a pipe that never ends among them. Each file is read only as the regular file it is, bounded; one
- * that can't be read so counts as including.
- */
-export function checkoutIncludes(checkout, gitFile = "git") {
+/** A setup call's time limit: its own five seconds, or less when a caller's deadline leaves less (never below 1 ms;
+ * a caller checks the deadline itself before calling). */
+const setupTimeout = (limit) => limit === undefined ? 5_000 : Math.max(1, Math.min(5_000, limit()));
+export function checkoutIncludes(checkout, gitFile = "git", limit) {
     const dirs = gitDirsOf(checkout);
     if (dirs === null)
         return true;
     for (const path of [join(dirs.common, "config"), join(dirs.gitdir, "config.worktree")]) {
         if (!existsSync(path) && path.endsWith("config.worktree"))
             continue;
-        if (includeIn(path, gitFile) !== null)
+        if (limit !== undefined && limit() <= 0)
+            return true;
+        if (includeIn(path, gitFile, limit) !== null)
             return true;
     }
     return false;
@@ -358,13 +349,23 @@ function gitDirsOf(checkout) {
     const named = regularFile(join(gitdir, "commondir"))?.trim();
     return { gitdir, common: named === undefined || named === "" ? gitdir : resolve(gitdir, named) };
 }
+/** What includeIn answers when Git didn't finish parsing the file in time: still a refusal, named as what it is. */
+export const INCLUDE_PARSE_TIMED_OUT = "Git didn't finish reading it in time";
+/** The include parse's own limit: a loaded machine (a CI runner's parallel test files) can take seconds to start git, and
+ * a refusal that names a slow machine an "unreadable file" sent two releases chasing a config that was fine. */
+const INCLUDE_PARSE_MS = 15_000;
 /** The include key one config file sets (lowercased, as git names it), "include" when only a plain reading finds one,
- * or "an unreadable file" when it can't be read as a plain file or parsed; null when it includes nothing. */
-function includeIn(path, gitFile = "git") {
+ * "an unreadable file" when it can't be read as a plain file or parsed, or INCLUDE_PARSE_TIMED_OUT when the caller's
+ * deadline or the parse's own limit ran out first; null when it includes nothing. Every non-null answer refuses. */
+function includeIn(path, gitFile = "git", limit) {
     const text = regularFile(path);
     if (text === null)
         return "an unreadable file";
-    const parsed = spawnSync(gitFile, ["config", "--file", path, "--no-includes", "--name-only", "--list", "-z"], { cwd: "/", encoding: "utf8", timeout: 5_000, killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } });
+    if (limit !== undefined && limit() <= 0)
+        return INCLUDE_PARSE_TIMED_OUT;
+    const parsed = spawnSync(gitFile, ["config", "--file", path, "--no-includes", "--name-only", "--list", "-z"], { cwd: "/", encoding: "utf8", timeout: limit === undefined ? INCLUDE_PARSE_MS : Math.max(1, Math.min(INCLUDE_PARSE_MS, limit())), killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } });
+    if (parsed.status === null && (parsed.signal === "SIGKILL" || parsed.error?.code === "ETIMEDOUT"))
+        return INCLUDE_PARSE_TIMED_OUT;
     if (parsed.status !== 0)
         return "an unreadable file";
     const named = parsed.stdout.split("\0").find(name => /^(include\.path|includeif\..*\.path)$/i.test(name));
@@ -474,7 +475,7 @@ function boundDirs(checkout, binding = {}) {
 const ADMIN_LINKED = ["index", "logs", "refs", "reftable"];
 /** What git keeps in a common directory (its path.c common_list, and reftable), linked whether or not it exists yet. */
 const COMMON_NAMES = ["branches", "gc.pid", "logs", "lost-found", "modules", "objects", "packed-refs", "reftable", "refs", "remotes", "rr-cache", "shallow", "svn", "worktrees"];
-function gitView(checkout, kind, binding = {}, gitFile = "git") {
+function gitView(checkout, kind, binding = {}, gitFile = "git", limit) {
     const dirs = boundDirs(checkout, binding);
     const root = ensureGitViewsRoot(realpathSync(homedir()));
     const view = realpathSync(mkdtempSync(join(root, `${kind}-`)));
@@ -488,9 +489,15 @@ function gitView(checkout, kind, binding = {}, gitFile = "git") {
             throw new Error("the checkout's git config couldn't be read as a plain file");
         const configPath = join(view, "config");
         writeFileSync(configPath, config, { mode: 0o600 });
-        const plain = { cwd: "/", encoding: "utf8", timeout: 5_000, killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } };
+        const base = { cwd: "/", encoding: "utf8", killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } };
+        // Each call's limit is worked out as it starts, from what is left of a caller's deadline.
+        const plainNow = () => {
+            if (limit !== undefined && limit() <= 0)
+                throw new Error("the read's deadline passed");
+            return { ...base, timeout: setupTimeout(limit) };
+        };
         if (/worktreeconfig/i.test(config)) {
-            const flag = spawnSync(gitFile, ["config", "--file", configPath, "--no-includes", "--type=bool", "--get", "extensions.worktreeConfig"], plain);
+            const flag = spawnSync(gitFile, ["config", "--file", configPath, "--no-includes", "--type=bool", "--get", "extensions.worktreeConfig"], plainNow());
             if (flag.status !== 0 && flag.status !== 1)
                 throw new Error("the checkout's git config couldn't be read");
             if (flag.stdout.trim() === "true") {
@@ -502,11 +509,13 @@ function gitView(checkout, kind, binding = {}, gitFile = "git") {
                 config = `${config}\n${own}`;
                 writeFileSync(configPath, config, { mode: 0o600 });
             }
-            const unset = spawnSync(gitFile, ["config", "--file", configPath, "--unset-all", "extensions.worktreeConfig"], plain);
+            const unset = spawnSync(gitFile, ["config", "--file", configPath, "--unset-all", "extensions.worktreeConfig"], plainNow());
             if (unset.status !== 0 && unset.status !== 5)
                 throw new Error("the checkout's git config couldn't be read");
         }
-        const include = includeIn(configPath, gitFile);
+        const include = includeIn(configPath, gitFile, limit);
+        if (include === INCLUDE_PARSE_TIMED_OUT)
+            throw new Error(`the checkout's git config couldn't be checked: ${INCLUDE_PARSE_TIMED_OUT}; try again`);
         if (include !== null)
             throw new Error(`the checkout's git config includes another file (${include})`);
         mkdirSync(join(view, "info"));
@@ -1029,7 +1038,7 @@ export const WRITE_VIEW_FLAGS = ["-c", "worktree.useRelativePaths=false", "-c",
 /** Whether the checkout's .lfsconfig (read as git parses it, that file only) sets any git-lfs key that could name a
  * program (anything but INERT_LFS). A file that
  * isn't a plain one, or doesn't parse, counts as naming one. */
-export function lfsExtensionIn(checkout, gitFile = "git") {
+export function lfsExtensionIn(checkout, gitFile = "git", limit) {
     const path = join(checkout, ".lfsconfig");
     try {
         if (!lstatSync(path).isFile())
@@ -1038,7 +1047,9 @@ export function lfsExtensionIn(checkout, gitFile = "git") {
     catch {
         return false;
     }
-    const parsed = spawnSync(gitFile, ["config", "--file", path, "--no-includes", "--name-only", "--list", "-z"], { cwd: "/", encoding: "utf8", timeout: 5_000, killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } });
+    if (limit !== undefined && limit() <= 0)
+        return true;
+    const parsed = spawnSync(gitFile, ["config", "--file", path, "--no-includes", "--name-only", "--list", "-z"], { cwd: "/", encoding: "utf8", timeout: setupTimeout(limit), killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } });
     return parsed.status !== 0 || parsed.stdout.split("\0").filter(Boolean).some(name => lfsCommand(name) || ["include", "includeif"].includes(keyParts(name).section));
 }
 /** Every command runs against a view of the checkout's repository (gitView) whose config and info are copies the
@@ -1140,16 +1151,26 @@ export function checkoutGitSync(cwd, args, options = {}) {
 }
 export function viewedGitSync(cwd, args, options = {}) {
     const gitFile = options.git ?? "git";
-    if (checkoutIncludes(cwd, gitFile))
+    // `deadline` (absolute, wall-clock ms): every subprocess here, setup included, gets only what is left of it, and an
+    // expired deadline throws before the next one starts or after the last one ran.
+    const deadline = options.deadline;
+    const limit = deadline === undefined ? undefined : () => deadline - Date.now();
+    const expire = () => { if (limit !== undefined && limit() <= 0)
+        throw new Error("the read's deadline passed"); };
+    expire();
+    if (checkoutIncludes(cwd, gitFile, limit))
         throw new Error("the checkout's git config includes another file, or couldn't be read as a plain file");
-    if (lfsExtensionIn(cwd, gitFile))
+    expire();
+    if (lfsExtensionIn(cwd, gitFile, limit))
         throw new Error("the checkout's .lfsconfig sets a git-lfs key that can run a command");
+    expire();
     // Its config and info/attributes as read once, in a folder of the plane's own: neither can change before git runs.
-    const view = gitView(cwd, "read", options.binding, gitFile);
+    const view = gitView(cwd, "read", options.binding, gitFile, limit);
     try {
         const env = { PATH: process.env["PATH"] ?? "", HOME: process.env["HOME"] ?? "", LANG: "C", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", GIT_TERMINAL_PROMPT: "0", ...view.env };
-        const bounded = { cwd, env, encoding: "utf8", timeout: options.timeoutMs ?? 60_000, killSignal: "SIGKILL", maxBuffer: options.maxBuffer ?? 1_048_576, stdio: ["ignore", "pipe", "pipe"] };
-        const own = spawnSync(gitFile, ["--no-optional-locks", "config", "--list", "--show-scope", "-z"], bounded);
+        const timeoutNow = () => { expire(); return limit === undefined ? options.timeoutMs ?? 60_000 : Math.max(1, Math.min(options.timeoutMs ?? 60_000, limit())); };
+        const fixed = { cwd, env, encoding: "utf8", killSignal: "SIGKILL", maxBuffer: options.maxBuffer ?? 1_048_576, stdio: ["ignore", "pipe", "pipe"] };
+        const own = spawnSync(gitFile, ["--no-optional-locks", "config", "--list", "--show-scope", "-z"], { ...fixed, timeout: timeoutNow() });
         if (own.status !== 0)
             throw new Error("its config couldn't be read");
         const key = commandSetting(own.stdout, { lfsChecked: true });
@@ -1170,16 +1191,18 @@ export function viewedGitSync(cwd, args, options = {}) {
         const argv = [...TEARDOWN_FLAGS, ...readFlags(gitFile), "-c", "diff.ignoreSubmodules=all", ...carried, ...safeArgs];
         if (options.buffer === true) {
             // stdin is the caller's own bytes when given (cat-file --batch), else closed.
-            const ran = spawnSync(gitFile, argv, { ...bounded, encoding: "buffer", ...(options.input === undefined ? {} : { input: options.input, stdio: ["pipe", "pipe", "pipe"] }) });
+            const ran = spawnSync(gitFile, argv, { ...fixed, timeout: timeoutNow(), encoding: "buffer", ...(options.input === undefined ? {} : { input: options.input, stdio: ["pipe", "pipe", "pipe"] }) });
             const why = view.settle();
             if (why !== null)
                 throw new Error(why);
+            expire();
             return { status: ran.error === undefined ? ran.status : null, stdout: ran.stdout };
         }
-        const ran = spawnSync(gitFile, argv, bounded);
+        const ran = spawnSync(gitFile, argv, { ...fixed, timeout: timeoutNow() });
         const why = view.settle();
         if (why !== null)
             throw new Error(why);
+        expire();
         return { status: ran.error === undefined ? ran.status : null, stdout: view.restore(ran.stdout ?? "", args) };
     }
     finally {

package/dist/up-processes.d.ts

@@ -26,6 +26,14 @@ export type UpWorkerConfig = {
     terminal: boolean;
     /** How long a start waits for a predecessor's watch lease to expire (a crashed worker's, after a restart). */
     leaseWaitMs: number;
+    /** Saved projects this start couldn't reach (a folder that didn't answer, a drive not connected): looked at again
+     * while it runs, and connected once they answer, on the same saved-list authority the start had. */
+    deferredRepos?: string[];
+    /** Each of those lines' removal count when this start read the saved list: a different count at binding means it was
+     * removed since (even if saved again), and the start's authority for it is gone. */
+    deferredGenerations?: Record<string, number>;
+    /** The saved line each of `repos` was proved from: a project stays while its line is saved, whatever else answers. */
+    repoLines?: Record<string, string[]>;
 };
 export type UpRoleStart = {
     type: "start";
@@ -67,6 +75,11 @@ export type RoleToParent = {
 } | {
     type: "repos";
     repos: string[];
+}
+/** The saved projects the worker still holds start authority for (it only ever shrinks: connected or removed). */
+ | {
+    type: "deferred";
+    repos: string[];
 } | {
     type: "failed";
     reason: "port-busy" | "start";

package/dist/up-processes.js

@@ -53,6 +53,7 @@ export function roleMessage(value, role) {
             return { type: "ready", role, build: value["build"], pid: value["pid"], url: value["url"], port: value["port"] };
         case "log": return text(value["line"]) ? { type: "log", line: value["line"] } : null;
         case "repos": return role === "worker" && texts(value["repos"]) ? { type: "repos", repos: [...value["repos"]] } : null;
+        case "deferred": return role === "worker" && texts(value["repos"]) ? { type: "deferred", repos: [...value["repos"]] } : null;
         case "failed": return (value["reason"] === "port-busy" || value["reason"] === "start") && text(value["detail"]) ? { type: "failed", reason: value["reason"], detail: value["detail"] } : null;
         case "fatal": return text(value["detail"]) ? { type: "fatal", detail: value["detail"] } : null;
         case "sign-in-link": return role === "console" && whole(value["id"]) && orNull(value["link"], (one) => nonEmpty(one, 2_048)) ? { type: "sign-in-link", id: value["id"], link: value["link"] } : null;
@@ -78,12 +79,15 @@ export function startMessage(value) {
         return { ...base, role: "console", config: config };
     }
     if (value["role"] === "worker") {
-        const keys = ["runner", "token", "repos", "pinnedRepos", "projectRoots", "registryPath", "pool", "forMs", "publicUrl", "stopGraceMs", "verbose", "terminal", "leaseWaitMs"];
+        const keys = ["runner", "token", "repos", "pinnedRepos", "projectRoots", "registryPath", "pool", "forMs", "publicUrl", "stopGraceMs", "verbose", "terminal", "leaseWaitMs", "deferredRepos", "deferredGenerations", "repoLines"];
         if (Object.keys(config).some(key => !keys.includes(key)))
             return null;
         if (!nonEmpty(config["runner"], 256) || !nonEmpty(config["token"], 1_024) || !texts(config["repos"]) || !texts(config["pinnedRepos"]) || !texts(config["projectRoots"]) ||
             !nonEmpty(config["registryPath"], 4_096) || !nonEmpty(config["pool"], 4_096) || !orNull(config["forMs"], (one) => whole(one, 1)) ||
-            !orNull(config["publicUrl"], (one) => nonEmpty(one, 2_048)) || !whole(config["stopGraceMs"], 0) || typeof config["verbose"] !== "boolean" || typeof config["terminal"] !== "boolean" || !whole(config["leaseWaitMs"], 0))
+            !orNull(config["publicUrl"], (one) => nonEmpty(one, 2_048)) || !whole(config["stopGraceMs"], 0) || typeof config["verbose"] !== "boolean" || typeof config["terminal"] !== "boolean" || !whole(config["leaseWaitMs"], 0) ||
+            (config["deferredRepos"] !== undefined && !texts(config["deferredRepos"])) ||
+            (config["deferredGenerations"] !== undefined && !(isObject(config["deferredGenerations"]) && Object.values(config["deferredGenerations"]).every(one => whole(one, -1, Number.MAX_SAFE_INTEGER)))) ||
+            (config["repoLines"] !== undefined && !(isObject(config["repoLines"]) && Object.values(config["repoLines"]).every(one => texts(one)))))
             return null;
         return { ...base, role: "worker", config: config };
     }

package/evals/cases/catalog/case.json

@@ -0,0 +1,25 @@
+{
+  "id": "catalog",
+  "kind": "build",
+  "title": "Add slug and catalog",
+  "goal": "Add slug.js exporting slug(text): trim and lowercase ASCII text and collapse every run of non-alphanumeric characters to one hyphen, with no hyphen at either end. Add catalog.js exporting catalog(titles): return { title, slug } records in order, and throw an Error when two titles give the same slug.",
+  "touches": [
+    "slug.js",
+    "catalog.js",
+    "test/catalog.test.mjs"
+  ],
+  "pin": {
+    "provider": "claude",
+    "model": "claude-sonnet-5-5"
+  },
+  "maxDispatches": 2,
+  "timeoutMinutes": 15,
+  "grade": {
+    "files": [
+      "slug.js",
+      "catalog.js"
+    ]
+  },
+  "expected": "pass",
+  "validatedBy": null
+}

package/evals/cases/catalog/fixture/README.md

@@ -0,0 +1,3 @@
+# Eval fixture
+
+Run `npm test`. Change only what the task asks for.

package/evals/cases/catalog/fixture/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "eval-fixture",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/evals/cases/catalog/fixture/test/catalog.test.mjs

@@ -0,0 +1,4 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+test('the fixture runs', () => assert.ok(true));

package/evals/cases/catalog/oracle.mjs

@@ -0,0 +1,23 @@
+// The hidden check's own answers (zero dependencies). Run only by the plane's oracle process, never inside a world or
+// the fence: `inputs` draws fresh inputs from a source seeded by each grading's nonce, and `expected` is the answer
+// the oracle computes itself for each one.
+export const files = ["slug.js", "catalog.js"];
+const CHARS = "abcXYZ019 &!-_.,";
+export function inputs(random) {
+  const int = (low, high) => low + Math.floor(random() * (high - low + 1));
+  const word = () => { let out = ""; const length = int(1, 12); for (let i = 0; i < length; i++) out += CHARS[int(0, CHARS.length - 1)]; return /[a-z0-9]/i.test(out) ? out : out + "q"; };
+  const out = [];
+  for (let i = 0; i < 8; i++) out.push({ kind: "slug", text: word() });
+  for (let i = 0; i < 6; i++) {
+    const titles = Array.from({ length: int(0, 4) }, word);
+    if (i % 3 === 0 && titles.length > 0) titles.push(titles[0].toUpperCase() + "!");
+    out.push({ kind: "catalog", titles });
+  }
+  return out;
+}
+const slug = text => text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+export function expected(input) {
+  if (input.kind === "slug") return { value: slug(input.text) };
+  const records = input.titles.map(title => ({ title, slug: slug(title) }));
+  return new Set(records.map(one => one.slug)).size === records.length ? { value: records } : { threw: true };
+}

package/evals/cases/catalog/probe.mjs

@@ -0,0 +1,10 @@
+// The graded program's launcher. The oracle copies this file from the installed case (never the build's copy) and
+// runs it inside the fence with the nonce and inputs on stdin; only a line naming that nonce with the right outputs
+// passes. Nothing here is visible to the agent while it builds.
+import { readFileSync } from "node:fs";
+const { nonce, inputs } = JSON.parse(readFileSync(0, "utf8"));
+const attempt = run => { try { return run(); } catch { return { threw: true }; } };
+const { slug } = await import("./slug.js");
+const { catalog } = await import("./catalog.js");
+const outputs = inputs.map(input => attempt(() => ({ value: input.kind === "slug" ? slug(input.text) : catalog(input.titles) })));
+process.stdout.write(JSON.stringify({ nonce, outputs }) + "\n");

package/evals/cases/catalog/source.md

@@ -0,0 +1,9 @@
+# catalog
+
+From the real-model pilot's fixed assignments (scripts/fixtures/pilot-scenarios.mjs, `catalog`, "multiple files"): two new modules, one using the other, with a duplicate rule that is easy to get wrong after case folding.
+
+Expected: pass.
+
+## Status
+
+Draft. The expected outcome above awaits a person's validation (`validatedBy` in case.json); until then this case counts in no canonical campaign.

package/evals/cases/csv-quoting/case.json

@@ -0,0 +1,23 @@
+{
+  "id": "csv-quoting",
+  "kind": "build",
+  "title": "Quote CSV fields",
+  "goal": "Revise csv(rows) in csv.js to support comma, quote and newline characters in fields: quote such fields and double any quote inside them. Join fields with commas and records with CRLF, and end non-empty output with a final CRLF. An empty list of rows returns an empty string. Keep the csv export.",
+  "touches": [
+    "csv.js",
+    "test/csv.test.mjs"
+  ],
+  "pin": {
+    "provider": "claude",
+    "model": "claude-sonnet-5-5"
+  },
+  "maxDispatches": 2,
+  "timeoutMinutes": 15,
+  "grade": {
+    "files": [
+      "csv.js"
+    ]
+  },
+  "expected": "pass",
+  "validatedBy": null
+}

package/evals/cases/csv-quoting/fixture/README.md

@@ -0,0 +1,3 @@
+# Eval fixture
+
+Run `npm test`. Change only what the task asks for.

package/evals/cases/csv-quoting/fixture/csv.js

@@ -0,0 +1 @@
+export const csv = rows => rows.map(r => r.join(',')).join('\n');

package/evals/cases/csv-quoting/fixture/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "eval-fixture",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/evals/cases/csv-quoting/fixture/test/csv.test.mjs

@@ -0,0 +1,5 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { csv } from '../csv.js';
+
+test('no rows', () => assert.equal(csv([]), ''));

package/evals/cases/csv-quoting/oracle.mjs

@@ -0,0 +1,14 @@
+// The hidden check's own answers (zero dependencies). Run only by the plane's oracle process, never inside a world or
+// the fence: `inputs` draws fresh inputs from a source seeded by each grading's nonce, and `expected` is the answer
+// the oracle computes itself for each one.
+export const files = ["csv.js"];
+const PARTS = ["a", "b c", ",", '"', "\n", "x", "0", ""];
+export function inputs(random) {
+  const int = (low, high) => low + Math.floor(random() * (high - low + 1));
+  const field = () => random() < 0.15 ? int(0, 99) : Array.from({ length: int(0, 3) }, () => PARTS[int(0, PARTS.length - 1)]).join("");
+  return Array.from({ length: 10 }, () => ({ rows: Array.from({ length: int(0, 3) }, () => Array.from({ length: int(1, 4) }, field)) }));
+}
+const cell = value => { const text = String(value); return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text; };
+export function expected({ rows }) {
+  return { value: rows.length === 0 ? "" : rows.map(row => row.map(cell).join(",")).join("\r\n") + "\r\n" };
+}

package/evals/cases/csv-quoting/probe.mjs

@@ -0,0 +1,9 @@
+// The graded program's launcher. The oracle copies this file from the installed case (never the build's copy) and
+// runs it inside the fence with the nonce and inputs on stdin; only a line naming that nonce with the right outputs
+// passes. Nothing here is visible to the agent while it builds.
+import { readFileSync } from "node:fs";
+const { nonce, inputs } = JSON.parse(readFileSync(0, "utf8"));
+const attempt = run => { try { return run(); } catch { return { threw: true }; } };
+const { csv } = await import("./csv.js");
+const outputs = inputs.map(({ rows }) => attempt(() => ({ value: csv(rows) })));
+process.stdout.write(JSON.stringify({ nonce, outputs }) + "\n");