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

package/lib/coordinator-instructions.mjs

@@ -16,10 +16,14 @@ Before dispatching:
 - To run tests without changing anything, use mode: verify; it costs no model usage.
 - Mark an implement job stakes: high when a mistake would be costly (security, access control, personal or tenant data, data loss, money, irreversible changes), however small it is. It then needs a verification profile, keeps the revert check, and needs an independent review before you accept it: a scout on another vendor with reviews: <job id>.
 - Brief outcomes, not edits: a task, explicit acceptance criteria, and the tests that prove it. Put facts you've already resolved in evidence.
+- At feature planning, write acceptance/<feature>.yml from durable outcome promises, not job hygiene. Assign stable criterion IDs in each job brief before parallel dispatch and pass them as criteria; jobs must not pick the next free ID. After integration, preview nomarmy acceptance fill <run-id> --dry-run, prune unrelated proposed mappings, fill for real, and commit the contract with the feature. A CONTRACT BROKEN: issue means the change is wrong or the contract must intentionally change in the same pull request.
 - Prefer local_worker_start for anything longer than a few minutes. Right after, if you can run a background command, run \`nomarmy jobs --wait <job_id>\` in the background so you're told the moment it finishes and can tell the operator (for several jobs, \`nomarmy jobs --wait <id> <id> ...\`; for a whole run, \`nomarmy jobs --events --until-done --run <run-id>\`); otherwise poll local_worker_status with wait_seconds. To read a finished job, use local_worker_status with report: true (the report, a scout's cited findings, the outcome, issues and commit); full: true is the whole record and rarely needed. Review scouts (reviews set, or a review-phase role) default to 20 minutes, other jobs to 10; pass timeout_seconds for more. Never use unscoped \`--until-done\` when other sessions may have jobs. Never run the plain \`nomarmy jobs --events\` stream as a background command: it only reports when it exits, so you'd never hear; it's for a monitor that reads each line. For a whole feature, use /feature (run_start keeps a run's jobs, spend and hours bounded).
 
 Trust boundary:
 - A worker's four-line report is a claim; nomArmy's verified git record and independent verification are the evidence. A job isn't complete if its report is missing or malformed, its STATUS is partial or blocked, STATUS done lacks VERIFICATION pass, or its changes aren't committed by nomArmy.
+- If a repository has no accepted trust map, suggest nomarmy trust map once; dispatch its scout brief and use nomarmy trust review for operator ratification.
+- A job with trust.level: review or human needs an independent review on another vendor before acceptance, like stakes: high.
+- A job with trust.level: human is a hard stop before integration: show every trust reason to the operator and wait for explicit approval. Never decide this gate alone. After the operator decides, record nomarmy trust ack <job> --accept|--reject --reason ...; rejection never permits integration.
 - Read the diff of anything material before integrating it. nomArmy commits on the worker's branch and never merges into yours: integration, conflicts and pushes are yours.
 - A job on the wrong track can be stopped with local_worker_stop; it keeps its worktree. To finish a job that came back partial, blocked, failing verification or stopped, dispatch the correction with continue_from: <that job id> (a cheaper model is fine). The new job starts with its unfinished work in place and verifies the whole. Don't fix and commit a worker's files yourself: that lands them unverified. If you must, commit them on a branch, run mode: verify on it before building on it, and say so in your report.
 - Failed and incomplete worktrees are kept for review; clean up with local_worker_cleanup or local_worker_sweep once you've decided.

package/lib/diff-checks.mjs

@@ -41,10 +41,16 @@ export function isCiConfigPath(file) {
     || normalized === "bitbucket-pipelines.yml";
 }
 
+export function isAcceptanceContractPath(file) {
+  const normalized = String(file ?? "").replace(/\\/g, "/").replace(/^\.\//, "");
+  return /^acceptance\/[^/]+\.ya?ml$/.test(normalized);
+}
+
 export function planRegressionProductionFiles(files) {
   // Local repository tests cannot exercise CI services, so reverting CI
-  // configuration cannot provide useful regression evidence.
-  return (files ?? []).filter((file) => !isDocumentationPath(file) && !isCiConfigPath(file));
+  // configuration cannot provide useful regression evidence. Acceptance
+  // contracts are checked directly against their proofs instead.
+  return (files ?? []).filter((file) => !isDocumentationPath(file) && !isCiConfigPath(file) && !isAcceptanceContractPath(file));
 }
 
 export function isTestPath(file) {
@@ -266,7 +272,7 @@ function meaningfulTokens(name) {
 }
 const TEST_NAME_PATTERN = /^test[_A-Za-z]/i;
 const MIN_CLAIM_OVERLAP = 2; // fewer shared, meaningful words is not a specific-enough claim to check
-const escRegex = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+export const escRegex = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 /**
  * @param {{ cwd: string, productionFiles: string[], testFiles: string[], gitDiffFn: (file: string) => Promise<string>, outlineFn: Function, readFileFn: (cwd: string, file: string) => string }} input

package/lib/doctor.mjs

@@ -1,3 +1,4 @@
+import { prepareHostGit } from "./worktree-pointer.mjs";
 // lib/doctor.mjs
 // Pure logic for the `nomarmy doctor` command.
 // Side effects (probing PATH, spawning podman, hitting the worker endpoint)
@@ -486,7 +487,8 @@ async function probeGitLongPaths(gitPath) {
     let out = "";
     let child;
     try {
-      child = spawn(gitPath, ["config", "--get", "core.longpaths"], { stdio: ["ignore", "pipe", "ignore"] });
+      const prep = prepareHostGit(process.cwd());
+      child = spawn(gitPath, [...(prep?.argsPrefix ?? []), "config", "--get", "core.longpaths"], { env: prep ? prep.env() : process.env, stdio: ["ignore", "pipe", "ignore"] });
     } catch { return resolve(null); }
     const timer = setTimeout(() => { child.kill(); resolve(null); }, 3000);
     child.stdout.on("data", (d) => { out += d.toString(); });

package/lib/execute.mjs

@@ -1,3 +1,7 @@
+import { recordReviewEvidence } from "./trust-learning.mjs";
+import { checkJobContracts, changedContractWeakening, touchesAcceptance } from "./acceptance-impact.mjs";
+import { jobAcceptanceProposals } from "./acceptance-fill.mjs";
+import { readWorktreeFile } from "./worktree-write.mjs";
 import { writeStatus, shouldRetryTransientAbort, shouldAttemptScoutRecovery, readStopRequest } from "./openclaw-run.mjs";
 import fs from "node:fs";
 import path from "node:path";
@@ -5,16 +9,22 @@ import { fileURLToPath } from "node:url";
 import { vmRestartIssue } from "./podman-health.mjs";
 import { measureReads } from "./job-budgets.mjs";
 import { coordinatorCommitMessage, worktreePointerState } from "./git-record.mjs";
+import { assertWorktreePointer, assertRegisteredWorktree, registerJobWorktree, registerJobsRoot, sealWorktree } from "./worktree-pointer.mjs";
 import { parseScoutReport, verifyCitations, resolveScoutOutcome, renderScoutReport, isScoutReportUnusable, scoutReportRecoveryPrompt } from "./scout.mjs";
 import { parseDecomposeReport, buildDecomposeFindings, resolveDecomposeOutcome, checkDecompositionOverlap, renderDecomposeReport } from "./decompose.mjs";
 import { deriveTimeBudget } from "./budget.mjs";
-import { continuationProblem, continuationBase, snapshotRetainedWork, applyRetainedWork, continuationNote } from "./continue-from.mjs";
+import { continuationStakes, continuationProblem, continuationBase, snapshotRetainedWork, applyRetainedWork, continuationNote } from "./continue-from.mjs";
 import { checkScoutCitations, checkReportClaims } from "./jev-checks.mjs";
 import { runJudge } from "./judge.mjs";
 import { pickMutants, runMutants, describeSurvivors } from "./mutation.mjs";
 import { estimateDisplacement, readOpenClawTranscript } from "./transcript.mjs";
 import { outlineFile, findReferences } from "./repo-query.mjs";
 import { loadConfig } from "./config.mjs";
+import { loadTrustMap } from "./trust-map.mjs";
+import { cachedTrustReach } from "./trust-reach.mjs";
+import { snapshotTrustFiles } from "./trust-files.mjs";
+import { evaluateDiffTrust, trustValidatorSettings } from "./trust-judgment.mjs";
+import { evaluateTrust, codeownersPaths, readTrustWorktreeFile, UNCHECKABLE_TRUST_FILE } from "./trust.mjs";
 import { linkNodePackages, nodeModulesState, repairHostInstalls } from "./sandbox-images.mjs";
 import { detectTestSabotage, addedLinesOf, loadDependencyNames } from "./sabotage.mjs";
 import { describeRecoveryChanges, reportRecoveryPrompt } from "./worker-prompt.mjs";
@@ -33,6 +43,7 @@ export const JOB_PHASES = Object.freeze(["starting", "worktree", "worker", "veri
 export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
 export function createExecutor(deps) {
+  registerJobsRoot(deps.jobsRoot);
   const { VERSION, projectDir, jobsRoot, run, git, gitRaw,
     collectGitRecord, createCoordinatorCommit, ensureJobsRoot, slug, assertRepo,
     resolveBase, workerModelThinkingSupported, budgetState, execution, buildMetrics,
@@ -41,8 +52,24 @@ export function createExecutor(deps) {
     runRegressionCheck, repoPolicy } = deps;
   // Optional Jev checks (lib/validators.mjs): the server wires the settings; without them (tests), none run.
   const jevSettingsFor = (check) => { try { const s = deps.jevSettings?.(); return s?.checks?.includes(check) ? s : null; } catch { return null; } };
+  // Seal a worktree nomArmy just created. A mocked worktree add (tests) may
+  // not plant a .git file; production git always does, and that is what we record.
+  function recordCreatedWorktree(worktree) {
+    const dotGit = path.join(worktree, ".git");
+    let st;
+    try { st = fs.lstatSync(dotGit); }
+    catch { return worktreePointerState(worktree); }
+    if (st.isSymbolicLink() || !st.isFile()) throw new Error(`worktree Git pointer integrity failure: ${st.isSymbolicLink() ? "symlink" : "not a regular file"} at creation`);
+    const sealed = sealWorktree(worktree, projectDir);
+    writeStatus(path.dirname(worktree), { worktree, projectDir, worktreePointerBefore: sealed });
+    return sealed;
+  }
+  function requireWorktreePointer(worktree, sealed) {
+    if (!sealed?.bytes) throw new Error("worktree Git pointer integrity failure: no recorded pointer bytes");
+    assertWorktreePointer({ worktree, expectedBytes: sealed.bytes, repoRoot: projectDir });
+  }
 
-  async function executeJob({ task, acceptance, verification, mode = "implement", baseRef, timeoutSeconds = 600, profile = "coder", reasoning = "high", pool = null, subscriptionWorker = null, onBehalfOf = null, model = null, reportSize = null, workerId, evidence = null, verifyRegression = false, commitSubject = null, refactor = false, continueFrom = null, stakes = null, reviews = null, jobId: presetJobId = null }) {
+  async function executeJob({ task, acceptance, criteria, verification, mode = "implement", baseRef, timeoutSeconds = 600, profile = "coder", reasoning = "high", pool = null, subscriptionWorker = null, onBehalfOf = null, model = null, reportSize = null, workerId, evidence = null, verifyRegression = false, commitSubject = null, refactor = false, continueFrom = null, stakes = null, trustAdmission = null, reviews = null, jobId: presetJobId = null }) {
     await assertRepo();
     // A continuation starts from the retained job's own base commit.
     let continuation = null;
@@ -51,6 +78,7 @@ export function createExecutor(deps) {
       if (checked.problem) throw new Error(checked.problem);
       continuation = { jobId: continueFrom, record: checked.record };
       baseRef = continuationBase(checked.record);
+      stakes = continuationStakes(checked.record.stakes, stakes);
     }
     ensureJobsRoot();
     // Fire-and-forget: sweeps whatever this or any other nomArmy install left
@@ -61,14 +89,14 @@ export function createExecutor(deps) {
     fs.mkdirSync(runtimeDir, { recursive: true });
     const progress = (phase, extra = {}) => writeStatus(jobDir, {
       jobId, workerId: workerId || jobId, mode, phase, state: phase === "finished" ? "finished" : "running",
-      serverPid: process.pid, baseSha: base.sha, timeoutSeconds, ...extra
+      projectDir, ...(stakes ? { stakes } : {}), serverPid: process.pid, baseSha: base.sha, timeoutSeconds, ...extra
     });
     progress("starting", { startedAt: new Date().toISOString(), agent: mode === "verify" ? null : pool ?? subscriptionWorker ?? "local", model: model ?? null });
     const common = { task, acceptance, base, jobId, jobDir, runtimeDir, timeoutSeconds, profile, reasoning, pool, subscriptionWorker, onBehalfOf, model, reportSize, workerId, progress, jobStartedMs };
     if (mode === "verify") return executeVerify({ ...common, verification });
     if (mode === "scout") return executeScout({ ...common, reviews });
     if (mode === "decompose") return executeDecompose(common);
-    return executeImplement({ ...common, verification, evidence, verifyRegression, commitSubject, refactor, continuation, stakes });
+    return executeImplement({ ...common, criteria, verification, evidence, verifyRegression, commitSubject, refactor, continuation, stakes, trustAdmission });
   }
 
   async function executeVerify({ task, verification: profile, base, jobId, jobDir, workerId, progress, jobStartedMs }) {
@@ -77,6 +105,7 @@ export function createExecutor(deps) {
     try {
       progress("worktree");
       await run("git", ["worktree", "add", "--detach", worktree, base.sha], { cwd: projectDir });
+      recordCreatedWorktree(worktree);
       record = await collectGitRecord({ cwd: worktree, baseSha: base.sha, baseRef: base.ref, branch: null, jobId });
       progress("verification");
       verification = await runIndependentVerification({ profile, cwd: worktree, jobId, baseSha: base.sha, branch: null, mode: "verify", record, logFile: path.join(jobDir, "verification.log") });
@@ -84,7 +113,7 @@ export function createExecutor(deps) {
       error = err.message;
       verification = normalizeVerification({ status: "not_run", reason: error }, profile);
     } finally {
-      try { await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }); }
+      try { assertRegisteredWorktree(worktree); await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }); }
       catch (err) { error = [error, err.message].filter(Boolean).join("\n"); }
     }
     const retained = fs.existsSync(worktree);
@@ -103,21 +132,33 @@ export function createExecutor(deps) {
     return { ok: outcome === OUTCOMES.VERIFIED, manifest, jobDir, report: "" };
   }
 
-  async function executeImplement({ task, acceptance, verification, base, jobId, jobDir, runtimeDir, timeoutSeconds, profile, reasoning, pool = null, subscriptionWorker = null, onBehalfOf = null, model = null, reportSize = null, workerId, evidence, verifyRegression = false, commitSubject = null, refactor = false, continuation = null, stakes = null, progress, jobStartedMs }) {
+  async function executeImplement({ task, acceptance, criteria, verification, base, jobId, jobDir, runtimeDir, timeoutSeconds, profile, reasoning, pool = null, subscriptionWorker = null, onBehalfOf = null, model = null, reportSize = null, workerId, evidence, verifyRegression = false, commitSubject = null, refactor = false, continuation = null, stakes = null, trustAdmission = null, progress, jobStartedMs }) {
     const mode = "implement";
     let branch = `agent/${jobId}`, worktree = path.join(jobDir, "worktree");
     try {
       progress("worktree");
       await run("git", ["worktree", "add", "-b", branch, worktree, base.sha], { cwd: projectDir });
       const cwd = worktree;
+      const beforePointer = recordCreatedWorktree(worktree), startedAt = new Date().toISOString();
+      // Snapshot the operator's floor before dispatch. Never read the worker's
+      // config to decide which trust rules or owners govern this job.
+      const trustConfig = loadConfig(projectDir)?.config?.trust;
+      const trustedOwners = trustConfig?.codeowners ? codeownersPaths(projectDir) : [];
+      const trustedFiles = snapshotTrustFiles(cwd);
+      const trustedMap = loadTrustMap(projectDir);
+      const trustedReach = trustedMap.length ? cachedTrustReach({ baseDir: cwd, baseCommit: base.sha,
+        stateDir: path.join(jobsRoot, ".."), entries: trustedMap }) : null;
       // continue_from: lay the retained job's unfinished work into this
       // worktree as uncommitted changes, so this job's diff (and so its
       // verification and revert check) covers that work too.
       let continuedFrom = null;
       if (continuation) {
+        const retainedBytes = continuation.record.worktreePointerBefore?.bytes;
+        if (!retainedBytes) throw new Error("worktree Git pointer integrity failure: continuation has no recorded pointer bytes");
+        registerJobWorktree(continuation.record, { repoRoot: projectDir });
         const git = async (args, opts = {}) => (await run("git", args, { trim: false, ...opts })).stdout;
-        const snapshot = await snapshotRetainedWork({ worktree: continuation.record.worktree, baseSha: base.sha, jobId: continuation.jobId, git });
-        await applyRetainedWork({ worktree, baseSha: base.sha, commit: snapshot.commit, git });
+        const snapshot = await snapshotRetainedWork({ worktree: continuation.record.worktree, baseSha: base.sha, jobId: continuation.jobId, git, repoRoot: projectDir, expectedPointer: retainedBytes });
+        await applyRetainedWork({ worktree, baseSha: base.sha, commit: snapshot.commit, git, repoRoot: projectDir, expectedPointer: beforePointer.bytes });
         continuedFrom = { jobId: continuation.jobId, snapshot: snapshot.commit, files: snapshot.files };
         evidence = [continuationNote({ continueFrom: continuation.jobId, record: continuation.record, files: snapshot.files }), evidence].filter(Boolean).join("\n\n");
         fs.appendFileSync(path.join(jobDir, "coordinator.log"), `${new Date().toISOString()} continuing job ${continuation.jobId}: ${snapshot.files.length} file(s) of its unfinished work carried into this worktree (snapshot ${snapshot.commit})\n`);
@@ -127,7 +168,6 @@ export function createExecutor(deps) {
       try { linkNodePackages(worktree, nodeConfig); } catch { /* verification reports what's missing */ }
       let nodeModulesBefore = {};
       try { nodeModulesBefore = nodeModulesState(worktree, nodeConfig); } catch { /* no Node packages */ }
-      const beforePointer = worktreePointerState(worktree), startedAt = new Date().toISOString();
 
       // The caller's timeout is split up front into a work phase and a
       // reserved report phase (see deriveTimeBudget) rather than letting the
@@ -257,16 +297,16 @@ export function createExecutor(deps) {
         }
       }
 
+      requireWorktreePointer(worktree, beforePointer);
       const afterPointer = worktreePointerState(worktree);
-      if (!afterPointer.exists || afterPointer.kind !== "file") throw new Error(`worktree Git pointer integrity failure after worker: ${JSON.stringify(afterPointer)}`);
       const preCommit = await collectGitRecord({ cwd, baseSha: base.sha, branch, baseRef: base.ref, jobId });
       const repositoryChanged = preCommit.repoStatusFiles.length > 0;
 
       // A worker whose tools ran outside the sandbox can leave a host-built
       // node_modules behind; verification must not run against it.
       let hostInstalls = [];
-      try { hostInstalls = repairHostInstalls(cwd, nodeConfig, nodeModulesBefore); } catch { /* best-effort */ }
-      if (hostInstalls.length) fs.appendFileSync(path.join(jobDir, "coordinator.log"), `${new Date().toISOString()} worker left a real ${hostInstalls.join(", ")} (packages installed outside the sandbox); removed and relinked to the dependency image before verification\n`);
+      try { hostInstalls = repairHostInstalls(cwd, nodeConfig, nodeModulesBefore); } catch (error) { hostInstalls = [`repair refused: ${error.message}`]; }
+      if (hostInstalls.length) fs.appendFileSync(path.join(jobDir, "coordinator.log"), `${new Date().toISOString()} dependency repair findings: ${hostInstalls.join(", ")}; safe paths repaired and unsafe paths retained for review\n`);
 
       progress("verification");
       let independentVerification = normalizeVerification({ status: "not_run", basis: "not-applicable", reason: "no verification runner registered" }, verification ?? null);
@@ -282,11 +322,35 @@ export function createExecutor(deps) {
         independentVerification = await runIndependentVerification({ profile: verification ?? null, cwd, jobId, baseSha: base.sha, branch, mode, record: preCommit, logFile: path.join(jobDir, "verification.log") });
       }
 
+      let changedContracts = { weakened: [], issues: [], files: [] };
+      if (touchesAcceptance(preCommit.nameStatus ?? []) && workerStopReason !== "stopped") {
+        changedContracts = await changedContractWeakening({
+          worktree: cwd, baseSha: base.sha, nameStatus: preCommit.nameStatus, gitRaw,
+        });
+        const contractFiles = changedContracts.files;
+        const contractCheck = contractFiles.length ? await runIndependentVerification({
+          profile: "acceptance-contracts", acceptanceFiles: contractFiles,
+          cwd, jobId: `${jobId}-acceptance`, baseSha: base.sha, branch, mode,
+          record: preCommit, logFile: path.join(jobDir, "acceptance-check.log"),
+        }) : { status: changedContracts.issues.length ? "fail" : "pass", basis: "not-applicable",
+          reason: "no changed contracts in the new contract set" };
+        // Missing infrastructure is not permission to accept unchecked contracts.
+        // Keep both verdicts and the dedicated log in the job record.
+        independentVerification = {
+          ...independentVerification,
+          status: contractCheck.status !== "pass" ? "fail"
+            : !verification && !planRegressionProductionFiles(preCommit.testChanges.production_files_changed).length
+              && independentVerification.status === "not_run" ? "pass" : independentVerification.status,
+          ...(contractCheck.status !== "pass" ? { reason: "changed acceptance contracts did not pass verification" } : {}),
+          contractCheck: { ...contractCheck, files: contractFiles, weakened: changedContracts.weakened },
+        };
+      }
+
       // verify_regression: on by default whenever there's a verification
       // profile (resolveVerifyRegression). It doubles verification wall-clock,
       // so it runs only when there's something to re-check: a passing
       // first-pass verification on a diff that touched production code.
-      // Documentation and CI configuration cannot be proven by local tests,
+      // Documentation, CI configuration and acceptance contracts are not code,
       // so neither is reverted or used as a reason to run this check.
       const codeFilesChanged = planRegressionProductionFiles(preCommit.testChanges.production_files_changed);
       let regressionCheck = null, regressionCheckFatal = false, regressionCheckElapsedMs = null;
@@ -322,13 +386,13 @@ export function createExecutor(deps) {
           for (const file of codeFilesChanged.filter((f) => !deleted.has(f))) {
             const full = path.join(cwd, file);
             let lines;
-            if (untracked.has(file)) { try { lines = fs.readFileSync(full, "utf8").split("\n").map((_, i) => i + 1); } catch { continue; } }
+            if (untracked.has(file)) { try { lines = readWorktreeFile(cwd, full).content.toString("utf8").split("\n").map((_, i) => i + 1); } catch { continue; } }
             else lines = parseAddedLineNumbers(await gitRaw(["diff", "-U0", base.sha, "--", file], cwd));
             if (lines.length) files.push({ path: file, full, lines });
           }
-          const mutants = pickMutants(files, mutationConfig.mutants);
+          const mutants = pickMutants(files, mutationConfig.mutants, cwd);
           let n = 0;
-          mutation = await runMutants({ mutants, deadlineMs: mutationStartedMs + mutationConfig.max_seconds * 1000,
+          mutation = await runMutants({ mutants, root: cwd, deadlineMs: mutationStartedMs + mutationConfig.max_seconds * 1000,
             verify: () => runIndependentVerification({ profile: verification, cwd, jobId: `${jobId}-mutant-${++n}`, baseSha: base.sha, branch, mode, record: preCommit }) });
           mutation.planned = mutants.length;
         } catch (error) {
@@ -338,6 +402,21 @@ export function createExecutor(deps) {
         fs.appendFileSync(path.join(jobDir, "coordinator.log"), `${new Date().toISOString()} mutation testing: ${mutation.killed ?? 0} killed, ${mutation.survived?.length ?? 0} survived, ${mutation.inconclusive ?? 0} inconclusive of ${mutation.tried ?? 0} tried (${Math.round(mutationElapsedMs / 1000)}s)\n`);
       }
 
+      // Operator contracts are authoritative even if the worker edits acceptance/.
+      // Reuse the registered sandbox runner, including its image, policy and budgets.
+      let contractCheck;
+      try {
+        contractCheck = await checkJobContracts({
+          projectDir, worktree: cwd, jobDir, jobId: `${jobId}-contract-impact`,
+          verify: runIndependentVerification,
+          changedFiles: [...new Set([...(preCommit.changedFiles ?? []),
+            ...(preCommit.nameStatus ?? []).flatMap(entry => [entry.path, entry.oldPath].filter(Boolean))])],
+        });
+      } catch (error) {
+        contractCheck = { record: { affected: [], broken: [] }, criteria: [],
+          issues: [`CONTRACT CHECK ERROR: ${error.message}`] };
+      }
+
       // resolveOutcome's own contract only ever sees pass/fail/not_run for
       // regressionCheck -- a restore_failed status is substituted to not_run
       // here so resolveOutcome never needs a fourth value; the hard override
@@ -425,7 +504,7 @@ export function createExecutor(deps) {
           for (const c of (preCommit.nameStatus ?? []).slice(0, 300)) {
             let addedLines = [];
             if (c.status === "A") {
-              try { const text = fs.readFileSync(path.join(cwd, c.path), "utf8"); if (text.length < 2_000_000) addedLines = text.split("\n"); } catch { /* unreadable: status alone still counts */ }
+              try { const text = readTrustWorktreeFile(cwd, c.path).bytes.toString("utf8"); if (text.length < 2_000_000) addedLines = text.split("\n"); } catch { /* unreadable: status alone still counts */ }
             } else if (c.status !== "D") {
               try { addedLines = addedLinesOf(await gitRaw(["diff", "-U0", base.sha, "--", c.path], cwd)); } catch { /* skip this file */ }
             }
@@ -458,7 +537,9 @@ export function createExecutor(deps) {
         } catch { /* best-effort; never blocks a commit on the scan's OWN failure -- the absence of a signal is not evidence of safety, but a hard block on a scanner crash would be a self-inflicted denial of service */ }
       }
       const afterHostInstalls = hostInstalls.length
-        ? { ...afterMislabeledTests, reviewRequired: true, reasons: [...afterMislabeledTests.reasons, `TOOLS OUTSIDE THE SANDBOX: the worker left a real ${hostInstalls.join(", ")}, so packages were installed where the sandbox (no network) couldn't have: its tool calls ran on this machine. nomArmy removed them and verified against the sandbox's own dependencies.`] }
+        ? { ...afterMislabeledTests, reviewRequired: true, reasons: [...afterMislabeledTests.reasons, hostInstalls.some(entry => entry.includes("refused"))
+          ? `UNSAFE DEPENDENCY PATHS: ${hostInstalls.join(", ")}. Unsafe paths were retained without following symlinks; inspect them before accepting the job.`
+          : `TOOLS OUTSIDE THE SANDBOX: the worker left a real ${hostInstalls.join(", ")}, so packages were installed where the sandbox (no network) couldn't have: its tool calls ran on this machine. nomArmy removed them and verified against the sandbox's own dependencies.`] }
         : afterMislabeledTests;
       const afterSecrets = possibleSecrets
         ? { ...afterHostInstalls, reviewRequired: true, commitAllowed: false,
@@ -472,12 +553,13 @@ export function createExecutor(deps) {
       const jevImplement = jevSettingsFor("report-claims");
       const judge = (() => { try { return deps.judgeSettings?.() ?? null; } catch { return null; } })();
       // The whole change, new files included, for whichever validators run.
-      const jobDiff = async () => {
-        let diff = await gitRaw(["diff", base.sha, "--"], cwd);
+      const jobDiff = async (fullContext = false) => {
+        let diff = await gitRaw(["diff", ...(fullContext ? ["--unified=1000000"] : []), base.sha, "--"], cwd);
         for (const entry of (preCommit.nameStatus ?? []).filter((e) => e.untracked)) {
           let text = "";
-          try { text = fs.readFileSync(path.join(cwd, entry.path), "utf8"); } catch { continue; }
-          diff += `\ndiff --git a/${entry.path} b/${entry.path}\nnew file\n--- /dev/null\n+++ b/${entry.path}\n${text.split("\n").map((l) => `+${l}`).join("\n")}\n`;
+          try { text = readTrustWorktreeFile(cwd, entry.path).bytes.toString("utf8"); }
+          catch (error) { if (trustConfig) throw error; continue; }
+          diff += `\ndiff --git a/${entry.path} b/${entry.path}\nnew file\n--- /dev/null\n+++ b/${entry.path}\n@@ -0,0 +1,${text.split("\n").length} @@\n${text.split("\n").map((l) => `+${l}`).join("\n")}\n`;
         }
         return diff;
       };
@@ -496,11 +578,15 @@ export function createExecutor(deps) {
         const modifiedTests = preCommit.testChanges?.existing_tests_modified ?? [];
         let testDiff = "";
         if (modifiedTests.length) { try { testDiff = await gitRaw(["diff", base.sha, "--", ...modifiedTests], cwd); } catch { testDiff = ""; } }
-        judged = await runJudge({ settings: judge, task, acceptance: acceptance ?? [], report: reportValidation, diff: diffText, testDiff, stateRoot: path.join(jobsRoot, "..") });
+        judged = await (deps.runJudge ?? runJudge)({ settings: judge, task, acceptance: acceptance ?? [], contracts: contractCheck.criteria, report: reportValidation, diff: diffText, testDiff, stateRoot: path.join(jobsRoot, "..") });
       }
-      const afterJevOnly = jevClaims?.flag
-        ? { ...afterSecrets, reviewRequired: true, reasons: [...afterSecrets.reasons, `REPORT MAY NOT MATCH THE DIFF (Jev, ${jevClaims.flag.probability.toFixed(2)}): the report says "${String(reportValidation.note ?? "").slice(0, 200)}", and the diff may show otherwise. Read the diff before accepting.`] }
+      const contractIssues = [...contractCheck.issues, ...changedContracts.issues];
+      const afterContracts = contractIssues.length
+        ? { ...afterSecrets, reviewRequired: true, reasons: [...afterSecrets.reasons, ...contractIssues] }
         : afterSecrets;
+      const afterJevOnly = jevClaims?.flag
+        ? { ...afterContracts, reviewRequired: true, reasons: [...afterContracts.reasons, `REPORT MAY NOT MATCH THE DIFF (Jev, ${jevClaims.flag.probability.toFixed(2)}): the report says "${String(reportValidation.note ?? "").slice(0, 200)}", and the diff may show otherwise. Read the diff before accepting.`] }
+        : afterContracts;
       const afterJev = judged?.flags?.length
         ? { ...afterJevOnly, reviewRequired: true, reasons: [...afterJevOnly.reasons, `JUDGE (${judge.agent}/${judge.model}): ${judged.flags.join("; ")}. Read the diff before accepting.`] }
         : afterJevOnly;
@@ -525,18 +611,62 @@ export function createExecutor(deps) {
         : mutation?.status === "survivors"
           ? { ...afterConfig, reviewRequired: true, reasons: [...afterConfig.reasons, describeSurvivors(mutation, verification)] }
           : afterConfig;
-      const afterStakes = stakes === "high" ? { ...afterMutation, reviewRequired: true, reasons: [...afterMutation.reasons, HIGH_STAKES_NOTE] } : afterMutation;
+      let trust = null;
+      {
+        const changedFiles = [...new Set([...(preCommit.changedFiles ?? []),
+          ...(preCommit.nameStatus ?? []).flatMap((entry) => [entry.path, entry.oldPath].filter(Boolean))])];
+        // ls-tree distinguishes absent base paths from a failed blob read. Never
+        // suppress base cat-file failures or filter the trusted base bytes.
+        const baseModes = new Map((await gitRaw(["ls-tree", "-r", "-z", base.sha], projectDir)).split("\0").filter(Boolean).map((entry) => {
+          const tab = entry.indexOf("\t");
+          return [entry.slice(tab + 1), entry.slice(0, entry.indexOf(" "))];
+        }));
+        const fileChanges = [];
+        for (const file of changedFiles) {
+          const mode = baseModes.get(file);
+          const baseProblem = mode && !["100644", "100755", "120000"].includes(mode) ? UNCHECKABLE_TRUST_FILE : null;
+          const before = mode && !baseProblem
+            ? (await run("git", ["cat-file", "blob", `${base.sha}:${file}`], { cwd: projectDir, encoding: null, trim: false })).stdout
+            : Buffer.alloc(0);
+          const { bytes: after, problem, regular } = readTrustWorktreeFile(cwd, file);
+          fileChanges.push({ file, before, after, problem: baseProblem ?? problem });
+          if (regular && !problem) {
+            try {
+              // Feed the safely read bytes, never reopen a worker path. Worktree
+              // attributes must apply here exactly as they will during git add.
+              const hashed = await run("git", ["hash-object", "-w", "--stdin", `--path=${file}`], { cwd, input: after });
+              const sha = hashed.stdout.trim();
+              if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(sha)) throw new Error("invalid blob id");
+              const committed = (await run("git", ["cat-file", "blob", sha], { cwd: projectDir, encoding: null, trim: false })).stdout;
+              fileChanges.push({ file, before, after: committed });
+            } catch {
+              fileChanges.push({ file, before, after, problem: "could not be converted to committed bytes" });
+            }
+          }
+        }
+        // Unlike optional validators, failure to read this deterministic floor
+        // must not silently mark sensitive work normal.
+        const floor = evaluateTrust({ rules: trustConfig?.sensitive ?? [], changedFiles,
+          fileChanges, codeowners: trustedOwners });
+        trust = await evaluateDiffTrust({ floor, fileChanges, repository: trustedFiles, reach: trustedReach, tenantColumns: trustConfig?.tenant_columns, judgment: trustConfig?.judgment, previous: continuation?.record?.trust,
+          ...trustValidatorSettings(deps), stateRoot: path.join(jobsRoot, ".."),
+          askJev: deps.askTrustJev, askJudge: deps.askTrustJudge });
+      }
+      if (["review", "human"].includes(trust?.level) || continuation?.record?.stakes === "high") stakes = "high";
+      const afterStakes = stakes === "high" || ["review", "human"].includes(trust?.level) ? { ...afterMutation, reviewRequired: true, reasons: [...afterMutation.reasons, HIGH_STAKES_NOTE] } : afterMutation;
       const finalOutcome = applyRefactorContract(applyVerificationPolicy(afterStakes, independentVerification.status, repoPolicy()),
         { refactor, verificationStatus: independentVerification.status, testChanges: preCommit.testChanges });
 
+      const proposalDiff = criteria?.length && regressionCheck?.status === "pass" && finalOutcome.commitAllowed ? await jobDiff(true) : "";
       progress("commit");
       const commit = await createCoordinatorCommit({ cwd, jobId, outcome: finalOutcome,
         message: coordinatorCommitMessage({ task: continuation?.record?.objective ?? task, subject: commitSubject, note: reportValidation?.note ?? null, jobId, workerId, recovered: Boolean(finalOutcome.recovered), provider: (result ?? attempted)?.provider ?? null, model: (result ?? attempted)?.model ?? null, continuedFrom: continuedFrom?.jobId ?? null }) });
+      const acceptanceProposals = await jobAcceptanceProposals({ criteria, commit, regressionCheck, diff: () => proposalDiff });
       progress("record");
       const record = await collectGitRecord({ cwd, baseSha: base.sha, branch, baseRef: base.ref, jobId }), worker = workerMetadata(result ?? attempted);
 
       let coordinatorStatus = COORDINATOR_STATUS_BY_OUTCOME[finalOutcome.outcome] ?? "incomplete";
-      const issues = [...finalOutcome.reasons, ...(preCommit.issues ?? [])];
+      const issues = [...finalOutcome.reasons, ...(trustAdmission?.notes ?? []), ...(preCommit.issues ?? [])];
       if (workerStopReason === "stopped") {
         const request = readStopRequest(jobDir);
         issues.push(`stopped on request${request?.reason ? `: ${request.reason}` : ""}; the worktree is kept, so continue_from can pick the work up (on another model too)`);
@@ -574,11 +704,16 @@ export function createExecutor(deps) {
           : `report-recovery follow-up call did not produce a usable report either (${cause})`);
       }
 
+      if (trust?.level === "human") issues.unshift(`HUMAN REVIEW REQUIRED (trust): ${trust.reasons.map((entry) => entry.reason).join("; ")}`);
+
       const metrics = buildMetrics({ result: result ?? attempted, record, reportValidation, outcome: finalOutcome, workerElapsedMs, totalElapsedMs: Date.now() - jobStartedMs, regressionCheckElapsedMs, transientAbortRetried });
       const manifest = { version: VERSION, jobId, workerId: workerId || jobId, mode, projectDir, worktree, branch, startedAt, finishedAt,
-        objective: task, acceptance: acceptance ?? [], verificationProfile: verification ?? null, ...(continuedFrom ? { continuedFrom } : {}), ...(stakes ? { stakes } : {}),
+        objective: task, acceptance: acceptance ?? [], ...(criteria ? { criteria } : {}), ...(acceptanceProposals !== undefined ? { acceptanceProposals } : {}), verificationProfile: verification ?? null, ...(continuedFrom ? { continuedFrom } : {}), ...(stakes ? { stakes } : {}),
+        ...(trust ? { trust } : {}),
+        ...(trustAdmission ? { trustAdmission } : {}),
         ...(mutation ? { mutation: { ...mutation, elapsedSeconds: Math.round((mutationElapsedMs ?? 0) / 1000) } } : {}),
         ...(jevClaims || judged ? { validators: { ...(jevClaims ? { jev: { check: "report-claims", verdict: jevClaims.verdict, flagged: Boolean(jevClaims.flag), error: jevClaims.error, truncated: Boolean(jevClaims.truncated), inputTokens: jevClaims.usage } } : {}), ...(judged ? { judge: { agent: judge?.agent ?? null, provider: judge?.provider ?? null, model: judge?.model ?? null, answer: judged.answer, flags: judged.flags, error: judged.error } } : {}) } } : {}),
+        ...(contractCheck.record.affected.length || contractCheck.record.bounded ? { contract: contractCheck.record } : {}),
         outcome: finalOutcome.outcome, recovered: finalOutcome.recovered, recoveryAttempted: finalOutcome.recoveryAttempted,
         reportRecoveryAttempted, reportRecovered,
         reviewRequired: finalOutcome.reviewRequired || record.testChanges.reviewRequired,
@@ -608,8 +743,8 @@ export function createExecutor(deps) {
       progress("finished", { coordinatorStatus, outcome: finalOutcome.outcome });
       return { ok: coordinatorStatus === "complete", report: report || "(worker returned no final report)", manifest, jobDir };
     } catch (error) {
-      const failure = { version: VERSION, jobId, workerId: workerId || jobId, mode, branch, worktree, outcome: OUTCOMES.WORKER_FAILED,
-        coordinatorStatus: "failed", error: error.stack || error.message, retained: Boolean(worktree), worktreeRetained: Boolean(worktree), execution };
+      const failure = { version: VERSION, jobId, workerId: workerId || jobId, mode, branch, worktree, ...(stakes ? { stakes } : {}), outcome: OUTCOMES.WORKER_FAILED,
+        coordinatorStatus: "failed", ...(criteria ? { criteria } : {}), error: error.stack || error.message, retained: Boolean(worktree), worktreeRetained: Boolean(worktree), execution };
       fs.writeFileSync(path.join(jobDir, "failure.json"), JSON.stringify(failure, null, 2));
       progress("finished", { coordinatorStatus: "failed", outcome: OUTCOMES.WORKER_FAILED });
       return { ok: false, report: `LOCAL WORKER FAILED:\n${error.stack || error.message}`, manifest: failure, jobDir };
@@ -627,6 +762,7 @@ export function createExecutor(deps) {
     try {
       progress("worktree");
       await run("git", ["worktree", "add", "--detach", worktree, base.sha], { cwd: projectDir });
+      const sealedPointer = recordCreatedWorktree(worktree);
       const startedAt = new Date().toISOString();
 
       // Place the deterministic evidence CLI where the sandbox can run it. It
@@ -712,6 +848,7 @@ export function createExecutor(deps) {
         }
       }
 
+      requireWorktreePointer(worktree, sealedPointer);
       const record = await collectGitRecord({ cwd: worktree, baseSha: base.sha, branch: null, baseRef: base.ref, jobId });
       const dirty = record.repoStatusFiles.length > 0;
       const readFile = async p => { try { return await gitRaw(["show", `${base.sha}:${p}`], projectDir); } catch { return null; } };
@@ -729,7 +866,10 @@ export function createExecutor(deps) {
 
       progress("record");
       if (outcome.retainWorktree) worktreeRetained = true;
-      else await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }).catch(() => { worktreeRetained = fs.existsSync(worktree); });
+      else {
+        try { assertRegisteredWorktree(worktree); await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }); }
+        catch (error) { worktreeRetained = fs.existsSync(worktree); outcome.reasons.push(error.message); outcome.reviewRequired = true; }
+      }
 
       const worker = workerMetadata(result ?? attempted);
       const issues = [...outcome.reasons];
@@ -802,6 +942,16 @@ export function createExecutor(deps) {
         // reasoningApplied is what the field previously conflated it with.
         requestedProfile: profile, requestedReasoning: reasoning, reasoningApplied: resolveReasoningApplied({ result, profile, reasoning, workerModelThinkingSupported }), execution };
       fs.writeFileSync(path.join(jobDir, "metadata.json"), JSON.stringify(manifest, null, 2));
+      if (reviews) {
+        try {
+          const job = JSON.parse(fs.readFileSync(path.join(jobsRoot, reviews, "metadata.json"), "utf8"));
+          recordReviewEvidence({ stateDir: path.dirname(jobsRoot), operatorDir: projectDir, review: manifest, job });
+        } catch (error) {
+          // The finished review remains available; trust review retries collection.
+          manifest.issues.push(`Trust learning evidence not recorded: ${error.message}`);
+          fs.writeFileSync(path.join(jobDir, "metadata.json"), JSON.stringify(manifest, null, 2));
+        }
+      }
       if (result) fs.writeFileSync(path.join(jobDir, "result.json"), JSON.stringify(result, null, 2));
       progress("finished", { coordinatorStatus: outcome.coordinatorStatus, outcome: outcome.outcome });
       return { ok: outcome.coordinatorStatus === "complete", report: rendered, manifest, jobDir };
@@ -832,6 +982,7 @@ export function createExecutor(deps) {
     try {
       progress("worktree");
       await run("git", ["worktree", "add", "--detach", worktree, base.sha], { cwd: projectDir });
+      const sealedPointer = recordCreatedWorktree(worktree);
       const startedAt = new Date().toISOString();
 
       const evidenceTool = ".openclaw/nomarmy-evidence.mjs";
@@ -859,6 +1010,7 @@ export function createExecutor(deps) {
       progress("verification");
       const used = result?.budgetsUsed ?? budgetState.budgets; // see executeScout: the job's own budget, not the local one
       const report = parseDecomposeReport(reportText, used.decompose);
+      requireWorktreePointer(worktree, sealedPointer);
       const record = await collectGitRecord({ cwd: worktree, baseSha: base.sha, branch: null, baseRef: base.ref, jobId });
       const dirty = record.repoStatusFiles.length > 0;
       const readFile = async p => { try { return await gitRaw(["show", `${base.sha}:${p}`], projectDir); } catch { return null; } };
@@ -868,7 +1020,10 @@ export function createExecutor(deps) {
 
       progress("record");
       if (outcome.retainWorktree) worktreeRetained = true;
-      else await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }).catch(() => { worktreeRetained = fs.existsSync(worktree); });
+      else {
+        try { assertRegisteredWorktree(worktree); await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }); }
+        catch (error) { worktreeRetained = fs.existsSync(worktree); outcome.reasons.push(error.message); outcome.reviewRequired = true; }
+      }
 
       const worker = workerMetadata(result ?? attempted);
       const issues = [...outcome.reasons];

package/lib/git-record.mjs

@@ -94,8 +94,15 @@ export function wrapText(text, width) {
 
 export function worktreePointerState(worktree) {
   if (!worktree) return { applicable: false, exists: null, kind: null };
-  const dotGit = path.join(worktree, ".git"); if (!fs.existsSync(dotGit)) return { applicable: true, exists: false, kind: "missing" };
-  const stat = fs.lstatSync(dotGit); return { applicable: true, exists: true, kind: stat.isFile() ? "file" : stat.isDirectory() ? "directory" : "other" };
+  const dotGit = path.join(worktree, ".git");
+  let stat;
+  try { stat = fs.lstatSync(dotGit); }
+  catch (error) {
+    if (error.code === "ENOENT") return { applicable: true, exists: false, kind: "missing" };
+    return { applicable: true, exists: false, kind: "unreadable" };
+  }
+  const kind = stat.isSymbolicLink() ? "symlink" : stat.isFile() ? "file" : stat.isDirectory() ? "directory" : "other";
+  return { applicable: true, exists: true, kind };
 }
 
 export function createGitRecord({ run, git, gitRaw }) {

package/lib/health.mjs

@@ -27,6 +27,7 @@ import { executionMode } from "./execution.mjs";
 import { modelRejection } from "./openclaw-errors.mjs";
 import { providerConfigured, readOpenclawConfig } from "./openclaw-config.mjs";
 import { readUsageSnapshots, usageStatus, usageDisplayText, usageReadingIsStale, refreshStaleOverLimitReadings } from "./usage-limits.mjs";
+import { PORTABLE_SERVER } from "./connect.mjs";
 import { freshnessIssues, readInstallVersions } from "./install-freshness.mjs";
 
 import { PINNED_OPENCLAW_VERSION } from "./openclaw-install.mjs";
@@ -280,12 +281,33 @@ export function leftoverIssues({ retainedWorktrees = 0, jobsBytes = 0, staleRunn
   return issues;
 }
 
+/** Check repository registrations against the same launch command connect writes. */
+export function projectRegistrationIssues(projectDir) {
+  if (!projectDir) return [];
+  const issues = [];
+  // Codex connect supports user scope only, so it has no project equivalent.
+  for (const [target, relative] of [["claude", ".mcp.json"], ["cursor", ".cursor/mcp.json"]]) {
+    const file = path.join(projectDir, relative);
+    let entry;
+    try { entry = JSON.parse(fs.readFileSync(file, "utf8"))?.mcpServers?.["nomarmy-local-worker"]; }
+    catch (error) { if (error.code === "ENOENT") continue; entry = {}; }
+    if (entry === undefined) continue;
+    if (entry?.command === PORTABLE_SERVER.command && Array.isArray(entry.args)
+      && entry.args.length === PORTABLE_SERVER.args.length && entry.args.every((arg, i) => arg === PORTABLE_SERVER.args[i])) continue;
+    issues.push({ id: `project-mcp:${target}`, severity: "warn",
+      title: `Unexpected project MCP registration in ${relative}`,
+      detail: `${file} is executable repository configuration; its command and args do not match what nomarmy connect writes today.`,
+      fix: `nomarmy connect ${target} --scope project (rewrite it), or review ${file} by hand`, short: "project MCP changed" });
+  }
+  return issues;
+}
+
 /**
  * Run every check. `env` supplies what each needs, with real defaults;
  * tests pass their own.
  */
-export async function runHealthChecks({ now = Date.now(), mode = "local", openclawCmd = process.env.NOMARMY_OPENCLAW_CMD || "openclaw", run = runBounded, armySummary = null, agentsError = null, jobsRoot = null, pidAlive = () => true, agents = null, openclawConfig = null, vendors = {}, modelsInUse = null, autoPruned = null, usageSnapshots = null, stateRoot = null, install = null } = {}) {
-  const issues = [];
+export async function runHealthChecks({ now = Date.now(), mode = "local", openclawCmd = process.env.NOMARMY_OPENCLAW_CMD || "openclaw", run = runBounded, armySummary = null, agentsError = null, jobsRoot = null, pidAlive = () => true, agents = null, openclawConfig = null, vendors = {}, modelsInUse = null, autoPruned = null, usageSnapshots = null, stateRoot = null, install = null, projectDir = null } = {}) {
+  const issues = projectRegistrationIssues(projectDir);
   if (autoPruned?.freedBytes) issues.push({ id: `auto-prune:${new Date(now).toISOString()}`, severity: "info",
     title: `Freed ${(autoPruned.freedBytes / 1024 ** 3).toFixed(2)} GB: ${[autoPruned.pruned ? `runtime data of ${autoPruned.pruned} finished job${autoPruned.pruned === 1 ? "" : "s"} older than ${autoPruned.olderThanHours}h` : null, autoPruned.scratchCleared ? `OpenClaw scratch files of ${autoPruned.scratchCleared} more` : null].filter(Boolean).join(", ")}`,
     detail: "Automatic; each job's record and report are kept. NOMARMY_AUTO_PRUNE_HOURS sets the age (0 turns it off).", fix: null, short: null });
@@ -413,7 +435,7 @@ export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, n
   if (ageMs !== null) { try { autoPruned = { ...pruneJobRuntime({ stateRoot, olderThanMs: ageMs, now }), olderThanHours: ageMs / 3600000 }; } catch { /* best-effort */ } }
   const mode = executionMode(env).mode;
   const install = await readRegisteredInstall({ projectDir });
-  const result = await runHealthChecks({ now, mode, armySummary, agentsError, jobsRoot: path.join(stateRoot, "jobs"), pidAlive,
+  const result = await runHealthChecks({ now, mode, projectDir, armySummary, agentsError, jobsRoot: path.join(stateRoot, "jobs"), pidAlive,
     agents, openclawConfig: readOpenclawConfig(), vendors: SUBSCRIPTION_VENDORS, modelsInUse, autoPruned, usageSnapshots: readUsageSnapshots(stateRoot), stateRoot, install });
   try {
     const { loadJobRecords, agentLookup } = await import("./stats.mjs");