nomarmy 0.1.0-alpha.2 → 0.1.0-alpha.21

package/lib/openclaw-install.mjs

@@ -0,0 +1,122 @@
+// One tested release for every nomArmy-managed OpenClaw installation.
+// Never follow npm's dist-tag or downgrade a newer installation.
+import { spawnSync } from "node:child_process";
+import { SUBSCRIPTION_VENDORS, parseOpenclawVersion, versionAtLeast } from "./subscription-setup.mjs";
+
+export const PINNED_OPENCLAW_VERSION = "2026.9.6";
+export const OPENCLAW_INSTALL_ARGS = Object.freeze(["install", "-g", `openclaw@${PINNED_OPENCLAW_VERSION}`]);
+
+export function runOpenclawCommand(command, args, { timeoutMs = command === "npm" ? 600000 : 60000 } = {}) {
+  const r = spawnSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs });
+  const timedOut = r.error?.code === "ETIMEDOUT";
+  return { ok: !timedOut && r.status === 0, stdout: r.stdout ?? "",
+    stderr: timedOut ? `Command timed out after ${timeoutMs} ms.` : r.stderr ?? "", timedOut };
+}
+
+export function openclawInstallPlan(installed, { prefix = null } = {}) {
+  const have = parseOpenclawVersion(installed);
+  if (versionAtLeast(have, PINNED_OPENCLAW_VERSION)) return [];
+  return [{
+    description: `${have ? "Upgrade" : "Install"} OpenClaw to ${PINNED_OPENCLAW_VERSION}`,
+    command: "npm",
+    args: [...OPENCLAW_INSTALL_ARGS, ...(prefix ? ["--prefix", prefix] : [])],
+  }];
+}
+
+export function configuredSubscriptionVendors(agents = {}, extra = []) {
+  return [...new Set([...extra, ...Object.values(agents)
+    .filter((a) => a?.kind === "subscription")
+    .map((a) => Object.keys(SUBSCRIPTION_VENDORS).find((key) => SUBSCRIPTION_VENDORS[key].provider === a.provider))])].filter(Boolean);
+}
+
+/** Read-only postflight using structured status and plugin compatibility data. */
+function parseCommandJson(stdout) {
+  const start = (stdout ?? "").indexOf("{");
+  if (start < 0) throw new Error("No JSON object in command output");
+  return JSON.parse(stdout.slice(start));
+}
+
+export function verifyOpenclaw({ run = runOpenclawCommand, command = "openclaw", vendors = [] } = {}) {
+  const checks = [];
+  const version = run(command, ["--version"]);
+  const have = version.ok ? parseOpenclawVersion(version.stdout) : null;
+  checks.push({
+    id: "openclaw", ok: versionAtLeast(have, PINNED_OPENCLAW_VERSION),
+    message: have ? `OpenClaw ${have.join(".")}${have.join(".") !== PINNED_OPENCLAW_VERSION && versionAtLeast(have, PINNED_OPENCLAW_VERSION) ? " is newer than the tested release; left unchanged" : ""}.` : version.timedOut ? "OpenClaw version check timed out." : "OpenClaw version could not be verified.",
+    fix: `npm ${OPENCLAW_INSTALL_ARGS.join(" ")}`,
+  });
+  if (!have) return checks;
+  for (const key of [...new Set(vendors)]) {
+    const vendor = SUBSCRIPTION_VENDORS[key];
+    if (!vendor) throw new Error(`Unknown subscription vendor: ${key}`);
+    if (!vendor.plugin) continue;
+    const { id, spec } = vendor.plugin;
+    const inspected = run(command, ["plugins", "inspect", id, "--json"]);
+    let plugin;
+    try { plugin = parseCommandJson(inspected.stdout).plugin; } catch { /* Unverified output fails below. */ }
+    const pluginVersion = plugin?.builtWithOpenClawVersion === undefined ? plugin?.version : plugin.builtWithOpenClawVersion;
+    const installedVersion = have.join(".");
+    const ok = inspected.ok && plugin?.enabled === true && pluginVersion !== undefined && versionAtLeast(have, pluginVersion);
+    checks.push({
+      id: `openclaw-plugin:${id}`, ok,
+      message: ok ? `OpenClaw plugin ${id} ${pluginVersion} is ready (built for ${pluginVersion}; OpenClaw is ${installedVersion}).` : `OpenClaw plugin ${id} ${inspected.timedOut ? "check timed out." : plugin?.enabled === true && pluginVersion === undefined ? "version could not be verified." : `is missing, disabled, unreadable, or built for a newer OpenClaw than ${installedVersion}.`}`,
+      fix: `openclaw plugins install ${spec}`,
+    });
+  }
+  const status = run(command, ["update", "status", "--json"]);
+  let warnings;
+  try {
+    if (!status.ok) throw new Error("Status command failed");
+    const data = parseCommandJson(status.stdout);
+    warnings = data.migrationWarnings === undefined ? [] : data.migrationWarnings;
+    if (!Array.isArray(warnings) || warnings.some((warning) => typeof warning !== "string")) throw new Error("Invalid migration warnings");
+  } catch {
+    checks.push({ id: "openclaw-migrations", ok: false, message: status.timedOut ? "OpenClaw migration check timed out." : "OpenClaw migrations could not be verified. Run openclaw update status --json by hand.", fix: "openclaw update status --json" });
+    return checks;
+  }
+  checks.push({
+    id: "openclaw-migrations", ok: warnings.length === 0,
+    message: warnings.length ? warnings.join("\n") : "No pending OpenClaw migrations.",
+    fix: "openclaw update repair",
+  });
+  return checks;
+}
+
+/** Print the complete mutation plan before a single default-no consent gate. */
+export async function repairOpenclaw({
+  run = runOpenclawCommand, command = "openclaw", vendors = [], prefix = null,
+  yes = false, isTTY = false, ask = async () => "", print = console.log,
+} = {}) {
+  const version = run(command, ["--version"]);
+  const actions = openclawInstallPlan(version.ok ? version.stdout : null, { prefix });
+  print("Planned changes:");
+  for (const action of actions) print(`  ${action.description}: ${action.command} ${action.args.join(" ")}`);
+  if (!actions.length) print("  None. The installed OpenClaw is not older than the tested release.");
+  print("Postflight checks (read-only):");
+  print(`  ${command} --version`);
+  for (const key of [...new Set(vendors)]) {
+    const vendor = SUBSCRIPTION_VENDORS[key];
+    if (!vendor) throw new Error(`Unknown subscription vendor: ${key}`);
+    if (vendor.plugin) print(`  ${command} plugins inspect ${vendor.plugin.id} --json`);
+  }
+  print(`  ${command} update status --json`);
+  print("  Migration repairs are not run automatically. If needed, run openclaw update repair --yes separately.");
+  const changed = [];
+  if (actions.length && !yes && (!isTTY || !/^(y|yes)$/i.test((await ask("Apply these changes? [y/N] ")).trim()))) {
+    print(isTTY ? "No changes made." : "No changes made. Non-interactive repair requires --yes.");
+    return { ok: false, actions, changed, checks: [] };
+  }
+  for (const action of actions) {
+    const result = run(action.command, action.args);
+    if (!result.ok) {
+      print(`Failed: ${action.description}. Fix: ${action.command} ${action.args.join(" ")}`);
+      print(`Completed changes: ${changed.length ? changed.join("; ") : "none"}. The failed install may have partially modified OpenClaw.`);
+      return { ok: false, actions, changed, checks: [] };
+    }
+    changed.push(action.description);
+  }
+  print(`Changed: ${changed.length ? changed.join("; ") : "nothing"}.`);
+  const checks = verifyOpenclaw({ run, command, vendors });
+  for (const check of checks) print(`${check.ok ? "OK" : "FAIL"}: ${check.message}${check.ok ? "" : ` Fix: ${check.fix}`}`);
+  return { ok: checks.every((check) => check.ok), actions, changed, checks };
+}

