nomarmy 0.1.0-alpha.21 → 0.1.0-alpha.22

package/lib/acceptance-impact.mjs

@@ -0,0 +1,215 @@
+// Later jobs use the operator's promises and the worker's import graph.
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { isDeepStrictEqual } from "node:util";
+import { createVerificationRunner } from "./verify.mjs";
+import { acceptanceEvidence } from "./acceptance-result.mjs";
+import { loadContracts, contractDisplayPath } from "./acceptance.mjs";
+import { toPosix } from "./path-utils.mjs";
+
+const MAX_DEPTH = 8;
+const MAX_FILES = 2000;
+
+// Ignore comments and unrelated strings. Keep literal import/require operands;
+// no module is evaluated while building this graph.
+function imports(source) {
+  const tokens = source.match(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|[\w$]+|[^\s]/g) ?? [];
+  const result = [];
+  const literal = token => token && /^["']/.test(token) ? token.slice(1, -1) : null;
+  const clean = tokens.filter(t => !t.startsWith("//") && !t.startsWith("/*"));
+  for (let i = 0; i < clean.length; i++) {
+    const token = clean[i];
+    let specifier = null;
+    if ((token === "import" || token === "require") && clean[i + 1] === "(" && clean[i + 3] === ")") {
+      specifier = literal(clean[i + 2]);
+    } else if (token === "import") {
+      specifier = literal(clean[i + 1]);
+      if (!specifier) {
+        for (let j = i + 1; j < clean.length && ![";", "import", "export"].includes(clean[j]); j++) {
+          if (clean[j] === "from") { specifier = literal(clean[j + 1]); break; }
+        }
+      }
+    } else if (token === "export") {
+      for (let j = i + 1; j < clean.length && ![";", "import", "export"].includes(clean[j]); j++) {
+        if (clean[j] === "from") { specifier = literal(clean[j + 1]); break; }
+      }
+    }
+    if (specifier?.startsWith("./") || specifier?.startsWith("../")) result.push(specifier);
+  }
+  return result;
+}
+
+/** Bounds are shared across criteria. An incomplete traversal is conservatively affected. */
+export function affectedContracts({ contracts, worktree, changedFiles }) {
+  const root = path.resolve(worktree);
+  const changed = new Set(changedFiles.map(file => path.resolve(root, file)));
+  const cache = new Map();
+  const hits = new Set();
+  const inside = file => file === root || (!path.relative(root, file).startsWith(".." + path.sep) && path.relative(root, file) !== ".." && !path.isAbsolute(path.relative(root, file)));
+  const resolve = (file, specifier) => {
+    const base = path.resolve(path.dirname(file), specifier);
+    const candidates = [base, ...[".mjs", ".js", ".cjs"].map(ext => base + ext), ...["index.mjs", "index.js", "index.cjs"].map(name => path.join(base, name))];
+    for (const candidate of candidates) {
+      if (!inside(candidate)) continue;
+      try { if (fs.statSync(candidate).isFile()) return candidate; } catch { /* try fallbacks */ }
+      // Deleted imports still connect their test to the change.
+      if (changed.has(candidate)) return candidate;
+    }
+    return null;
+  };
+  const reachesChange = start => {
+    const queue = [[path.resolve(root, start), 0]], visited = new Set();
+    let incomplete = false;
+    for (let index = 0; index < queue.length; index++) {
+      const [file, depth] = queue[index];
+      if (changed.has(file)) return true;
+      if (visited.has(file) || !inside(file)) continue;
+      visited.add(file);
+      if (!cache.has(file)) {
+        if (cache.size >= MAX_FILES) { hits.add("files"); incomplete = true; continue; }
+        let source = "";
+        try { source = fs.readFileSync(file, "utf8"); } catch { /* a missing reference is checked when affected */ }
+        cache.set(file, imports(source).map(specifier => resolve(file, specifier)).filter(Boolean));
+      }
+      const next = cache.get(file).filter(dependency => !visited.has(dependency));
+      if (depth >= MAX_DEPTH && next.length) { hits.add("depth"); incomplete = true; continue; }
+      queue.push(...next.map(dependency => [dependency, depth + 1]));
+    }
+    return incomplete;
+  };
+  const selected = changed.size ? contracts.map(contract => ({
+    ...contract,
+    criteria: contract.criteria.filter(criterion => criterion.status !== "retired"
+      && criterion.proven_by.some(ref => "file" in ref && reachesChange(ref.file))),
+  })).filter(contract => contract.criteria.length) : [];
+  return { contracts: selected, ...(hits.size ? { bounded: { depth: MAX_DEPTH, files: MAX_FILES, hit: [...hits].sort() } } : {}) };
+}
+
+/** Snapshot operator contracts outside the worker tree and check inside verification's sandbox. */
+export async function runContractChecks({ contracts, worktree, projectDir, jobDir, jobId,
+  timeoutMs, verify = createVerificationRunner({ hostProjectDir: projectDir,
+    ...(timeoutMs === undefined ? {} : { commandTimeoutMs: timeoutMs, overallTimeoutMs: timeoutMs }) }) }) {
+  const directory = fs.mkdtempSync(path.join(jobDir ?? os.tmpdir(), "acceptance-contracts-"));
+  try {
+    fs.chmodSync(directory, 0o755);
+    contracts.forEach(({ file, ...contract }, index) => {
+      fs.writeFileSync(path.join(directory, `${index}.yml`), JSON.stringify(contract), { mode: 0o644 });
+    });
+    const checked = acceptanceEvidence(await verify({ cwd: worktree, jobId,
+      profile: "acceptance-contracts", acceptanceContractsDir: directory }));
+    // The checker reports mount-relative paths. Match by snapshot filename, not
+    // criterion IDs (IDs need only be unique within each contract).
+    if (checked.contracts.length !== contracts.length) throw new Error("incomplete acceptance result");
+    return contracts.map((contract, index) => {
+      const result = checked.contracts.find(entry => typeof entry.file === "string" && path.posix.basename(entry.file) === `${index}.yml`);
+      if (!result || JSON.stringify(result.criteria.map(c => c.id)) !== JSON.stringify(contract.criteria.map(c => c.id))) {
+        throw new Error("incomplete acceptance result");
+      }
+      return { file: contract.file, results: result.criteria };
+    });
+  } finally { fs.rmSync(directory, { recursive: true, force: true }); }
+}
+
+/** No contracts or affected criteria means no sandbox run. */
+export async function checkJobContracts({ projectDir, worktree, changedFiles, timeoutMs, jobDir, jobId, verify, run = runContractChecks }) {
+  const impact = affectedContracts({ contracts: loadContracts(projectDir), worktree, changedFiles });
+  const criteria = impact.contracts.flatMap(contract => contract.criteria.map(({ id, text }) => ({
+    id, text, file: contractDisplayPath(projectDir, contract.file),
+  })));
+  const record = { affected: criteria.map(criterion => criterion.id), broken: [], ...(impact.bounded ? { bounded: impact.bounded } : {}) };
+  if (!criteria.length) return { record, criteria, issues: [] };
+  let checked;
+  try { checked = await run({ contracts: impact.contracts, worktree, projectDir, timeoutMs, jobDir, jobId, verify }); }
+  catch (error) {
+    checked = impact.contracts.map(contract => ({ file: contract.file, results: contract.criteria.map(criterion => ({
+      id: criterion.id, status: "broken", failures: [{ detail: `couldn't run: ${error.message}` }],
+    })) }));
+  }
+  for (const contract of checked) {
+    for (const result of contract.results) {
+      if (result.status === "broken" || result.status === "missing") record.broken.push({
+        id: result.id, file: contractDisplayPath(projectDir, contract.file), failures: result.failures,
+      });
+    }
+  }
+  const issues = record.broken.map(({ id, file, failures }) =>
+    `CONTRACT BROKEN: ${id} (${file}): ${failures.map(ref => ref.file ? `${ref.file}: ${ref.test}` : ref.command ?? ref.detail).join("; ")}`);
+  return { record, criteria, issues };
+}
+
+/** Trigger on both sides of every change, independent of test classification. */
+export function touchesAcceptance(nameStatus) {
+  return nameStatus.some(entry => [entry.path, entry.oldPath].some(file =>
+    typeof file === "string" && /^acceptance\//i.test(file.replaceAll("\\", "/").replace(/^\.\//, ""))));
+}
+
+/** Compare the loader's complete declarations without executing either side's proofs.
+ * Git supplies the base tree, never the operator's possibly modified worktree.
+ * Accumulate failures and findings before reporting, including unexpected errors.
+ */
+export async function changedContractWeakening({ worktree, baseSha, nameStatus = [], gitRaw, load = loadContracts }) {
+  const weakened = [], errors = [];
+  let files = [], directory;
+  const fail = error => {
+    let message = toPosix(error.message ?? String(error));
+    for (const root of [directory, worktree].filter(Boolean).map(toPosix).sort((a, b) => b.length - a.length)) {
+      message = message.replaceAll(`${root.replace(/\/$/, "")}/`, "");
+    }
+    errors.push(message);
+  };
+  try {
+    directory = fs.mkdtempSync(path.join(os.tmpdir(), "acceptance-base-"));
+    const paths = (await gitRaw(["ls-tree", "-r", "--name-only", "-z", baseSha], worktree)).split("\0").filter(Boolean);
+    for (const file of paths.filter(file => /^acceptance\//i.test(file))) {
+      try {
+        const target = path.resolve(directory, file);
+        if (!target.startsWith(directory + path.sep)) throw new Error("invalid base contract path");
+        const source = await gitRaw(["show", `${baseSha}:${file}`], worktree);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, source);
+      } catch (error) { fail(error); }
+    }
+    const before = load(directory, { onError: fail });
+    const after = load(worktree, { onError: fail });
+    const changed = new Set(nameStatus.map(entry => entry.path));
+    files = after.map(contract => contractDisplayPath(worktree, contract.file)).filter(file => changed.has(file));
+    const index = new Map();
+    for (const contract of after) {
+      for (const criterion of contract.criteria) {
+        if (index.has(criterion.id)) fail(new Error(`duplicate criterion ${criterion.id}`));
+        else index.set(criterion.id, criterion);
+      }
+    }
+    const normalizedText = text => text.trim().replace(/\s+/g, " ");
+    const rank = { met: 3, unproven: 2, broken: 1, missing: 1, retired: 0 };
+    for (const contract of before) {
+      for (const criterion of contract.criteria) {
+        const changes = [];
+        try {
+          const next = index.get(criterion.id);
+          if (!next) changes.push("criterion removed");
+          else {
+            if (normalizedText(criterion.text) !== normalizedText(next.text)) {
+              changes.push(`text changed from ${JSON.stringify(criterion.text)} to ${JSON.stringify(next.text)}`);
+            }
+            if (criterion.security === true && next.security !== true) changes.push("security protection removed");
+            if (rank[next.status] < rank[criterion.status]) changes.push(`${criterion.status} status changed to ${next.status}`);
+            if (criterion.proven_by.some(ref => !next.proven_by.some(value => isDeepStrictEqual(ref, value)))) changes.push("proofs removed");
+          }
+        } catch (error) { fail(error); }
+        if (changes.length) weakened.push({ id: criterion.id, file: contractDisplayPath(directory, contract.file), changes });
+      }
+    }
+  } catch (error) { fail(error); }
+  finally {
+    if (directory) {
+      try { fs.rmSync(directory, { recursive: true, force: true }); }
+      catch (error) { fail(error); }
+    }
+  }
+  const issues = weakened.map(({ id, file, changes }) =>
+    `CONTRACT WEAKENED: ${id} (${file}): ${changes.join("; ")}`);
+  if (errors.length) issues.push(`CONTRACT CHECK ERROR: ${errors.join("; ")}`);
+  return { weakened, issues, files };
+}

package/lib/acceptance-result.mjs

@@ -0,0 +1,21 @@
+// Only sandboxed checker output is evidence for automatic acceptance checks.
+export function parseAcceptanceResult(stdout) {
+  let result;
+  try { result = JSON.parse(stdout); }
+  catch { throw new Error("acceptance check returned non-JSON output"); }
+  const statuses = ["met", "broken", "missing", "unproven", "retired"];
+  if (!Array.isArray(result?.contracts) || result.contracts.some(contract =>
+    !Array.isArray(contract?.criteria) || contract.criteria.some(criterion =>
+      typeof criterion?.id !== "string" || !statuses.includes(criterion.status)))) {
+    throw new Error("acceptance check returned invalid JSON result");
+  }
+  return result;
+}
+
+export function acceptanceEvidence(value) {
+  if (value?.status === "not_run" || !value?.acceptanceResult) {
+    throw new Error(["sandbox-unavailable", "sandbox-image-build-failed"].includes(value?.basis) ? "sandbox unavailable"
+      : value?.reason || value?.detail || "sandbox acceptance produced no result");
+  }
+  return value.acceptanceResult;
+}

package/lib/acceptance.mjs

@@ -0,0 +1,166 @@
+// Acceptance contracts keep feature promises tied to executable regression checks.
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import YAML from "yaml";
+import { z } from "zod";
+import { typeError } from "./zod-issues.mjs";
+import { toPosix } from "./path-utils.mjs";
+
+export const criterionIdSchema = z.string().regex(/^[A-Z][A-Z0-9]*-\d+$/, "must be an ID such as WIN-6");
+
+const string = () => z.string({ error: typeError("a string") }).min(1, "must not be empty");
+const platformsSchema = z.array(z.enum([
+  "aix", "android", "cygwin", "darwin", "freebsd", "haiku", "linux", "netbsd", "openbsd", "sunos", "win32", "posix",
+]));
+const dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "must be YYYY-MM-DD").refine((value) => {
+  const date = new Date(`${value}T00:00:00Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}, "must be a real date");
+const referenceSchema = z.union([
+  z.object({ file: string(), test: string(), platforms: platformsSchema.optional() }).strict(),
+  z.object({ command: string(), cwd: string().optional(), platforms: platformsSchema.optional() }).strict(),
+  z.object({ manual: string(), checked_by: string(), date: dateSchema, expires_days: z.number().int().positive().optional(), platforms: platformsSchema.optional() }).strict(),
+]);
+export const contractSchema = z.object({
+  feature: string(),
+  run: string().optional(),
+  pr: z.union([string(), z.number().int().positive()]).optional(),
+  criteria: z.array(z.object({
+    id: criterionIdSchema,
+    text: string(),
+    proven_by: z.array(referenceSchema),
+    status: z.enum(["met", "unproven", "broken", "retired"]),
+    security: z.boolean().optional(),
+    note: z.string().optional(),
+  }).strict()),
+}).strict().superRefine((contract, ctx) => {
+  const seen = new Set();
+  contract.criteria.forEach(({ id }, index) => {
+    if (seen.has(id)) ctx.addIssue({ code: "custom", path: ["criteria", index, "id"], message: `duplicate criterion ${id}` });
+    seen.add(id);
+  });
+});
+
+/** Load one file while retaining its path for grouped CLI output and errors. */
+export function loadContract(file) {
+  let data;
+  try {
+    data = YAML.parse(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new Error(`${file}: ${error.message}`);
+  }
+  const parsed = contractSchema.safeParse(data);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => {
+      const index = issue.path[0] === "criteria" ? issue.path[1] : undefined;
+      const id = index === undefined ? "contract" : data?.criteria?.[index]?.id ?? `criteria[${index}]`;
+      return `${file}: ${id}: ${issue.path.join(".") || "contract"} ${issue.message}`;
+    });
+    throw new Error(issues.join("\n"));
+  }
+  return { file, ...parsed.data };
+}
+
+export function contractDisplayPath(repoDir, file) {
+  return toPosix(path.relative(repoDir, file));
+}
+
+export function loadContracts(repoDir, { onError = error => { throw error; } } = {}) {
+  const directory = path.join(repoDir, "acceptance");
+  let files;
+  try {
+    files = fs.readdirSync(directory);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  return files.filter((file) => file.endsWith(".yml")).sort().flatMap((file) => {
+    try { return [loadContract(path.join(directory, file))]; }
+    catch (error) { onError(error); return []; }
+  });
+}
+
+const fixedName = (name) => name.split("${", 1)[0];
+const escapeRegex = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const failureFor = (ref, detail) => "file" in ref
+  ? { file: ref.file, test: ref.test, detail }
+  : { command: ref.command, detail };
+
+const appliesOn = (ref, platform) => !ref.platforms || ref.platforms.some((value) => value === platform || (value === "posix" && platform !== "win32"));
+
+/** Recompute status from evidence, never from a contract's recorded verdict. */
+export function checkContract(contract, { repoDir, run = spawnSync, platform = process.platform, today = new Date().toISOString().slice(0, 10) }) {
+  // A checker invoked by node:test must start a fresh test runner, not inherit
+  // the parent's child-test context (which disables --test on some Node versions).
+  const env = { ...process.env };
+  delete env.NODE_TEST_CONTEXT;
+  const options = { cwd: repoDir, encoding: "utf8", env, maxBuffer: 16 * 1024 * 1024 };
+  const execute = (command, args, opts) => {
+    try { return run(command, args, opts); }
+    catch (error) { return { status: null, error }; }
+  };
+  const runFailure = (result) => result.error?.message || result.stderr?.trim() || result.stdout?.trim()
+    || `process exited ${result.status ?? result.signal ?? "without a status"}`;
+
+  return contract.criteria.map((criterion) => {
+    const result = { id: criterion.id, text: criterion.text, status: "met", security: criterion.security ?? false, failures: [] };
+    if (criterion.status === "retired") return { ...result, status: "retired" };
+    if (!criterion.proven_by.length) return { ...result, status: "unproven" };
+    const applicable = criterion.proven_by.filter((ref) => appliesOn(ref, platform));
+    const notApplicable = criterion.proven_by.filter((ref) => !appliesOn(ref, platform));
+    if (notApplicable.length) result.notApplicable = notApplicable;
+    if (!applicable.length) return { ...result, status: "unproven", note: `no proof applies on ${platform}` };
+    const manualRefs = applicable.filter((ref) => "manual" in ref);
+    const expired = manualRefs.filter((ref) => ref.expires_days !== undefined
+      && Date.parse(`${today}T00:00:00Z`) > Date.parse(`${ref.date}T00:00:00Z`) + ref.expires_days * 86400000);
+    const currentManual = manualRefs.filter((ref) => !expired.includes(ref));
+    if (currentManual.length) result.manual = currentManual;
+    const nodeRefs = applicable.filter((ref) => "file" in ref);
+    for (const ref of nodeRefs) {
+      try {
+        const source = fs.readFileSync(path.resolve(repoDir, ref.file), "utf8");
+        if (!fixedName(ref.test) || !source.includes(fixedName(ref.test))) {
+          throw new Error("test name is absent from the source");
+        }
+      } catch (error) {
+        result.failures.push(failureFor(ref, `${criterion.id}: ${ref.file}: ${ref.test}: ${error.message}`));
+      }
+    }
+    if (result.failures.length) return { ...result, status: "missing" };
+    if (nodeRefs.length) {
+      // Literal names are exact; template names select the loop's fixed prefix.
+      const pattern = nodeRefs.map((ref) => `^${escapeRegex(fixedName(ref.test))}${ref.test.includes("${") ? "" : "$"}`).join("|");
+      const files = [...new Set(nodeRefs.map((ref) => path.resolve(repoDir, ref.file)))];
+      const execution = execute(process.execPath, ["--test", "--test-reporter=tap", "--test-name-pattern", pattern, ...files], options);
+      // Newer Node versions report the file itself as passing when a filter
+      // matches nothing. Count named, non-skipped test results, not file passes.
+      const passedNames = [...String(execution.stdout ?? "").matchAll(/^\s*ok \d+ - (.+)$/gm)]
+        .map((match) => match[1].trim()).filter((name) => !/ # (?:SKIP|TODO)\b/i.test(name))
+        .map((name) => name.replace(/\\#/g, "#"));
+      if (execution.status !== 0 || execution.error) {
+        const failedNames = [...String(execution.stdout ?? "").matchAll(/^\s*not ok \d+ - (.+)$/gm)]
+          .map((match) => match[1].trim().replace(/\\#/g, "#"));
+        const failedRefs = nodeRefs.filter((ref) => failedNames.some((name) => ref.test.includes("${") ? name.startsWith(fixedName(ref.test)) : name === ref.test));
+        // Startup and runner failures may have no named test result at all.
+        result.failures.push(...(failedRefs.length ? failedRefs : nodeRefs).map((ref) => failureFor(ref, runFailure(execution))));
+      } else {
+        for (const ref of nodeRefs) {
+          const matched = passedNames.some((name) => ref.test.includes("${") ? name.startsWith(fixedName(ref.test)) : name === ref.test);
+          if (!matched) result.failures.push(failureFor(ref, "no tests passed (zero tests ran or all were skipped/todo)"));
+        }
+      }
+    }
+    for (const ref of applicable.filter((ref) => "command" in ref)) {
+      const execution = execute(ref.command, [], { ...options, shell: true, cwd: path.resolve(repoDir, ref.cwd ?? ".") });
+      if (execution.status !== 0 || execution.error) result.failures.push(failureFor(ref, runFailure(execution)));
+    }
+    if (result.failures.length) result.status = "broken";
+    else if (!currentManual.length && !nodeRefs.length && !applicable.some((ref) => "command" in ref)) {
+      result.status = "unproven";
+      const ref = expired[0];
+      result.note = `manual check by ${ref.checked_by} on ${ref.date} expired after ${ref.expires_days} days`;
+    }
+    return result;
+  });
+}

package/lib/admission.mjs

@@ -1,8 +1,11 @@
+import { markBriefTrust, trustValidatorSettings } from "./trust-judgment.mjs";
+import { criteriaProblems } from "./acceptance-fill.mjs";
+import { registerJobsRoot, registeredWorktree, registerJobWorktree } from "./worktree-pointer.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { executionMode } from "./execution.mjs";
 import { jobLabel, jobElapsedSeconds } from "./job-format.mjs";
-import { continuationProblem } from "./continue-from.mjs";
+import { continuationStakes, continuationProblem } from "./continue-from.mjs";
 import { loadConfig } from "./config.mjs";
 import { maxJobs } from "./limits.mjs";
 import { checkBrief, assessAdmission, describeBudgets } from "./budget.mjs";
@@ -67,6 +70,7 @@ export function refusalText(problems, snapshot) {
 }
 
 export function createJobRuntime(deps) {
+  registerJobsRoot(deps.jobsRoot);
   const { projectDir, stateRoot, jobsRoot, runsRoot, leasesRoot, slotsRoot, run, currentMaxWorkers, slug, agentsConfig, modelCatalogReady, budgetsForJob, resolveSubscriptionSelection, executeJob, subscriptionJobFieldProblems, repoPolicy, jobArgs } = deps;
 
   // Staggers concurrent job starts by `slot * staggerMs` before each runner
@@ -203,6 +207,9 @@ export function createJobRuntime(deps) {
     if (jobs.some(j => j.mode !== "verify")) await deps.budgetState.refresh();
     if (jobs.some((j) => j.mode !== "verify" && jobLane(j) === "remote")) await modelCatalogReady();
     const problems = [];
+    jobs.forEach((j, i) => {
+      for (const problem of criteriaProblems(j.criteria, projectDir, j.mode)) problems.push(`${jobs.length > 1 ? `job ${i + 1}: ` : ""}${problem}`);
+    });
     const notARepo = (deps.projectDirProblem ?? projectDirProblem)(projectDir);
     if (notARepo) problems.push(notARepo);
     // Every job needs its sandbox; the server wires the Podman check (tests don't).
@@ -256,6 +263,14 @@ export function createJobRuntime(deps) {
         } catch (error) { problems.push(error.message); }
         return;
       }
+      // A misspelled profile used to be found only after the worker ran, so the
+      // whole run was spent and nothing could be committed. Refuse it here.
+      if (j.verification && (j.mode ?? "implement") === "implement") {
+        try {
+          const profiles = Object.keys(loadConfig(projectDir)?.config?.verification ?? {});
+          if (!profiles.includes(j.verification)) problems.push(`${jobs.length > 1 ? `job ${i + 1}: ` : ""}verification profile '${j.verification}' is not defined in .nomarmy.yml; available profiles: ${profiles.join(", ") || "(none)"}`);
+        } catch (error) { problems.push(error.message); }
+      }
       const jobBudgets = budgetsForJob(j);
       for (const p of checkBrief(j, jobBudgets)) problems.push(jobs.length > 1 ? `job ${i + 1}: ${p}` : p);
     });
@@ -275,9 +290,10 @@ export function createJobRuntime(deps) {
     // and belong to this repo; see lib/continue-from.mjs.
     jobs.forEach((j, i) => {
       if (!j.continue_from) return;
-      const { problem } = continuationProblem({ continueFrom: j.continue_from, mode: j.mode, baseRef: j.base_ref ?? null, jobsRoot, projectDir,
+      const { problem, record } = continuationProblem({ continueFrom: j.continue_from, mode: j.mode, baseRef: j.base_ref ?? null, jobsRoot, projectDir,
         isRunning: (id) => activeJobs.get(id)?.settled === false });
       if (problem) problems.push(`${jobs.length > 1 ? `job ${i + 1}: ` : ""}${problem}`);
+      else j.stakes = continuationStakes(record.stakes, j.stakes);
     });
     jobs.forEach((j, i) => {
       if (j.verify_regression && !j.verification) {
@@ -395,6 +411,15 @@ export function createJobRuntime(deps) {
         problems.push(`not admitted (capacity): ${runningRemote} remote job(s) (api or subscription agents) already running, the limit of ${remoteCeiling} at once (raise it with \`nomarmy config max-jobs <n>\`)`);
       }
     }
+    // Model marking runs after refusal checks so it never rejects admission.
+    const settings = trustValidatorSettings(deps);
+    // Only the operator checkout can opt out, never job or worktree config.
+    const judgment = !problems.length ? loadConfig(projectDir)?.config?.trust?.judgment : undefined;
+    if (!problems.length && (judgment === false || settings.jev || (settings.judge && !settings.judge.problem))) {
+      const notes = await Promise.all(jobs.map((job) => markBriefTrust(job, { ...settings, judgment, stateRoot,
+        askJev: deps.askTrustJev, askJudge: deps.askTrustJudge })));
+      admission.reasons.push(...notes.flat());
+    }
     for (const note of usageNotes) admission.reasons.push(note);
     return { problems, admission };
   }
@@ -472,6 +497,11 @@ export function createJobRuntime(deps) {
     try {
       const worktree = path.join(jobDir, "worktree");
       if (fs.existsSync(worktree)) {
+        if (!registeredWorktree(worktree)) {
+          const metadata = readJson(path.join(jobDir, "metadata.json"));
+          const record = metadata?.worktreePointerBefore ? metadata : readJson(path.join(jobDir, "status.json"));
+          registerJobWorktree(record, { worktree, repoRoot: projectDir });
+        }
         // --untracked-files=normal, not all: "all" descends into every
         // untracked directory (a virtualenv, a cache) a job creates. Bounded:
         // a live progress read must never hold anything up.
@@ -482,7 +512,7 @@ export function createJobRuntime(deps) {
         // filesChangedLive: 1 anyway.
         out.filesChangedLive = parseStatusPorcelainZ(statusOut).map(e => e.file).filter(f => !isRuntimeJunk(f)).length;
       }
-    } catch { /* worktree not ready yet, or mutated mid-read; omit */ }
+    } catch (error) { if (error.message.includes("worktree Git pointer integrity failure")) out.worktreeIntegrityError = error.message; }
     try {
       const stateDir = path.join(jobDir, "runtime", "state");
       const transcript = await readOpenClawTranscriptTail(stateDir, { limit: 6 });

package/lib/army.mjs

@@ -1,3 +1,4 @@
+import { spawnHostGitSync } from "./worktree-pointer.mjs";
 // nomArmy's army: who the General (the coordinator session) calls for what.
 //
 // The General is the Claude Code / Codex session itself. Its charter is
@@ -23,7 +24,6 @@
 // endpoint, an owner or a provider, and never will. A hostile
 // .nomarmy.yml can at worst route a job to one of your own agents.
 
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -101,7 +101,7 @@ export function privateConfigProblem(filePath, { platform = process.platform, ui
 
 /** True when git tracks this file (committed or force-added past .gitignore). No git or no repo -> false. */
 export function isTrackedByGit(filePath) {
-  const result = spawnSync("git", ["ls-files", "--error-unmatch", "--", path.basename(filePath)], { cwd: path.dirname(filePath), stdio: "ignore" });
+  const result = spawnHostGitSync(path.dirname(filePath), ["ls-files", "--error-unmatch", "--", path.basename(filePath)], { cwd: path.dirname(filePath), stdio: "ignore" });
   return result.status === 0;
 }
 

package/lib/codex-link.mjs

@@ -4,13 +4,17 @@ import { parseOpenclawAuthProfiles } from "./health.mjs";
 import { CODEX_IMPORT_ARGS, CODEX_IMPORT_RECOVERY, emailOpenaiProfiles, usableCodexImport } from "./openclaw-runtime-health.mjs";
 
 // Never relay migration output: --include-secrets may expose credential data.
-export async function linkCodex({ run, command = "openclaw", isTTY = false, removeEmailProfiles = false, confirm = async () => false, print = () => {}, codexDir = path.join(os.homedir(), ".codex"), now = Date.now() }) {
+export async function linkCodex({ run, command = "openclaw", isTTY = false, importLogin = false, removeEmailProfiles = false, confirm = async () => false, print = () => {}, codexDir = path.join(os.homedir(), ".codex"), now = Date.now() }) {
   const read = async () => {
     const result = await run(command, ["models", "auth", "list", "--json"]);
     return result.ok ? parseOpenclawAuthProfiles(result.stdout) : null;
   };
   const profiles = await read();
   if (!profiles) { print("Cannot inspect OpenClaw auth profiles; nothing imported."); return false; }
+  if (!importLogin && !(isTTY && await confirm("Import your Codex login into OpenClaw? This copies the ChatGPT credential Codex stores into OpenClaw's auth store", { defaultYes: true }))) {
+    print("Nothing imported; use --link-openclaw to authorize the Codex login import non-interactively.");
+    return false;
+  }
   const emails = emailOpenaiProfiles(profiles);
   if (emails.length) {
     print(`Email-keyed profiles will capture the Codex import: ${emails.map((p) => p.id).join(", ")}.`);
@@ -32,6 +36,7 @@ export async function linkCodex({ run, command = "openclaw", isTTY = false, remo
     print("Sign-in has no usable auth profile: expected an unexpired openai:account- profile labeled (Codex import).");
     return false;
   }
+  print("Imported the ChatGPT credential stored by Codex into OpenClaw's auth store.");
   print("Confirmed an unexpired openai:account- (Codex import) profile.");
   return true;
 }

package/lib/connect.mjs

@@ -306,6 +306,8 @@ export function includeInGit(projectDir, relPaths, run = defaultRun) {
   return removed.map((l) => l.trim());
 }
 
+export const PROJECT_REGISTRATION_WARNING = "Warning: a project MCP registration is executable configuration committed to the repository. Other developers run its command when they open this repo. Review it before committing.";
+
 function repoScoped(scope, projectDir) {
   if (!SCOPES.includes(scope)) throw new Error(`unknown scope "${scope}"; use one of ${SCOPES.join(", ")}`);
   if (scope !== "user" && !projectDir) throw new Error(`--scope ${scope} registers nomArmy for one repository; run it inside that repository`);
@@ -353,7 +355,8 @@ export function derivePoolAuthEnvPlaceholders(configDir = globalConfigDir()) {
 /**
  * @param {{ nomarmyRoot: string, installDir?: string, run?: Function, extraEnv?: Record<string,string>, configDir?: string }} input
  */
-export function connectClaude({ nomarmyRoot, installDir = defaultInstallDir(), run = defaultRun, extraEnv = {}, configDir = globalConfigDir(), commandsDir = defaultCommandDirs().claude, settingsPath = defaultClaudeSettingsPath(), scope = "user", projectDir = null }) {
+export function connectClaude({ nomarmyRoot, installDir = defaultInstallDir(), run = defaultRun, extraEnv = {}, configDir = globalConfigDir(), commandsDir = defaultCommandDirs().claude, settingsPath = defaultClaudeSettingsPath(), scope = "user", projectDir = null, warn = console.warn }) {
+  if (scope === "project") warn(PROJECT_REGISTRATION_WARNING);
   if (repoScoped(scope, projectDir)) return connectClaudeToRepo({ nomarmyRoot, installDir, run, extraEnv, configDir, scope, projectDir });
   installMcpCopy({ nomarmyRoot, installDir, run });
   const commands = installPlaybooks({ nomarmyRoot, target: "claude", dir: commandsDir });
@@ -553,7 +556,8 @@ export function readCursorConfig(configPath) {
 /**
  * @param {{ nomarmyRoot: string, installDir?: string, configPath?: string }} input
  */
-export function connectCursor({ nomarmyRoot, installDir = defaultInstallDir(), configPath = defaultCursorConfigPath(), run = defaultRun, configDir = globalConfigDir(), commandsDir = defaultCommandDirs().cursor, scope = "user", projectDir = null }) {
+export function connectCursor({ nomarmyRoot, installDir = defaultInstallDir(), configPath = defaultCursorConfigPath(), run = defaultRun, configDir = globalConfigDir(), commandsDir = defaultCommandDirs().cursor, scope = "user", projectDir = null, warn = console.warn }) {
+  if (scope === "project") warn(PROJECT_REGISTRATION_WARNING);
   // Cursor reads a project's own .cursor/mcp.json beside the user one. local
   // keeps it out of git; project commits it, with the portable command.
   if (repoScoped(scope, projectDir)) {

package/lib/continue-from.mjs

@@ -13,6 +13,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isRuntimeJunk } from "./git-record.mjs";
+import { registerWorktreePointer, prepareHostGit } from "./worktree-pointer.mjs";
+import { removeWorktreeEntry } from "./worktree-write.mjs";
 
 const JOB_ID_RE = /^[A-Za-z0-9._-]{1,120}$/;
 
@@ -43,6 +45,11 @@ export function continuationProblem({ continueFrom, mode = "implement", baseRef
   return { problem: null, record: { ...record, worktree } };
 }
 
+/** A continuation may raise stakes, never lower the retained work's stakes. */
+export function continuationStakes(retained, brief) {
+  return retained === "high" || brief === "high" ? "high" : brief ?? retained ?? null;
+}
+
 /** The retained job's base commit, however its record spells it. */
 export function continuationBase(record) {
   return record.git?.baseSha ?? record.gitBeforeCoordinatorCommit?.baseSha ?? record.baseSha;
@@ -56,17 +63,26 @@ export function continuationBase(record) {
  * worktree can check the commit out.
  * @returns {Promise<{ commit: string, files: string[] }>}
  */
-export async function snapshotRetainedWork({ worktree, baseSha, jobId, git }) {
+function guardedGit(git, { worktree, repoRoot, expectedPointer }) {
+  return async (args, opts = {}) => {
+    registerWorktreePointer(worktree, { expectedBytes: expectedPointer, repoRoot });
+    const prep = prepareHostGit(worktree, args);
+    return git([...prep.argsPrefix, ...args], { ...opts, env: prep.env(opts.env ?? process.env) });
+  };
+}
+
+export async function snapshotRetainedWork({ worktree, baseSha, jobId, git, repoRoot, expectedPointer }) {
+  const hostGit = guardedGit(git, { worktree, repoRoot, expectedPointer });
   const indexFile = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "nomarmy-continue-")), "index");
   const env = { ...process.env, GIT_INDEX_FILE: indexFile };
   try {
-    await git(["read-tree", baseSha], { cwd: worktree, env });
-    await git(["add", "-A"], { cwd: worktree, env });
-    const staged = (await git(["diff", "--cached", "--name-only", "-z", baseSha], { cwd: worktree, env })).split("\0").filter(Boolean);
+    await hostGit(["read-tree", baseSha], { cwd: worktree, env });
+    await hostGit(["add", "-A"], { cwd: worktree, env });
+    const staged = (await hostGit(["diff", "--cached", "--name-only", "-z", baseSha], { cwd: worktree, env })).split("\0").filter(Boolean);
     const junk = staged.filter(isRuntimeJunk);
-    for (const file of junk) await git(["rm", "--cached", "-q", "-r", "--ignore-unmatch", "--", file], { cwd: worktree, env });
-    const tree = (await git(["write-tree"], { cwd: worktree, env })).trim();
-    const commit = (await git(["commit-tree", tree, "-p", baseSha, "-m", `nomArmy: unfinished work of ${jobId}`], { cwd: worktree, env })).trim();
+    for (const file of junk) await hostGit(["rm", "--cached", "-q", "-r", "--ignore-unmatch", "--", file], { cwd: worktree, env });
+    const tree = (await hostGit(["write-tree"], { cwd: worktree, env })).trim();
+    const commit = (await hostGit(["commit-tree", tree, "-p", baseSha, "-m", `nomArmy: unfinished work of ${jobId}`], { cwd: worktree, env })).trim();
     return { commit, files: staged.filter((f) => !junk.includes(f)) };
   } finally {
     fs.rmSync(path.dirname(indexFile), { recursive: true, force: true });
@@ -78,11 +94,12 @@ export async function snapshotRetainedWork({ worktree, baseSha, jobId, git }) {
  * changes: the files from the snapshot, deletions removed, index back at the
  * base. The new job's git record then counts them as its own diff.
  */
-export async function applyRetainedWork({ worktree, baseSha, commit, git }) {
-  await git(["checkout", commit, "--", "."], { cwd: worktree });
-  const deleted = (await git(["diff", "--name-only", "-z", "--diff-filter=D", baseSha, commit], { cwd: worktree })).split("\0").filter(Boolean);
-  for (const file of deleted) fs.rmSync(path.join(worktree, file), { force: true });
-  await git(["reset", "-q"], { cwd: worktree });
+export async function applyRetainedWork({ worktree, baseSha, commit, git, repoRoot, expectedPointer }) {
+  const hostGit = guardedGit(git, { worktree, repoRoot, expectedPointer });
+  await hostGit(["checkout", commit, "--", "."], { cwd: worktree });
+  const deleted = (await hostGit(["diff", "--name-only", "-z", "--diff-filter=D", baseSha, commit], { cwd: worktree })).split("\0").filter(Boolean);
+  for (const file of deleted) removeWorktreeEntry(worktree, path.join(worktree, file));
+  await hostGit(["reset", "-q"], { cwd: worktree });
 }
 
 /** The brief's note, so the worker builds on the work instead of redoing it. */