@outerlayer/cli 0.34.0-next.20261026161241 → 0.34.0-next.20261026182624

package/dist/build-info.json

@@ -1 +1 @@
-{"id":"2026-10-26T16:14:37.797Z+2a1ebb8","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}
+{"id":"2026-10-26T18:28:05.559Z+12e29af","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}

package/dist/{check-ERYYVAEM.js → check-G2K76NEM.js}

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { probeCredentials } from './chunk-E6OVLJTR.js';
-import './chunk-U6AWVO6L.js';
-import './chunk-HOUFCUMH.js';
-import './chunk-VWZHOFBP.js';
-import './chunk-4G4IH4A7.js';
-import './chunk-ZVB57WI6.js';
-import './chunk-TS3EFB7S.js';
+import { probeCredentials } from './chunk-LTN2YFLR.js';
 import './chunk-3JVYMD4G.js';
+import './chunk-ERTIEYDG.js';
 import './chunk-E7R2GIAW.js';
 import './chunk-MH6QLXUO.js';
+import './chunk-HOUFCUMH.js';
+import './chunk-P3CHDKXD.js';
+import './chunk-TS3EFB7S.js';
+import './chunk-SZU4YCBH.js';
+import './chunk-ZVB57WI6.js';
+import './chunk-6D7H5DMZ.js';
 import './chunk-P3NPTFLF.js';
 import './chunk-I3LTIAOR.js';
 import './chunk-LD3BHLK7.js';

package/dist/chunk-6D7H5DMZ.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { resolvePackRoot } from './chunk-ZQSANKS4.js';
+import { CHECK_ITEM_REASON_MAX_LENGTH, CheckItemsSchema } from './chunk-EOTMDIYC.js';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+
+createRequire(import.meta.url);
+var ARTIFACT_PROOF_REASON = "Its declared artifact proves it; the judge does not judge artifacts.";
+var NO_CITING_TEST_REASON = "No test cites this criterion, and it declares no artifact proof.";
+var NO_VERDICT_REASON = "The judge gave no result for this criterion.";
+function criterionInputs(input) {
+  const paths = [...new Set((input.citations[input.criterion.id] ?? []).map((citation) => citation.path))].sort();
+  const hash = createHash("sha256");
+  const part = (text) => {
+    hash.update(`${Buffer.byteLength(text)}:`);
+    hash.update(text);
+  };
+  part("judge-criterion-v1");
+  part(input.brief);
+  part(input.criterion.id);
+  part(input.criterion.text);
+  part(input.criterion.proof ?? "");
+  for (const path of paths) {
+    part(path);
+    part(input.testFiles.get(path) ?? "");
+  }
+  return hash.digest("hex");
+}
+var HTTPS_LINK = /^https:\/\/\S+$/;
+function refsFor(id, citations) {
+  const refs = (citations[id] ?? []).slice(0, 20).map((citation) => ({
+    path: citation.path,
+    line: citation.line,
+    // Only an https link becomes an href on a page; any other is left off rather than refusing the check.
+    ...HTTPS_LINK.test(citation.href ?? "") ? { href: citation.href } : {}
+  }));
+  return refs.length === 0 ? void 0 : refs;
+}
+function planCriteria(input) {
+  const previousById = new Map(input.previous.map((item) => [item.id, item]));
+  const settled = [];
+  const toJudge = [];
+  for (const criterion of input.criteria) {
+    const inputs = input.inputs.get(criterion.id);
+    const base = { id: criterion.id, criterion: criterion.id, ...inputs === void 0 ? {} : { inputs } };
+    const refs = refsFor(criterion.id, input.citations);
+    if (criterion.proof !== null) {
+      settled.push({ ...base, result: "skipped", reason: ARTIFACT_PROOF_REASON });
+      continue;
+    }
+    if (refs === void 0) {
+      settled.push({ ...base, result: "fail", reason: NO_CITING_TEST_REASON });
+      continue;
+    }
+    const kept = previousById.get(criterion.id);
+    if (kept !== void 0 && inputs !== void 0 && kept.inputs === inputs && (kept.result === "pass" || kept.result === "fail")) {
+      settled.push({ ...base, result: kept.result, ...kept.reason === void 0 ? {} : { reason: kept.reason }, refs });
+      continue;
+    }
+    toJudge.push(criterion);
+  }
+  return { settled, toJudge };
+}
+var MAX_ANSWER_ENTRIES = 500;
+function readAnswer(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { ok: false, problem: "expected an object" };
+  const { result, items } = raw;
+  if (result !== void 0 && result !== "pass" && result !== "fail") return { ok: false, problem: 'result: must be "pass" or "fail"' };
+  if (items !== void 0 && !Array.isArray(items)) return { ok: false, problem: "items: must be an array" };
+  const entries = items ?? [];
+  if (entries.length > MAX_ANSWER_ENTRIES) return { ok: false, problem: `items: at most ${MAX_ANSWER_ENTRIES} entries` };
+  const read = [];
+  for (const [index, entry] of entries.entries()) {
+    const { id, result: itemResult, reason } = typeof entry === "object" && entry !== null ? entry : {};
+    if (typeof id !== "string" || id === "" || id.length > 200) return { ok: false, problem: `items.${index}.id: must be text of 1 to 200 characters` };
+    if (itemResult !== "pass" && itemResult !== "fail") return { ok: false, problem: `items.${index}.result: must be "pass" or "fail"` };
+    if (reason !== void 0 && typeof reason !== "string") return { ok: false, problem: `items.${index}.reason: must be text` };
+    read.push({ id, result: itemResult, ...reason === void 0 ? {} : { reason } });
+  }
+  return { ok: true, answer: { ...result === void 0 ? {} : { result }, items: read } };
+}
+function parseJudgeAnswer(text) {
+  if (text === void 0 || text.trim() === "") return void 0;
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "the judge's items.json is not JSON" };
+  }
+  const read = readAnswer(raw);
+  return read.ok ? read : { ok: false, reason: `the judge's items.json does not match its shape: ${read.problem}` };
+}
+function oneLineReason(text) {
+  if (text === void 0) return void 0;
+  const line = text.replace(/\s+/g, " ").trim();
+  if (line === "") return void 0;
+  return line.length <= CHECK_ITEM_REASON_MAX_LENGTH ? line : `${line.slice(0, CHECK_ITEM_REASON_MAX_LENGTH - 1)}\u2026`;
+}
+function judgedItems(input) {
+  return input.toJudge.map((criterion) => {
+    const said = input.results.get(criterion.id);
+    const inputs = input.inputs.get(criterion.id);
+    const refs = refsFor(criterion.id, input.citations);
+    const reason = said === void 0 ? NO_VERDICT_REASON : oneLineReason(said.reason);
+    return {
+      id: criterion.id,
+      criterion: criterion.id,
+      result: said?.result ?? "fail",
+      ...reason === void 0 ? {} : { reason },
+      ...refs === void 0 ? {} : { refs },
+      ...inputs === void 0 || said === void 0 ? {} : { inputs }
+    };
+  });
+}
+function inCriteriaOrder(items, criteria) {
+  const order = new Map(criteria.map((criterion, index) => [criterion.id, index]));
+  return [...items].sort((a, b) => (order.get(a.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(b.id) ?? Number.MAX_SAFE_INTEGER));
+}
+function itemsSentence(items, noun) {
+  const failing = items.filter((item) => item.result === "fail").map((item) => item.id);
+  if (failing.length === 0) return void 0;
+  return `${failing.length} of ${items.length} ${items.length === 1 ? noun.one : noun.many} not satisfied: ${failing.join(", ")}`;
+}
+var MAX_TEST_FILES = 2e4;
+var MAX_TEST_FILE_BYTES = 1024 * 1024;
+async function loadCitationFinder() {
+  return await import(pathToFileURL(join(resolvePackRoot(), "maintained", "outerlayer-build", "scripts", "criterion-citations.mjs")).href);
+}
+function criteriaOf(workItem) {
+  const criteria = Object(Object(workItem).criteria);
+  if (!Array.isArray(criteria.items)) return void 0;
+  const drafted = criteria.drafted === true;
+  const items = [];
+  for (const entry of criteria.items) {
+    const { id, text, proof } = Object(entry);
+    if (typeof id !== "string" || typeof text !== "string") continue;
+    items.push({ id, text, proof: typeof proof === "string" ? proof : null, drafted });
+  }
+  return items.length === 0 ? void 0 : items;
+}
+function hostItemsOf(workItem, name) {
+  const checks = Object(workItem).checks;
+  if (!Array.isArray(checks)) return [];
+  const check = checks.find((entry) => Object(entry).name === name);
+  if (check?.source !== "host") return [];
+  const parsed = CheckItemsSchema.safeParse(check.items);
+  return parsed.success ? parsed.data : [];
+}
+
+export { MAX_TEST_FILES, MAX_TEST_FILE_BYTES, NO_CITING_TEST_REASON, NO_VERDICT_REASON, criteriaOf, criterionInputs, hostItemsOf, inCriteriaOrder, itemsSentence, judgedItems, loadCitationFinder, oneLineReason, parseJudgeAnswer, planCriteria };

package/dist/{chunk-U6AWVO6L.js → chunk-ERTIEYDG.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { scrubReason, stripTerminalControls } from './chunk-4G4IH4A7.js';
+import { scrubReason, stripTerminalControls } from './chunk-SZU4YCBH.js';
 import { checkFit, RUNNER_RESERVE_BYTES } from './chunk-V2VJYK46.js';
 import { RunnerAlreadyRunningError, readPidFile } from './chunk-LQHCNXPK.js';
 import { isSameProcess } from './chunk-JBJTC3UU.js';

package/dist/chunk-GYVMMU3U.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { criteriaOf, loadCitationFinder, hostItemsOf, MAX_TEST_FILE_BYTES, MAX_TEST_FILES, criterionInputs, NO_CITING_TEST_REASON, NO_VERDICT_REASON, planCriteria } from './chunk-6D7H5DMZ.js';
+import { WorkCommandError, resolveCredentials, getJson } from './chunk-JKNOJKVD.js';
+import { C } from './chunk-ANPNT6PM.js';
+import { sanitizeTerminal } from './chunk-MECW77XP.js';
+import { defaultFetch } from './chunk-7QAJQDHS.js';
+import { resolveRepoIdentity } from './chunk-Z7WMU3RA.js';
+import { parseWorkItemEnv } from './chunk-T2Q7ISPE.js';
+import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
+import { readDeliveryRecord } from './chunk-YQR6E6OV.js';
+import { inferArtifactKind, mediaTypeForArtifactPath, WORK_ITEM_COMMENT_MAX_BODY_LENGTH } from './chunk-EOTMDIYC.js';
+import { createHash } from 'crypto';
+import { spawnSync } from 'child_process';
+import { existsSync, statSync, readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+
+createRequire(import.meta.url);
+function kindProblem(declared, file) {
+  if (declared === "test") return "a test proof is recorded by CI, not by --record";
+  const kind = inferArtifactKind(mediaTypeForArtifactPath(file));
+  return kind === declared ? void 0 : `the kinds differ: the file is a ${kind}, but the criterion declares a ${declared} proof`;
+}
+function proofsCommentBody(head, lines) {
+  const header = `These proofs are not current at ${head.slice(0, 7)}:`;
+  const rows = lines.map((line) => `- ${line.id} (${line.proof}): ${line.reason}`);
+  const fits = (count2) => {
+    const left = rows.length - count2;
+    return [header, ...rows.slice(0, count2), ...left > 0 ? [`and ${left} more.`] : []].join("\n");
+  };
+  let count = rows.length;
+  while (count > 0 && fits(count).length > WORK_ITEM_COMMENT_MAX_BODY_LENGTH) count -= 1;
+  return fits(count);
+}
+function proofsCommentId(item, head, lines) {
+  const list = [...lines].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((line) => [line.id, line.proof, line.reason]);
+  const digest = createHash("sha256").update(JSON.stringify([item, head.toLowerCase(), list])).digest("hex");
+  return `proofs-${digest.slice(0, 32)}`;
+}
+function repositoryName(repository) {
+  return repository.replace(/\.git$/, "").split("/").filter((part) => part !== "").slice(-2).join("/").toLowerCase();
+}
+function ownPullRequest(pullRequests, requested, checkoutRepository) {
+  if (requested !== void 0) return { pr: requested };
+  const here = checkoutRepository === void 0 ? void 0 : repositoryName(checkoutRepository);
+  const open = pullRequests.filter(
+    (pr) => pr.state === "open" && typeof pr.prNumber === "number" && (here === void 0 || repositoryName(pr.repository ?? "") === here)
+  );
+  if (open.length > 1) return { ambiguous: open.map((pr) => pr.prNumber) };
+  return { pr: open[0]?.prNumber };
+}
+var NO_BRIEF = "";
+var GITHUB_BLOB = /^https:\/\/github\.com\/[^/]+\/[^/]+\/blob\/([0-9a-f]{7,64})\//;
+function commitOf(refs) {
+  for (const ref of refs) {
+    const match = GITHUB_BLOB.exec(ref.href ?? "");
+    if (match !== null) return match[1];
+  }
+  return void 0;
+}
+function unprovenCriteria(input) {
+  const { criteria, finder } = input;
+  const citations = finder.buildCitations({ ids: criteria.map((c) => c.id), files: [...input.headFiles], repository: null, sha: null });
+  const headTexts = new Map(input.headFiles.map((file) => [file.path, file.contents]));
+  const inputs = new Map(criteria.map((c) => [c.id, criterionInputs({ brief: NO_BRIEF, criterion: c, citations, testFiles: headTexts })]));
+  const notes = [];
+  const commits = /* @__PURE__ */ new Map();
+  const previous = /* @__PURE__ */ new Map();
+  const filesByCommit = /* @__PURE__ */ new Map();
+  for (const item of input.items) {
+    const criterion = criteria.find((c) => c.id === item.id);
+    if (criterion === void 0 || item.result !== "fail" || item.inputs === void 0) continue;
+    if (item.reason === NO_CITING_TEST_REASON || item.reason === NO_VERDICT_REASON) continue;
+    const commit = item.refs === void 0 ? void 0 : commitOf(item.refs);
+    if (commit === void 0) {
+      notes.push(`the links of ${item.id} name no commit`);
+      continue;
+    }
+    if (!filesByCommit.has(commit)) filesByCommit.set(commit, input.testFilesAt(commit));
+    const files = filesByCommit.get(commit);
+    if (files === void 0) {
+      notes.push(`this checkout does not hold ${item.id}'s cited tests at ${commit.slice(0, 7)}`);
+      continue;
+    }
+    const judgedCitations = finder.buildCitations({ ids: [item.id], files: [...files], repository: null, sha: null });
+    const judged = new Map(files.map((file) => [file.path, file.contents]));
+    commits.set(item.id, commit);
+    previous.set(item.id, { ...item, inputs: criterionInputs({ brief: NO_BRIEF, criterion, citations: judgedCitations, testFiles: judged }) });
+  }
+  const plan = planCriteria({ criteria, citations, inputs, previous: [...previous.values()] });
+  const settled = new Map(plan.settled.map((item) => [item.id, item]));
+  const entries = [];
+  for (const criterion of criteria) {
+    const item = settled.get(criterion.id);
+    if (item === void 0 || item.result !== "fail") continue;
+    if (item.refs === void 0) entries.push({ id: criterion.id, proof: null, state: "uncited" });
+    else entries.push({ id: criterion.id, proof: null, state: "failed", commit: commits.get(criterion.id) ?? "", reason: item.reason ?? "no reason recorded" });
+  }
+  return { entries, notes };
+}
+function git(cwd, args, input) {
+  const run = spawnSync("git", args, { cwd, input, maxBuffer: 268435456 });
+  if (run.status !== 0) throw new Error(`git ${args[0]} failed`);
+  return run.stdout;
+}
+function readObjects(cwd, specs) {
+  const out = git(cwd, ["cat-file", "--batch"], `${specs.join("\n")}
+`);
+  const texts = [];
+  let at = 0;
+  for (let n = 0; n < specs.length; n += 1) {
+    const end = out.indexOf(10, at);
+    const header = out.subarray(at, end).toString("utf8");
+    at = end + 1;
+    const match = /^[0-9a-f]+ blob (\d+)$/.exec(header);
+    if (match === null) {
+      texts.push(void 0);
+      continue;
+    }
+    const size = Number(match[1]);
+    texts.push(out.subarray(at, at + size).toString("utf8"));
+    at += size + 1;
+  }
+  return texts;
+}
+function testFilesAt(cwd, head, isTest) {
+  try {
+    const listing = git(cwd, ["ls-tree", "-r", "-l", "-z", head]);
+    const picked = /* @__PURE__ */ new Map();
+    for (const entry of listing.toString("utf8").split("\0")) {
+      const match = /^(\d+) blob ([0-9a-f]+)\s+(\d+)\t(.*)$/s.exec(entry);
+      if (match === null || !match[1].startsWith("100") || Number(match[3]) > MAX_TEST_FILE_BYTES || !isTest.test(match[4])) continue;
+      if (picked.size >= MAX_TEST_FILES) break;
+      picked.set(match[4], match[2]);
+    }
+    const paths = [...picked.keys()];
+    const texts = readObjects(cwd, [...picked.values()]);
+    return paths.flatMap((path, n) => texts[n] === void 0 ? [] : [{ path, contents: texts[n] }]);
+  } catch {
+    return void 0;
+  }
+}
+function checkoutPlaces(cwd) {
+  for (let dir = resolve(cwd); ; dir = dirname(dir)) {
+    const dotGit = resolve(dir, ".git");
+    try {
+      if (statSync(dotGit).isDirectory()) return { root: dir, common: dotGit };
+      const named = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, "utf8"))?.[1]?.trim();
+      if (named === void 0) return void 0;
+      const gitDir = resolve(dir, named);
+      let common = gitDir;
+      try {
+        common = resolve(gitDir, readFileSync(resolve(gitDir, "commondir"), "utf8").trim());
+      } catch {
+      }
+      return { root: dir, common };
+    } catch {
+    }
+    if (dirname(dir) === dir) return void 0;
+  }
+}
+async function judgeCheckName(cwd) {
+  const places = checkoutPlaces(cwd);
+  if (places === void 0) return {};
+  const delivered = readDeliveryRecord(places.common);
+  const dir = delivered?.dir ?? places.root;
+  if (!existsSync(dir)) return { note: `the governed context at ${dir} is not readable` };
+  const { checksIn, isJudgeCheck } = await import('./host-checks-NDXNYOMA.js');
+  const quiet = { line: () => void 0, error: () => void 0 };
+  const check = checksIn(dir, quiet, "").checks.find((c) => isJudgeCheck(c) && c.judge.subjects === "criteria");
+  return check === void 0 ? {} : { name: check.name };
+}
+async function findUnproven(input) {
+  try {
+    const found = await judgeCheckName(input.cwd);
+    if (found.name === void 0) return { entries: [], notes: found.note === void 0 ? [] : [found.note] };
+    const criteria = criteriaOf(input.item);
+    if (criteria === void 0) return { entries: [], notes: [] };
+    const finder = await loadCitationFinder();
+    const headFiles = testFilesAt(input.cwd, input.head, finder.TEST_FILE);
+    if (headFiles === void 0) return { entries: [], notes: [`the test files at ${input.head.slice(0, 7)} cannot be read`] };
+    const items = hostItemsOf(input.item, found.name);
+    const result = unprovenCriteria({
+      criteria,
+      finder,
+      headFiles,
+      items,
+      testFilesAt: (commit) => testFilesAt(input.cwd, commit, finder.TEST_FILE)
+    });
+    const check = Object(input.item).checks?.find((c) => Object(c).name === found.name);
+    if (check?.source === "host" && check.result === "fail" && items.length === 0) result.notes.unshift("the gateway returned no check items for the judge's result");
+    return result;
+  } catch (err) {
+    return { entries: [], notes: [err instanceof Error ? err.message : String(err)] };
+  }
+}
+
+// src/work-proofs-cmd.ts
+function liveHead(pr) {
+  if (pr.state !== "open" && pr.state !== "merged" || typeof pr.headSha !== "string" || pr.headSha === "") return void 0;
+  return pr.headSha.toLowerCase();
+}
+function otherPullRequestHeads(pullRequests, ownPr, checkoutRepository) {
+  const here = checkoutRepository === void 0 ? void 0 : repositoryName(checkoutRepository);
+  const heads = /* @__PURE__ */ new Set();
+  for (const pr of pullRequests) {
+    const head = liveHead(pr);
+    if (head === void 0) continue;
+    const isOwn = ownPr !== void 0 && pr.prNumber === ownPr && (here === void 0 || repositoryName(pr.repository ?? "") === here);
+    if (!isOwn) heads.add(head);
+  }
+  return heads;
+}
+function classifyProofs(data, checkoutHead) {
+  const heads = /* @__PURE__ */ new Set();
+  if (checkoutHead !== void 0 && checkoutHead !== "") heads.add(checkoutHead.toLowerCase());
+  data.pullRequests?.forEach((pr) => {
+    const head = liveHead(pr);
+    if (head !== void 0) heads.add(head);
+  });
+  return classifyProofsAt(data, heads);
+}
+function classifyProofsAt(data, heads) {
+  const entries = [];
+  for (const criterion of data.criteria?.items ?? []) {
+    if (criterion.proof === null || criterion.proof === "test") continue;
+    const newest = criterion.newestProof;
+    if (newest === null || newest === void 0) {
+      entries.push({ id: criterion.id, proof: criterion.proof, state: "missing", commit: null });
+    } else if (newest.commitSha !== null && heads.has(newest.commitSha.toLowerCase())) {
+      entries.push({ id: criterion.id, proof: criterion.proof, state: "current", commit: newest.commitSha });
+    } else {
+      entries.push({ id: criterion.id, proof: criterion.proof, state: "out-of-date", commit: newest.commitSha });
+    }
+  }
+  return entries;
+}
+var STATE_LABEL = { current: "current", "out-of-date": "out of date", missing: "missing" };
+function renderEntry(e) {
+  const id = sanitizeTerminal(e.id);
+  if (e.state === "uncited") {
+    return `${id}  none  uncited  No test at HEAD cites it. Put ${id} in a test's title or in a comment above the test, as in // proves ${id}`;
+  }
+  if (e.state === "failed") {
+    return `${id}  none  failed  ${sanitizeTerminal(e.commit)}  The judge failed it: ${sanitizeTerminal(e.reason)} No test that cites it has changed since. Change a test that cites ${id}.`;
+  }
+  return `${id}  ${sanitizeTerminal(e.proof)}  ${STATE_LABEL[e.state]}  ${sanitizeTerminal(e.commit ?? "no commit")}`;
+}
+function render(entries, notes, json) {
+  if (json) return JSON.stringify(entries);
+  const lines = entries.length === 0 ? ["No criterion declares a proof other than test."] : entries.map(renderEntry);
+  if (notes.length > 0) lines.push(`The command could not check the judge's results: ${notes.map(sanitizeTerminal).join("; ")}.`);
+  return lines.join("\n");
+}
+function resolveProofsItem(opts) {
+  const env = opts.env ?? process.env;
+  let item;
+  if (opts.item !== void 0) {
+    item = parseTrackerNumber(opts.item);
+    if (item === void 0) throw new WorkCommandError(trackerNumberError("--item", opts.item));
+  } else if (env.OUTERLAYER_WORK !== void 0) {
+    const parsed = parseWorkItemEnv(env.OUTERLAYER_WORK);
+    if (!("number" in parsed)) throw new WorkCommandError(parsed.reason);
+    item = parsed.number;
+  }
+  if (item === void 0) {
+    throw new WorkCommandError("no work item. Pass --item <number>, or set OUTERLAYER_WORK to the item's number.");
+  }
+  return item;
+}
+async function runWorkProofs(opts) {
+  const item = resolveProofsItem(opts);
+  const creds = resolveCredentials(opts);
+  const { data } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, opts.fetchImpl ?? defaultFetch);
+  const body = data;
+  const items = body.criteria?.items ?? [];
+  if (items.some((c) => c.proof !== null && c.proof !== "test" && !("newestProof" in c))) {
+    throw new WorkCommandError(
+      "the gateway does not report each criterion's newest proof. Update the gateway, then run this again."
+    );
+  }
+  const checkoutHead = opts.checkoutHead ?? resolveRepoIdentity(opts.cwd ?? process.cwd()).commitSha;
+  if (!checkoutHead) {
+    throw new WorkCommandError("cannot read the checkout's HEAD. Run this inside the git checkout, or pass the head explicitly.");
+  }
+  const declared = classifyProofs(body, checkoutHead);
+  const unproven = await findUnproven({ item: body, cwd: opts.cwd ?? process.cwd(), head: checkoutHead });
+  const entries = [...declared, ...unproven.entries];
+  const json = opts.json === true;
+  const output = render(entries, json ? [] : unproven.notes, json);
+  if (!opts.quiet) {
+    process.stdout.write(output + "\n");
+    if (json && unproven.notes.length > 0) process.stderr.write(`The command could not check the judge's results: ${unproven.notes.join("; ")}.
+`);
+  }
+  const inRunnerBuild = (opts.env ?? process.env).OUTERLAYER_JOB_DIR !== void 0;
+  const declaredCurrent = declared.every((e) => e.state === "current");
+  return { entries, output, exitCode: declaredCurrent && !(inRunnerBuild && unproven.entries.length > 0) ? 0 : 1 };
+}
+async function runWorkProofsCommand(opts) {
+  try {
+    if (opts.record) {
+      const { runWorkProofsRecord } = await import('./work-proofs-record-NUCWR7ZJ.js');
+      const result2 = await runWorkProofsRecord(opts);
+      process.exitCode = result2.exitCode;
+      return;
+    }
+    const result = await runWorkProofs(opts);
+    process.exitCode = result.exitCode;
+  } catch (err) {
+    if (err instanceof WorkCommandError) {
+      process.stderr.write(`${C.red}\u2717${C.reset} ${err.message}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    throw err;
+  }
+}
+
+export { classifyProofs, classifyProofsAt, kindProblem, otherPullRequestHeads, ownPullRequest, proofsCommentBody, proofsCommentId, resolveProofsItem, runWorkProofs, runWorkProofsCommand };

package/dist/{chunk-E6OVLJTR.js → chunk-LTN2YFLR.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { reportFailedStart, fitImageBuildMemory } from './chunk-U6AWVO6L.js';
-import { writePendingUpdate } from './chunk-HOUFCUMH.js';
-import { renderUpdateSteps } from './chunk-VWZHOFBP.js';
-import { releaseLease, isUnfinished, setStage, jobEnv, runHook, describeHookEnd, provisionMicroVm, deliverCommitHooks, provisionProcess, readProvisionOut, workdirProblem, MICROVM_COMMAND_DIR, commandLogOffset, startMicroVmCommand, microVmCommandLine, runCommand, startSender, finishJob, sampleGuest, foldSample, isContainerTracked, isMicroVmTracked, probeMicroVmCommand, probeCommand, appendCommandLog, judgeProbe, EXIT_CODE_FILE, isTracked, isGroupAlive, outcomeFromExitCode, isTimedOut, readCpuUsec, isIdle, stopOrphanedMicroVms, unfinishedJobs, listUnreadableJobs, listAdoptableJobs, retryFailedReleases, recoverLostJobs, GUEST_USAGE_INTERVAL_MS, hookLimitsFor, AttemptLogBook, microVmOomKills, needsRenew, renewLease, RENEW_INTERVAL_SECONDS, listTrackedJobs, restartSender, serveLease, vmAlive, writeGuestGhConfig, ALREADY_RELEASED, inTeardown } from './chunk-4G4IH4A7.js';
-import { JOB_STATE_FORMAT, readsJobState, jobStateFormatOf } from './chunk-ZVB57WI6.js';
-import { readHousekeepingRecord, writeHousekeepingRecord } from './chunk-TS3EFB7S.js';
 import { decideInstalledSwitch } from './chunk-3JVYMD4G.js';
+import { reportFailedStart, fitImageBuildMemory } from './chunk-ERTIEYDG.js';
 import { fetchVersionMeta, npmVersion, npmSupportsProvenance, fetchTarballDigest, fetchProvenance, installVersion, auditSignatures } from './chunk-E7R2GIAW.js';
 import { RUNNER_PROTOCOL } from './chunk-MH6QLXUO.js';
+import { writePendingUpdate } from './chunk-HOUFCUMH.js';
+import { renderUpdateSteps } from './chunk-P3CHDKXD.js';
+import { readHousekeepingRecord, writeHousekeepingRecord } from './chunk-TS3EFB7S.js';
+import { releaseLease, isUnfinished, setStage, jobEnv, runHook, describeHookEnd, provisionMicroVm, deliverCommitHooks, provisionProcess, readProvisionOut, workdirProblem, MICROVM_COMMAND_DIR, commandLogOffset, startMicroVmCommand, microVmCommandLine, runCommand, startSender, finishJob, sampleGuest, foldSample, isContainerTracked, isMicroVmTracked, probeMicroVmCommand, probeCommand, appendCommandLog, judgeProbe, EXIT_CODE_FILE, isTracked, isGroupAlive, outcomeFromExitCode, isTimedOut, readCpuUsec, isIdle, stopOrphanedMicroVms, unfinishedJobs, listUnreadableJobs, listAdoptableJobs, retryFailedReleases, recoverLostJobs, GUEST_USAGE_INTERVAL_MS, hookLimitsFor, AttemptLogBook, microVmOomKills, needsRenew, renewLease, RENEW_INTERVAL_SECONDS, listTrackedJobs, restartSender, serveLease, vmAlive, writeGuestGhConfig, ALREADY_RELEASED, inTeardown } from './chunk-SZU4YCBH.js';
+import { JOB_STATE_FORMAT, readsJobState, jobStateFormatOf } from './chunk-ZVB57WI6.js';
 import { realBlockedProbes, checkBlockedWithSlots, largeBuildMemoryBytes, LARGE_BUILD_DISK_BYTES, checkManagedRoom, sliceMemoryOf } from './chunk-JC6AQ6PC.js';
 import { writeMarker, readMarker, currentVersion, removeMarker, isInLayout, startedThroughCurrent, entryIn, versionDir, switchCurrent, cleanVersions, stagingDir } from './chunk-YL3RWW7X.js';
 import { RepoFilter } from './chunk-TBT347UY.js';
@@ -3279,7 +3279,7 @@ async function startRunner(configPath, deps, startup) {
       check: update.check ? () => update.check(configPath) : async () => {
         const held = heldClaudeCredential();
         const env = held === void 0 ? process.env : { ...process.env, [held.variable]: held.value };
-        return (await import('./check-ERYYVAEM.js')).runRunnerCheck(configPath, { fetchImpl: deps.fetchImpl, env });
+        return (await import('./check-G2K76NEM.js')).runRunnerCheck(configPath, { fetchImpl: deps.fetchImpl, env });
       },
       now: () => (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime(),
       log

package/dist/{chunk-VWZHOFBP.js → chunk-P3CHDKXD.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { stripTerminalControls } from './chunk-4G4IH4A7.js';
+import { stripTerminalControls } from './chunk-SZU4YCBH.js';
 import { tagToPull, imageTag, pullInstruction, readUpdateStatus, runnerImageVersion } from './chunk-SDELQEG4.js';
 import { readFileSync } from 'fs';