package/lib/openclaw-path.mjs

@@ -0,0 +1,28 @@
+// Find OpenClaw where install.sh may have put it. With no writable npm global
+// folder (common on Linux), it installs into ~/.npm-global/bin, which isn't on
+// most PATHs: a fresh-install practice run ended "OpenClaw not found", and
+// every job would then fail. The CLI and the MCP server call this first, so
+// they and everything they spawn find it.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const isExecutable = (file) => { try { fs.accessSync(file, fs.constants.X_OK); return fs.statSync(file).isFile(); } catch { return false; } };
+
+export function openclawFallbackDirs(home = os.homedir()) {
+  return [path.join(home, ".npm-global", "bin"), path.join(home, ".local", "bin")];
+}
+
+/** Adds the folder holding openclaw to env.PATH when it isn't already reachable. Returns the folder added, or null. */
+export function ensureOpenClawOnPath(env = process.env, { home = os.homedir(), platform = process.platform } = {}) {
+  if (env.NOMARMY_OPENCLAW_CMD) return null;
+  const sep = platform === "win32" ? ";" : ":";
+  const names = platform === "win32" ? ["openclaw.cmd", "openclaw.exe", "openclaw"] : ["openclaw"];
+  const dirs = String(env.PATH ?? "").split(sep).filter(Boolean);
+  if (dirs.some((d) => names.some((n) => isExecutable(path.join(d, n))))) return null;
+  const found = openclawFallbackDirs(home).find((d) => names.some((n) => isExecutable(path.join(d, n))));
+  if (!found) return null;
+  env.PATH = [found, ...dirs].join(sep);
+  return found;
+}

package/lib/openclaw-run.mjs

@@ -4,7 +4,7 @@ import path from "node:path";
 import { resolveExecutable } from "./process.mjs";
 import { readOpenClawTranscriptTail } from "./transcript.mjs";
 import { loadConfig } from "./config.mjs";
-import { resolveSandboxImage, detectPrimaryLanguage, EXEC_PATH_PREPEND, SANDBOX_NPM_ENV } from "./sandbox-images.mjs";
+import { resolveSandboxImage, sandboxPathEntries, SANDBOX_NPM_ENV } from "./sandbox-images.mjs";
 import { DEFAULT_AGENT_IMAGE } from "./verify.mjs";
 import { scoutPrompt, isScoutReportUnusable } from "./scout.mjs";
 import { decomposePrompt } from "./decompose.mjs";
@@ -13,6 +13,7 @@ import { deriveBudgets } from "./budget.mjs";
 import { entryContextPerNom } from "./dispatch-config.mjs";
 import { readClaudeSessionUsage } from "./claude-transcript.mjs";
 import { modelRejection, modelRejectionLine } from "./openclaw-errors.mjs";
+import { nearestThinkingLevel } from "./thinking.mjs";
 
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
@@ -61,6 +62,35 @@ export function makeAbandonedBackgroundProcessTick(stateDir, { idleMs, minElapse
  * tool call and files changed so far (liveProgress), and when. Never asks
  * to stop; a failed read just skips that beat.
  */
+// local_worker_stop (or `nomarmy jobs --stop`) writes this into the job's
+// folder, so any session can stop any job; the next tick ends the worker.
+export const STOP_REQUEST_FILE = "stop-request.json";
+export function makeStopRequestTick(jobDir) {
+  return async () => (fs.existsSync(path.join(jobDir, STOP_REQUEST_FILE)) ? { stop: true, reason: "stopped" } : { stop: false });
+}
+/**
+ * Ask a running job to stop. Refuses what isn't running; never kills
+ * anything itself (the job's own tick does, within one tick).
+ * @returns {{ ok: boolean, message: string }}
+ */
+export function requestJobStop({ jobsRoot, jobId, reason = null, now = new Date() }) {
+  if (!/^[A-Za-z0-9._-]{1,120}$/.test(String(jobId ?? ""))) return { ok: false, message: "not a job id" };
+  const jobDir = path.join(jobsRoot, jobId);
+  let status = null;
+  try { status = JSON.parse(fs.readFileSync(path.join(jobDir, "status.json"), "utf8")); } catch { return { ok: false, message: `no job ${jobId} (see local_worker_jobs)` }; }
+  if (status.state !== "running") return { ok: false, message: `job ${jobId} isn't running (it's ${status.state ?? "unknown"})` };
+  if (status.phase && status.phase !== "worker" && status.phase !== "starting" && status.phase !== "worktree") {
+    return { ok: false, message: `job ${jobId} is past its worker (phase ${status.phase}); it's finishing on its own and spends no more model usage` };
+  }
+  if (fs.existsSync(path.join(jobDir, STOP_REQUEST_FILE))) return { ok: true, message: `a stop was already requested for ${jobId}` };
+  fs.writeFileSync(path.join(jobDir, STOP_REQUEST_FILE), JSON.stringify({ at: now.toISOString(), reason: reason ? String(reason).slice(0, 300) : null }));
+  return { ok: true, message: `stop requested for ${jobId}: its worker ends within about 15 seconds, verification is skipped, and the worktree is kept uncommitted, so continue_from can pick the work up (on another model too)` };
+}
+
+export function readStopRequest(jobDir) {
+  try { return JSON.parse(fs.readFileSync(path.join(jobDir, STOP_REQUEST_FILE), "utf8")); } catch { return null; }
+}
+
 export function makeHeartbeatTick(jobDir, liveProgress) {
   // Never two beats at once: a slow beat used to overlap the next.
   let busy = false;
@@ -128,12 +158,44 @@ export function parseUnsupportedThinkingError(errorMessage) {
 // worker that ran out of room, but has valid session state worth resuming)
 // it exists for. Checked against the real captured envelope from that
 // incident, not a synthesized shape.
-export function parseOpenClawInternalTimeout(stdout) {
+export function parseOpenClawInternalTimeout(stdout, stderr = "") {
+  // OpenClaw's own timer can end a run in the middle of a tool call. The
+  // envelope then reports that call's failure ("Read failed", status
+  // "error"), not a timeout; its run log still says so. Seen live on a Grok
+  // security review cut off mid-read at 600s: recorded as a crash, so its
+  // findings were never recovered.
+  if (/embedded run timeout: /.test(String(stderr))) return true;
   let parsed;
   try { parsed = JSON.parse(stdout); } catch { return false; }
   return parsed?.ok === false && (parsed?.status === "timeout" || parsed?.error?.kind === "timeout");
 }
 
+/** What a failed run's envelope still says it used, so a failed job's spend is recorded too. */
+export function failedRunUsage(stdout) {
+  let parsed;
+  try { parsed = JSON.parse(stdout); } catch { return {}; }
+  if (!parsed || typeof parsed !== "object") return {};
+  const out = {};
+  if (parsed.usage && typeof parsed.usage === "object") out.usage = parsed.usage;
+  if (Number.isFinite(parsed.costUsd)) out.costUsd = parsed.costUsd;
+  if (parsed.toolSummary && typeof parsed.toolSummary === "object") out.toolSummary = parsed.toolSummary;
+  if (typeof parsed.sessionId === "string") out.sessionId = parsed.sessionId;
+  return out;
+}
+
+/**
+ * The time a run has, told to the worker. Without it a Grok scout read files
+ * for its whole 10 minutes and was cut off before writing a word of its report.
+ */
+export function timeBudgetNote(timeoutSeconds, mode) {
+  const total = Number(timeoutSeconds);
+  if (!Number.isFinite(total) || total <= 0) return "";
+  const minutes = Math.max(1, Math.round(total / 60));
+  const wrapAt = Math.max(1, Math.floor((total * 0.8) / 60));
+  const what = mode === "scout" || mode === "decompose" ? "stop exploring and write your report from what you have" : "stop starting new work, finish verification and write your report";
+  return `\n\nTIME\nThis run has about ${minutes} minute(s), then it is cut off. By minute ${wrapAt}, ${what}. A report on part of the question, with what's left under NOT DONE, is far more useful than none.`;
+}
+
 /**
  * A run whose work finished but whose exit failed: OpenClaw logged the run
  * ending normally (stopReason=stop) and then errored, e.g. "Codex one-shot
@@ -337,7 +399,7 @@ export function createOpenClawRunner(deps) {
   // which is the one per-call lever that does reach the sandbox OpenClaw
   // starts for that run. This clones the ambient config, points
   // agents.defaults.sandbox.docker.image at the resolved image, and adds
-  // EXEC_PATH_PREPEND's extra PATH entries -- verified live: OpenClaw's exec
+  // the matched harnesses' extra PATH entries -- verified live: OpenClaw's exec
   // tool does not inherit a sandbox image's own baked ENV PATH on its own (a
   // freshly built Go image's `go` resolved fine under a direct `podman exec`
   // but came back "not found" through `openclaw agent exec` until
@@ -360,7 +422,7 @@ export function createOpenClawRunner(deps) {
     // contract verification does.
     loadConfigFn = () => loadConfig(projectDir),
     resolveSandboxImageFn = resolveSandboxImage,
-    detectPrimaryLanguageFn = detectPrimaryLanguage,
+    sandboxPathEntriesFn = sandboxPathEntries,
     ambientConfigPathFn = ambientOpenClawConfigPath,
     readAmbientConfig = (p) => JSON.parse(fs.readFileSync(p, "utf8")),
   } = {}) {
@@ -372,7 +434,7 @@ export function createOpenClawRunner(deps) {
 
     let image;
     try {
-      image = resolveSandboxImageFn({ cwd, explicitImage: process.env.NOMARMY_AGENT_IMAGE || null, defaultImage: DEFAULT_AGENT_IMAGE, config });
+      image = resolveSandboxImageFn({ cwd, trustedDir: projectDir, explicitImage: process.env.NOMARMY_AGENT_IMAGE || null, defaultImage: DEFAULT_AGENT_IMAGE, config });
     } catch {
       // A lazy Go/Rust/Python image build failure here should not fail the
       // worker's turn -- it runs in the default image instead, same as before
@@ -399,8 +461,7 @@ export function createOpenClawRunner(deps) {
     // own verification runs: outside the worktree, and off.
     overridden.agents.defaults.sandbox.docker.env = { ...(overridden.agents.defaults.sandbox.docker.env ?? {}), ...SANDBOX_NPM_ENV };
 
-    const lang = detectPrimaryLanguageFn(cwd, config);
-    const pathPrepend = EXEC_PATH_PREPEND[lang] || [];
+    const pathPrepend = sandboxPathEntriesFn(cwd, config);
     if (pathPrepend.length) {
       overridden.tools ??= {};
       overridden.tools.exec ??= {};
@@ -443,7 +504,7 @@ export function createOpenClawRunner(deps) {
       ? scoutPrompt({ question: task, mustCover: acceptance, baseRef, baseSha, workerId, limits: jobBudgets.scout, report: jobBudgets.report.scout, evidenceTool })
       : mode === "decompose"
       ? decomposePrompt({ objective: task, constraints: acceptance, baseRef, baseSha, workerId, limits: jobBudgets.decompose, report: jobBudgets.report.decompose, evidenceTool })
-      : workerPrompt({ task, acceptance, verification, mode, baseRef, baseSha, workerId, evidence, report: jobBudgets.report.implement }));
+      : workerPrompt({ task, acceptance, verification, mode, baseRef, baseSha, workerId, evidence, report: jobBudgets.report.implement })) + (overridePrompt ? "" : timeBudgetNote(timeoutSeconds, mode));
     fs.writeFileSync(path.join(jobDir, `brief${logSuffix}.txt`), prompt + "\n");
     // --state-dir keeps OpenClaw's session state (its transcript database among
     // it) inside the job directory instead of a temp dir it deletes on exit.
@@ -476,8 +537,9 @@ export function createOpenClawRunner(deps) {
     // The heartbeat runs for every job, so a running job is always watchable
     // (status.json used to keep its launch-time updatedAt until the end).
     const onTick = combineTicks([
+      makeStopRequestTick(jobDir),
       makeHeartbeatTick(jobDir),
-      ...(idleDiff ? [makeIdleDiffTick(cwd, idleDiff), makeAbandonedBackgroundProcessTick(stateDir, idleDiff)] : []),
+      ...(idleDiff ? [makeIdleDiffTick(cwd, { ...idleDiff, activity: async () => { const t = await readOpenClawTranscriptTail(stateDir, { limit: 5 }); return t.available ? { events: t.events, toolInFlight: t.toolInFlight } : null; } }), makeAbandonedBackgroundProcessTick(stateDir, idleDiff)] : []),
     ]);
     const liveLogs = { stdout: path.join(jobDir, `openclaw${logSuffix}.stdout.log`), stderr: path.join(jobDir, `openclaw${logSuffix}.stderr.log`) };
     // Where this call's own transcript events will start (see salvageFinishedRun).
@@ -519,7 +581,7 @@ export function createOpenClawRunner(deps) {
           // -- never loop on the same level, and never mask a real, unrelated
           // failure as a thinking-level problem it isn't.
           if (unsupported && !unsupported.supported.includes(selected.thinking)) {
-            const fallback = unsupported.supported[0];
+            const fallback = nearestThinkingLevel(selected.thinking, unsupported.supported);
             fs.appendFileSync(path.join(jobDir, "coordinator.log"),
               `${new Date().toISOString()} "${selected.model}" rejected thinking level "${selected.thinking}" (OpenClaw supports: ${unsupported.supported.join(", ")}) -- retrying once with "${fallback}"\n`);
             selected.thinking = fallback; // the manifest's requestedReasoning field should reflect what was ACTUALLY used, not the level that failed
@@ -557,7 +619,7 @@ export function createOpenClawRunner(deps) {
         // a graceful internal timeout, not an opaque crash -- relabel it so
         // executeImplement/executeScout's workerTimedOut check (and therefore
         // report recovery) sees it correctly.
-        if (!error.timedOut && parseOpenClawInternalTimeout(error.stdout)) {
+        if (!error.timedOut && error.stopReason !== "stopped" && parseOpenClawInternalTimeout(error.stdout, error.stderr)) {
           error.timedOut = true;
           error.stopReason = error.stopReason ?? "openclaw_internal_timeout";
         }
@@ -582,7 +644,7 @@ export function createOpenClawRunner(deps) {
         }
         // What was attempted, for the job record: a failed job used to be
         // labeled with the local default model, whatever it really ran on.
-        error.partialResult = { model: bareModel, provider: selected.entry?.provider ?? workerProvider, budgetsUsed: jobBudgets };
+        error.partialResult = { ...failedRunUsage(error.stdout), model: bareModel, provider: selected.entry?.provider ?? workerProvider, budgetsUsed: jobBudgets };
         throw error;
       } finally {
         // A cloned copy of the ambient OpenClaw config (which may carry a real

package/lib/openclaw-runtime-health.mjs

@@ -0,0 +1,56 @@
+// Metadata-only checks for the runtime used by nomArmy's real test calls.
+import { agentProviderId } from "./agents.mjs";
+export const CODEX_IMPORT_RECOVERY = "openclaw migrate apply codex --from ~/.codex --agent main --include-secrets --item auth:openai --yes";
+export function codexImportRecovery({ profiles = [] } = {}) {
+  return [...emailOpenaiProfiles(profiles).map((p) => `openclaw models auth logout ${shellId(p.id)}`), CODEX_IMPORT_RECOVERY].join(" && ");
+}
+
+export const CODEX_IMPORT_ARGS = ["migrate", "apply", "codex", "--from", "~/.codex", "--agent", "main", "--include-secrets", "--item", "auth:openai", "--yes"];
+export function emailOpenaiProfiles(profiles) {
+  return profiles.filter((p) => /^openai:.*@/.test(p.id ?? ""));
+}
+export function shellId(id) {
+  return /^[\w@.+:-]+$/.test(id) ? id : "'" + id.replaceAll("'", "'\\''") + "'";
+}
+export function usableCodexImport(profiles, now = Date.now()) {
+  return profiles.some((p) => p.provider === "openai" && /^openai:account-/.test(p.id ?? "") &&
+    [p.label, p.name, p.displayName].some((s) => typeof s === "string" && s.includes("(Codex import)")) &&
+    (p.expiresAt == null || Date.parse(p.expiresAt) > now));
+}
+export function codexImportIssues(profiles, { now = Date.now() } = {}) {
+  const issues = [];
+  const emails = emailOpenaiProfiles(profiles);
+  const fix = codexImportRecovery({ profiles });
+  if (!usableCodexImport(profiles, now)) issues.push({
+    id: "codex-import:missing", severity: "error", title: "Codex has no unexpired account-ID (Codex import) profile",
+    detail: "The Codex app-server cannot use an email-keyed OpenAI login. Confirm Codex CLI login, then re-import it.",
+    fix, short: "Codex import missing",
+  });
+  if (emails.length) issues.push({
+    id: "codex-import:shadowed", severity: "error", title: "Email-keyed OpenAI profiles capture the Codex import",
+    detail: `Remove before importing: ${emails.map((p) => p.id).join(", ")}. A models status probe is not an app-server login test.`,
+    fix, short: "Codex import shadowed",
+  });
+  return issues;
+}
+export function modelPolicyIssues({ policies, paths, agents = {}, armySummary = null, modelsInUse = null }) {
+  const models = new Set(modelsInUse ?? []);
+  for (const a of Object.values(agents ?? {})) {
+    const provider = agentProviderId(a);
+    if (provider && a.model && a.model !== "auto") models.add(`${provider}/${a.model}`);
+  }
+  for (const role of Object.values(armySummary?.roles ?? {})) {
+    const provider = agentProviderId(agents?.[role.agent]);
+    if (provider && role.model && role.model !== "auto" && !role.modelIsAuto) models.add(`${provider}/${role.model}`);
+  }
+  return policies.flatMap((result, i) => {
+    let allow;
+    try { allow = result.ok ? JSON.parse(result.stdout) : null; } catch { return []; }
+    if (!Array.isArray(allow)) return [];
+    const missing = [...models].filter((m) => !allow.includes(m)).sort();
+    if (!missing.length) return [];
+    return [{ id: `model-policy:${paths[i]}`, severity: "error", title: `OpenClaw model policy excludes: ${missing.join(", ")}`,
+      detail: `${paths[i]} refuses models used by nomArmy agents or roles.`,
+      fix: `openclaw config unset ${paths[i].replace(/\.allow$/, "")} (or add the missing models to ${paths[i]})`, short: "models blocked" }];
+  });
+}

package/lib/outcome.mjs

@@ -7,6 +7,16 @@ import { parseWorkerReport } from "./report.mjs";
 // failed. Recovery exists so that a mangled REPORT cannot destroy correct WORK.
 // It does not exist to launder a failure into a success.
 // ---------------------------------------------------------------------------
+// A failed verification's own detail (the command, its exit code, the end of
+// its output), capped so an issue line stays readable; the full output is in
+// the job's verification.log.
+const FAILURE_DETAIL_CHARS = 600;
+function failureDetail(independentVerification) {
+  const detail = String(independentVerification?.detail ?? independentVerification?.reason ?? "").trim();
+  if (!detail) return "";
+  return `: ${detail.length > FAILURE_DETAIL_CHARS ? `${detail.slice(0, FAILURE_DETAIL_CHARS)}...` : detail}`;
+}
+
 export function resolveOutcome({ report, repositoryChanged = false, independentVerification = null, regressionCheck = null, workerFailed = false, workerTimedOut = false, mode = "implement" }) {
   const verification = independentVerification?.status ?? "not_run";
   const parsed = report ?? parseWorkerReport("");
@@ -34,7 +44,7 @@ export function resolveOutcome({ report, repositoryChanged = false, independentV
     if (verification === "fail") {
       return { ...base, outcome: OUTCOMES.NEEDS_REVIEW, reviewRequired: true,
         commitBlockedReason: "independent verification failed despite a clean done/pass report",
-        reasons: ["worker claimed done/pass but independent verification failed"] };
+        reasons: [`worker claimed done/pass but independent verification failed${failureDetail(independentVerification)}`] };
     }
     // verify_regression: reverting just the production files and re-running
     // the SAME verification profile still passed (or came back genuinely
@@ -92,7 +102,7 @@ export function resolveOutcome({ report, repositoryChanged = false, independentV
   if (verification === "fail") {
     return { ...recovery, outcome: OUTCOMES.WORKER_REPORT_INVALID,
       commitBlockedReason: "independent verification failed; recovery cannot promote a failure",
-      reasons: [...recovery.reasons, "independent verification FAILED"] };
+      reasons: [...recovery.reasons, `independent verification FAILED${failureDetail(independentVerification)}`] };
   }
   if (verification === "pass") {
     // A leniently recovered `done` plus a passing independent check is the
@@ -197,8 +207,17 @@ export function policyAdmissionProblems(job, policy) {
   // A refactor meets the regression requirement through its own contract
   // (applyRefactorContract), not the revert check.
   if (policy.require_regression_check && job.verify_regression === false && !job.refactor) problems.push("this repo requires the revert check (policy.require_regression_check in .nomarmy.yml): verify_regression can't be false (a behavior-preserving change can declare refactor: true instead)");
+  // stakes: high (security, data loss, irreversible): the checks a General
+  // could skip on routine work are mandatory, whatever the repo's policy.
+  if (job.stakes === "high") {
+    if (!job.verification && !job.refactor) problems.push("a stakes: high job needs a `verification` profile: its result is only as good as the tests that prove it");
+    if (job.verify_regression === false && !job.refactor) problems.push("a stakes: high job can't turn the revert check off (verify_regression: false): it's the proof a test catches the change");
+  }
   return problems;
 }
+
+/** The review line every high-stakes job carries, whatever its outcome. */
+export const HIGH_STAKES_NOTE = "HIGH STAKES: accept this only after an independent review: a scout on another vendor (army_role security-analyst or similar) with reviews: <this job id>, or a judge on another vendor. Passing its tests isn't enough on its own; most defects that pass every check are in security, data or deploy-only paths.";
 /**
  * A declared refactor commits only when verification passed and no test
  * file was added, changed or deleted. Mechanical, not the General's call:

package/lib/outcomes.mjs

@@ -2,6 +2,9 @@ import { SCOUT_OUTCOMES, SCOUT_STATUS_BY_OUTCOME } from "./scout.mjs";
 import { DECOMPOSE_STATUS_BY_OUTCOME } from "./decompose.mjs";
 
 export const OUTCOMES = Object.freeze({
+  VERIFIED: "VERIFIED",
+  VERIFICATION_FAILED: "VERIFICATION_FAILED",
+  VERIFICATION_NOT_RUN: "VERIFICATION_NOT_RUN",
   WORKER_DONE: "WORKER_DONE",
   WORKER_PARTIAL: "WORKER_PARTIAL",
   WORKER_BLOCKED: "WORKER_BLOCKED",
@@ -14,6 +17,9 @@ export const OUTCOMES = Object.freeze({
 });
 
 export const COORDINATOR_STATUS_BY_OUTCOME = Object.freeze({
+  [OUTCOMES.VERIFIED]: "complete",
+  [OUTCOMES.VERIFICATION_FAILED]: "failed",
+  [OUTCOMES.VERIFICATION_NOT_RUN]: "incomplete",
   [OUTCOMES.WORKER_DONE]: "complete",
   [OUTCOMES.RECOVERED_SUCCESS]: "complete",
   [OUTCOMES.WORKER_BLOCKED]: "blocked",

package/lib/path-utils.mjs

@@ -0,0 +1,4 @@
+/** Docker, Git, and repository metadata paths are POSIX paths, even on Windows. */
+export function toPosix(value) {
+  return value.replaceAll("\\", "/");
+}

package/lib/podman-health.mjs

@@ -0,0 +1,41 @@
+// Is Podman answering, and when did its VM last start? A job dispatched into
+// a stopped Podman, or running while its VM restarts (resizing it with
+// `nomarmy sandbox --memory`, say), fails with nothing but "openclaw exited
+// 2" unless nomArmy checks. Seen live: two jobs lost to a VM resize.
+
+import { spawnSync } from "node:child_process";
+
+// A loaded machine can take several seconds to answer; 15 seconds keeps a
+// slow Podman from being reported as a stopped one (5 wasn't enough under a
+// load average in the 40s to 80s).
+export const PODMAN_ANSWER_TIMEOUT_MS = 15000;
+const defaultRun = (args) => spawnSync("podman", args, { encoding: "utf8", timeout: PODMAN_ANSWER_TIMEOUT_MS });
+
+/** Why jobs can't start their sandbox right now, or null. */
+export function podmanProblem({ run = defaultRun } = {}) {
+  const r = run(["info", "--format", "{{.Host.Arch}}"]);
+  if (r.status === 0) return null;
+  const why = String(r.stderr || r.error?.message || "").split("\n").find((l) => l.trim()) ?? "no answer";
+  if (r.error?.code === "ETIMEDOUT") {
+    return `Podman didn't answer within ${PODMAN_ANSWER_TIMEOUT_MS / 1000} seconds, so no job was sent. It may be running but starved: check the machine's load (Docker, a local model, other jobs) and retry, or run \`nomarmy sandbox\`. Don't restart Podman while jobs are running; that kills their sandboxes.`;
+  }
+  return `Podman isn't answering (${why.trim().slice(0, 160)}), so no job was sent: its sandbox couldn't start. Start it with \`podman machine start\` (macOS, Windows), then check with \`nomarmy sandbox\`.`;
+}
+
+/** When the Podman VM last started (macOS, Windows), or null where there's no VM. */
+export function podmanVmStartedAt({ run = defaultRun, platform = process.platform } = {}) {
+  if (!["darwin", "win32"].includes(platform)) return null;
+  try {
+    const machines = JSON.parse(run(["machine", "inspect"]).stdout || "[]");
+    const m = machines.find((x) => x.State === "running") ?? machines[0];
+    return m?.LastUp ?? null;
+  } catch { return null; }
+}
+
+/** A job issue when the VM restarted, or stopped, between two readings. */
+export function vmRestartIssue(before, after) {
+  if (!before || before === after) return null;
+  return after
+    ? "the Podman VM restarted during this job, which removed its sandbox: the failure is most likely that, not the work. Re-dispatch once Podman is up (nomarmy sandbox)."
+    : "the Podman VM stopped during this job, which removed its sandbox: the failure is most likely that, not the work. Start it (podman machine start) and re-dispatch.";
+}

package/lib/process.mjs

@@ -73,7 +73,10 @@ export function createProcess(ctx) {
         if (ticker) clearInterval(ticker);
         child.kill("SIGTERM");
         const error = new Error(message);
-        error.timedOut = true;
+        // A stop someone asked for (local_worker_stop) isn't a timeout: a
+        // timeout invites a report-recovery call, which would spend exactly
+        // the usage the stop was meant to save.
+        error.timedOut = stopReason !== "stopped";
         if (stopReason) error.stopReason = stopReason;
         reject(error);
       };

package/lib/propose.mjs

@@ -50,21 +50,17 @@ export function buildConfigProposal(evidence) {
   }
 
   // --- environment.python.requirements -------------------------------------
-  // lib/sandbox-images.mjs's ensurePythonImageBuilt only ever `pip install
-  // -r <file>`s whatever this proposes -- it cannot install from
-  // pyproject.toml/poetry/uv directly, so this stays scoped to the same
-  // requirements.txt-shaped evidence handleRequirements records (tooling
-  // name "pip"), never pyproject.toml evidence alone; proposing something
-  // the sandbox builder can't actually act on would be worse than proposing
-  // nothing. A repo whose real Python dependency source is poetry/uv with no
-  // requirements.txt anywhere gets no proposal here -- a distinct, real gap
-  // (the sandbox has no poetry/uv install path at all yet), not this one.
+  // Root project manifests are installed automatically by the Python harness.
+  // Do not override that manager selection with incidental requirements files.
+  const projectSources = new Set(["pyproject.toml", "uv.lock", "poetry.lock"]);
+  const pythonProject = (evidence?.files?.items ?? []).some((f) => projectSources.has(f.path) && !fixturePaths.has(f.path)) ||
+    (evidence?.tooling?.items ?? []).some((t) => projectSources.has(t.source) && !fixturePaths.has(t.source));
   const pipTooling = (evidence?.tooling?.items ?? []).filter((t) => t.name === "pip" && t.category === "package-manager" && t.source);
   for (const t of pipTooling) if (fixturePaths.has(t.source)) excludedFixturePaths.add(t.source);
   const requirementsFiles = [...new Set(pipTooling.filter((t) => !fixturePaths.has(t.source)).map((t) => t.source))].sort();
-  if (requirementsFiles.length === 1) {
+  if (!pythonProject && requirementsFiles.length === 1) {
     proposal.environment = { ...proposal.environment, python: { requirements: requirementsFiles } };
-  } else if (requirementsFiles.length > 1) {
+  } else if (!pythonProject && requirementsFiles.length > 1) {
     // The exact ambiguity this file's own header already treats as a human
     // judgment call for compose files: several requirements.txt-shaped files
     // (app, dev, a sub-package's own) with no single conventional
@@ -88,6 +84,9 @@ export function buildConfigProposal(evidence) {
   if (firstCommand) {
     notes.push(`verification.quick.commands was seeded from a command found in evidence (${firstCommand}) -- confirm this is actually the right check before trusting it.`);
     proposal.verification = { quick: { environment: "none", commands: [firstCommand] } };
+  } else if (pythonProject) {
+    notes.push("Python project detected: pytest is a proposed check using the sandbox venv; confirm the project declares pytest and this is the right test command.");
+    proposal.verification = { quick: { environment: "none", commands: ["pytest"] } };
   } else {
     notes.push("no command was found anywhere in evidence; verification.quick.commands is a fail-loud placeholder -- replace it before this profile is usable.");
     proposal.verification = { quick: { environment: "none", commands: [PLACEHOLDER_COMMAND] } };

package/lib/refusal-retry.mjs

@@ -0,0 +1,16 @@
+import { claimModelRefusalRetry, modelRefusals, recordModelRefusal, recordProbeSuccess } from "./health.mjs";
+
+/** Start eligible one-token probes without waiting for them in the caller. */
+export function retryRefusedModelsInBackground(stateRoot, { probeModel, now = Date.now() } = {}) {
+  if (!probeModel) return;
+  for (const key of Object.keys(modelRefusals(stateRoot))) {
+    if (!claimModelRefusalRetry(stateRoot, key, { now })) continue;
+    const slash = key.indexOf("/");
+    if (slash < 1 || slash === key.length - 1) continue;
+    const provider = key.slice(0, slash), model = key.slice(slash + 1);
+    Promise.resolve().then(() => probeModel({ provider, model, stateRoot })).then((result) => {
+      if (result?.ok) recordProbeSuccess(stateRoot, key, { now });
+      else if (result?.refused) recordModelRefusal(stateRoot, key, result.reason, { now });
+    }).catch(() => { /* An inconclusive probe keeps the refusal and retry timestamp. */ });
+  }
+}