nomarmy 0.1.0-alpha.5 → 0.1.0-alpha.7

package/README.md

@@ -12,7 +12,7 @@
 
 ## TL;DR
 
-1. **Have** Git, Node 20+ and [Podman](https://podman.io) (on macOS: `brew install podman && podman machine init && podman machine start`).
+1. **Have** Git, Node 24.16+ (or 26.1+; OpenClaw, which nomArmy installs, needs it) and [Podman](https://podman.io) (on macOS: `brew install podman && podman machine init --memory 8192 && podman machine start`; Podman's 2 GiB default is too small for nomArmy's sandboxes).
 2. **Install and set up:**
    ```bash
    npm install -g nomarmy@alpha
@@ -67,6 +67,7 @@ Around that core: **agents** say where a job can run, the **army** says which ro
 | [Agents and the army](https://github.com/rayson-tech/nomarmy/blob/main/docs/agents-and-army.md) | Where a job can run, who does what, usage limits, picking an agent |
 | [`/feature` runs](https://github.com/rayson-tech/nomarmy/blob/main/docs/feature-runs.md) | A feature end to end, and watching what nomArmy is doing |
 | [Your repository](https://github.com/rayson-tech/nomarmy/blob/main/docs/your-repo.md) | `.nomarmy.yml`, verification, languages and dependencies, what nomArmy checks |
+| [Harnesses](https://github.com/rayson-tech/nomarmy/blob/main/docs/harnesses.md) | Ecosystem registry, detection, network levels, and requirements |
 | [Configuration](https://github.com/rayson-tech/nomarmy/blob/main/docs/configuration.md) | Settings, swapping the local model, sizing, admission |
 | [Reference](https://github.com/rayson-tech/nomarmy/blob/main/docs/reference.md) | Every CLI command and MCP tool |
 | [Security posture](https://github.com/rayson-tech/nomarmy/blob/main/docs/security.md) | What the sandbox holds back, and the one exception |
@@ -88,9 +89,10 @@ A worker gets a writable git worktree inside a Podman sandbox and nothing else:
 | Agents: api keys | Live-verified with xAI; other providers built to OpenClaw's documented interface |
 | Agents: subscriptions | ChatGPT (Codex) and Muse Code sandboxed and live-verified; Claude live-verified, but its tools run on the host (scout and review by default) |
 | The army and `/feature` | Driven by a real Claude Code General across three runs, about 18 implement jobs |
-| Go, Rust, Python and Node repos | Dependency images live-verified for Python and Node (npm); Go and Rust toolchains live-verified |
-| Disposable per-job services (Postgres, mocks) | Not built |
-| Browser/E2E testing inside a nom | Not built |
+| Go, Rust, Python and Node repos, and mixed ones | Harness images live-verified: Go modules and Rust crates prefetched; npm, pnpm, yarn, bun and workspaces; pip, pyproject, uv and poetry |
+| Fake services beside the app (mock login server, mock APIs) | Live-verified on a private network with no route out (the `services` harness level) |
+| Browser tests (Playwright + Chromium) | Live-verified offline, with screenshots and traces kept as job evidence |
+| Private registries and a verification-only network allowlist | Live-verified; each passed an independent security review |
 
 What we've learned from real runs, including where delegating pays and where it doesn't, is in [docs/findings.md](https://github.com/rayson-tech/nomarmy/blob/main/docs/findings.md).
 
@@ -101,7 +103,7 @@ What we've learned from real runs, including where delegating pays and where it
 - **Claude subscription token counts** come from the Claude CLI's own session log, since OpenClaw sees only the final reply. Totals include cache reads and writes, which make up most of an agent's prompt; each part is also kept separately.
 - **Test-workaround detection is a flag, not a verdict**: a legitimate new skip still gets flagged.
 - **Deploy-time failures need your own check.** See [Add a check for what unit tests can't see](https://github.com/rayson-tech/nomarmy/blob/main/docs/your-repo.md#nomarmyyml).
-- **Node dependencies install only from npm lockfiles**, one per package (no workspaces, yarn, pnpm or bun yet), and only from the public registry: the image build has no credentials for a private one.
+- **Node private registries are not supported yet**: npm, pnpm, yarn and bun lockfiles and workspaces are supported, but the image build has no credentials for private registries (dependency plan step 8).
 - **Verification needing services** (a database, a mock server) reports `not_run` instead of running without them. The compose parser doesn't resolve YAML anchors.
 - **Same-host sandboxes**: the MCP server, OpenClaw and every job's sandbox run on the machine with the coordinator. Only the model can be elsewhere (an agent, or [a shared model server](https://github.com/rayson-tech/nomarmy/blob/main/docs/install.md#a-shared-model-server)).
 

package/bin/nomarmy.mjs

@@ -18,13 +18,17 @@ import { buildConfigProposal } from "../lib/propose.mjs";
 import { detectHardware } from "../lib/hardware.mjs";
 import { readGGUFMetadata, resolveModelPath, totalSplitBytes } from "../lib/gguf.mjs";
 import { recommend, customRecommendation, evaluateConfig, bytesPerKvElementForCacheTypes, MIN_CONTEXT_PER_NOM } from "../lib/sizing.mjs";
-import { connectClaude, connectCodex, connectCursor, cursorAlreadyConnected, deriveWorkerModelEnv } from "../lib/connect.mjs";
+import { connectClaude, connectCodex, connectCursor, cursorAlreadyConnected, deriveWorkerModelEnv, defaultInstallDir } from "../lib/connect.mjs";
+import { compareVersions, readPackageVersion, readInstallVersions } from "../lib/install-freshness.mjs";
 import { ID_RE, AUTH_ENV_NAME_RE, OPENCLAW_PROVIDER_ID_RE, openclawProviderId, isNativeProviderType } from "../lib/dispatch-schema.mjs";
 import { loadAgents, readAgentsFile, writeAgentsFile, agentsConfigPath, apiAgentAsPoolEntry, describeAgent as describeAgentLabel, agentRunsToolsOnHost, agentProviderId, AGENT_KINDS, API_PROVIDER_TYPES, RESERVED_AGENT_NAMES, BUILTIN_LOCAL_AGENT } from "../lib/agents.mjs";
 import { loadArmy, mergeArmy, describeArmy, readArmyFile, updateArmyInFile, assignRoleInFile, parseTargetSpec, armyLayerPath, globalConfigDir, DEFAULT_ARMY, ARMY_PHASES, LOCAL_CONFIG_FILENAME } from "../lib/army.mjs";
 import { parseLlamaUrl } from "../lib/execution.mjs";
 import { setupSteps, formatSetupSteps, runSetupPlaybook } from "../lib/setup-steps.mjs";
 import { readUsageSnapshots } from "../lib/usage-limits.mjs";
+import { pickMachine, planResize } from "../lib/sandbox-vm.mjs";
+import { MIN_PODMAN_VM_MB } from "../lib/doctor.mjs";
+import { liveLeases } from "../lib/slots.mjs";
 import { ensureProviderConfig } from "../lib/openclaw-config.mjs";
 import { recordProbeSuccess } from "../lib/health.mjs";
 import { pruneJobRuntime } from "../lib/prune.mjs";
@@ -112,8 +116,9 @@ Usage: nomarmy <command> [options]
                                       registration (never done silently)
                   --restart-inference with --json, also stop/start local
                                       inference (never done silently)
-  update          Pull the latest nomArmy code and re-sync the installed
-                  MCP copy (fast-forward only; refuses on local changes).
+  update          Update nomArmy and reconnect your coordinators: installs
+                  npm's latest alpha, or for a git checkout pulls (fast-forward
+                  only; refuses on local changes). Then restart open sessions.
   agents <list|add|update|remove>
                   Every account a job can run on, in one list:
                   ~/.config/nomarmy/agents.yml (or NOMARMY_CONFIG_DIR).
@@ -190,7 +195,7 @@ Usage: nomarmy <command> [options]
                             which agent the General is, in --global
                             (default) or --local
   config paths    where agents.yml and the three army layers live
-  jobs [--watch|--events|--prune] [--interval N] [--older-than DAYS]
+  jobs [--watch|--events|--prune|--wait <jobId>] [--interval N] [--older-than DAYS]
                   what's running across every session (agent, model, phase,
                   last tool call, files changed, heartbeat) and what just
                   finished; --watch redraws every N seconds (default 3);
@@ -198,7 +203,9 @@ Usage: nomarmy <command> [options]
                   finish (for Claude Code's background monitor; --json for
                   JSON lines); --prune removes the bulky runtime data
                   from finished jobs older than DAYS (default 2), keeping
-                  their records, reports and any retained worktree
+                  their records, reports and any retained worktree;
+                  --wait <jobId> [--timeout <seconds>] blocks for one job
+                  to finish (default timeout 1800; --json is supported)
   health          check what's likely to break a run before it does:
                   expiring logins, an outdated OpenClaw or plugin, roles
                   that can't be dispatched, an unloadable agents.yml,
@@ -211,6 +218,12 @@ Usage: nomarmy <command> [options]
                   (Re-)register the MCP server with one or more coordinators.
                   With no target and not --json, prompts an interactive
                   multi-select instead.
+  sandbox         The Podman VM every sandbox shares (macOS, Windows): its
+                  memory, disk and images. --memory <GiB> resizes it (stops,
+                  sets, restarts; refused while jobs run); --prune removes
+                  images no container uses (nomArmy rebuilds its own on
+                  demand); --repair restores missing subordinate ID
+                  ranges (refused while jobs run); --yes skips confirming
   start <profile> Start local inference (wraps scripts/start-inference.sh).
   stop <profile>  Stop local inference (wraps scripts/stop-inference.sh).
   uninstall       Remove the MCP registration and install directory.
@@ -1631,14 +1644,9 @@ function git(args) {
  */
 async function cmdUpdate() {
   const say = (s) => { if (!json) console.log(s); };
-  // Installed from npm: there's no checkout to pull. npm updates the
-  // package; connect resyncs the copy each coordinator runs.
-  if (!fs.existsSync(path.join(nomarmyRoot, ".git"))) {
-    const how = "npm install -g nomarmy@alpha && nomarmy connect";
-    if (json) return out({ error: "installed from npm, not a git checkout", fix: how });
-    console.log(`This nomArmy was installed from npm, so there's nothing to pull. Update with:\n  ${how}`);
-    return;
-  }
+  // Installed from npm: npm updates the package, then connect resyncs the
+  // copy each coordinator runs.
+  if (!fs.existsSync(path.join(nomarmyRoot, ".git"))) return updateFromNpm();
   const status = git(["status", "--porcelain"]);
   if (status) {
     if (json) { out({ error: "working tree is not clean; refusing to pull over local changes", status }); process.exit(1); }
@@ -1693,6 +1701,45 @@ async function cmdUpdate() {
   console.log(c.yellow("\nThe MCP server is a per-session child process: every open Claude Code / Codex / Cursor session needs a restart to pick this up, not just this one."));
 }
 
+// The coordinators nomArmy is registered with. Cursor has no CLI to probe,
+// so it counts when its own config already lists nomArmy.
+function connectedTargets() {
+  return [commandExists("claude") && "claude", commandExists("codex") && "codex", cursorAlreadyConnected() && "cursor"].filter(Boolean);
+}
+
+async function updateFromNpm() {
+  const current = readPackageVersion(nomarmyRoot);
+  let latest = null;
+  try { latest = execFileSync("npm", ["view", "nomarmy", "dist-tags.alpha"], { encoding: "utf8", timeout: 20000 }).trim(); } catch { /* offline */ }
+  if (!latest) {
+    const fix = "npm install -g nomarmy@alpha && nomarmy connect claude";
+    if (json) { out({ error: "could not read nomarmy's latest release from npm", fix }); process.exit(1); }
+    console.log(c.red("Couldn't reach npm to find nomArmy's latest release.") + ` Update by hand:\n  ${fix}`);
+    process.exit(1);
+  }
+  const { copyVersion } = readInstallVersions(defaultInstallDir());
+  const upgrade = compareVersions(current, latest) < 0;
+  const staleCopy = !copyVersion || compareVersions(copyVersion, upgrade ? latest : current) < 0;
+  if (!upgrade && !staleCopy) {
+    if (json) return out({ updated: false, version: current, reason: "already up to date" });
+    console.log(c.green(`✓ nomArmy ${current} is the latest, and your coordinators run it.`));
+    return;
+  }
+  if (upgrade) {
+    if (!json) console.log(c.bold(`🍪 Updating nomArmy ${current} → ${latest}\n`));
+    execFileSync("npm", ["install", "-g", `nomarmy@${latest}`, "--no-audit", "--no-fund"], { stdio: json ? "ignore" : "inherit" });
+  }
+  // A child process, so the reconnect runs the code just installed rather
+  // than the old code this process loaded.
+  const targets = connectedTargets();
+  if (targets.length) {
+    if (!json) console.log(`\nReconnecting ${targets.join(", ")}...`);
+    execFileSync(process.execPath, [path.join(nomarmyRoot, "bin", "nomarmy.mjs"), "connect", ...targets, ...(json ? ["--json"] : [])], { stdio: json ? "ignore" : "inherit" });
+  }
+  if (json) return out({ updated: upgrade, from: current, version: upgrade ? latest : current, resynced: targets });
+  console.log(c.yellow("\nRestart every open Claude Code, Codex and Cursor session: each keeps the code it started with until then."));
+}
+
 function commandExists(cmd) {
   try { execFileSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" }); return true; }
   catch { return false; }
@@ -1783,6 +1830,77 @@ async function cmdConnect() {
 function runScript(name, args = []) {
   execFileSync("bash", [path.join(nomarmyRoot, "scripts", name), ...args], { cwd: nomarmyRoot, stdio: "inherit" });
 }
+// `nomarmy sandbox`: see lib/sandbox-vm.mjs.
+async function cmdSandbox() {
+  const stateRoot = process.env.NOMARMY_AGENT_STATE || path.join(os.homedir(), ".local", "share", "nomarmy-local-agents");
+  const podman = (args, opts = {}) => spawnSync("podman", args, { encoding: "utf8", ...opts });
+  const machine = process.platform === "linux" ? null : pickMachine(podman(["machine", "inspect"]).stdout);
+  let images = null;
+  try {
+    const rows = JSON.parse(podman(["system", "df", "--format", "json"]).stdout || "[]");
+    const row = rows.find((r) => /image/i.test(r.Type ?? ""));
+    if (row) images = { count: row.Total ?? null, size: row.Size ?? null, reclaimable: row.Reclaimable ?? null };
+  } catch { /* podman missing or old */ }
+  const runningJobs = liveLeases(path.join(stateRoot, "leases")).length;
+  const memoryGib = value("memory");
+
+  if (!memoryGib && !flag("prune") && !flag("repair")) {
+    if (json) return out({ platform: process.platform, machine, images, runningJobs, minimumMb: MIN_PODMAN_VM_MB });
+    console.log(c.bold("🍪 nomArmy sandbox"));
+    if (process.platform === "linux") console.log("\nPodman runs natively on Linux: there's no VM to size.");
+    else if (!machine) console.log(c.yellow("\nNo Podman machine found. Run: podman machine init && podman machine start"));
+    else {
+      const low = machine.memoryMb && machine.memoryMb < MIN_PODMAN_VM_MB;
+      console.log(`\nVM ${machine.name} (${machine.state}): ${machine.cpus} CPUs, ${low ? c.red(`${machine.memoryMb / 1024} GiB memory`) : `${machine.memoryMb / 1024} GiB memory`}, ${machine.diskGb} GB disk`);
+      if (low) console.log(c.yellow(`  Too small: worker commands get cut off below ${MIN_PODMAN_VM_MB / 1024} GiB. Fix: nomarmy sandbox --memory 8`));
+    }
+    if (images) console.log(`Images: ${images.count}, ${images.size}${images.reclaimable ? `, ${images.reclaimable} reclaimable (nomarmy sandbox --prune)` : ""}`);
+    console.log(c.dim(runningJobs ? `${runningJobs} nomArmy job(s) running.` : "No nomArmy jobs running."));
+    return;
+  }
+
+  const ask = async (question) => {
+    if (flag("yes")) return true;
+    if (!process.stdin.isTTY) throw new Error(`${question} Re-run with --yes to confirm without a terminal.`);
+    const rl = createInterface({ input, output });
+    try { return await confirm(rl, question, { defaultYes: false }); } finally { rl.close(); }
+  };
+  const runPodman = (args) => {
+    console.log(c.dim(`$ podman ${args.join(" ")}`));
+    const r = podman(args, { stdio: "inherit" });
+    if (r.status !== 0) throw new Error(`podman ${args.join(" ")} failed (exit ${r.status ?? "none"}).`);
+  };
+
+  if (flag("repair")) {
+    // Restore the subordinate ID ranges a Podman machine ships with, only
+    // where they're missing, then let Podman re-read them.
+    if (process.platform === "linux") throw new Error("On Linux, add a range for your user to /etc/subuid and /etc/subgid (e.g. `sudo usermod --add-subuids 100000-1099999 --add-subgids 100000-1099999 $USER`), then run `podman system migrate`.");
+    if (!machine) throw new Error("No Podman machine found. Run: podman machine init && podman machine start");
+    // podman system migrate stops every container, a running job's sandbox included.
+    if (runningJobs > 0) throw new Error(`${runningJobs} nomArmy job(s) are running; the repair restarts Podman's containers and would kill their sandboxes. Run it when they're done.`);
+    const script = 'set -e; restored=0; for f in /etc/subuid /etc/subgid; do if ! grep -q "^$(id -un):" "$f" 2>/dev/null; then echo "$(id -un):100000:1000000" | sudo tee -a "$f" >/dev/null; echo "restored $f"; restored=1; else echo "$f already has a range"; fi; done; if [ "$restored" = 1 ]; then podman system migrate; else echo "nothing to repair"; fi';
+    if (!(await ask(`Restore missing subordinate ID ranges in the ${machine.name} VM and run podman system migrate?`))) { console.log(c.dim("Nothing changed.")); return; }
+    const r = spawnSync("podman", ["machine", "ssh", machine.name, script], { stdio: "inherit" });
+    if (r.status !== 0) throw new Error(`the repair failed (exit ${r.status ?? "none"}).`);
+    console.log(c.green("✓ Done. Check with: nomarmy doctor"));
+    return;
+  }
+
+  if (memoryGib) {
+    const plan = planResize({ gib: memoryGib, machine, hostMemoryMb: os.totalmem() / 1024 / 1024, runningJobs });
+    if (!plan.ok) throw new Error(plan.problems.join("; "));
+    for (const w of plan.warnings) console.log(c.yellow(`⚠ ${w}`));
+    if (!(await ask(`Restart the Podman VM with ${memoryGib} GiB (from ${machine.memoryMb / 1024})?`))) { console.log(c.dim("Nothing changed.")); return; }
+    for (const args of plan.commands) runPodman(args);
+    console.log(c.green(`✓ The Podman VM now has ${memoryGib} GiB.`));
+  }
+  if (flag("prune")) {
+    if (runningJobs > 0) throw new Error(`${runningJobs} nomArmy job(s) are running; prune when they're done.`);
+    if (!(await ask(`Remove every image no container uses${images?.reclaimable ? ` (about ${images.reclaimable})` : ""}? nomArmy rebuilds its own when a job needs them.`))) { console.log(c.dim("Nothing removed.")); return; }
+    runPodman(["image", "prune", "--all", "--force"]);
+  }
+}
+
 async function cmdStart() { console.log(c.bold("🍪 Starting inference...\n")); runScript("start-inference.sh", argv.slice(1)); }
 async function cmdStop() { runScript("stop-inference.sh", argv.slice(1)); }
 function safeDu(dir) {
@@ -2369,6 +2487,66 @@ async function streamJobEvents() {
   }
 }
 
+/** Wait for one job in the shared, cross-session state directory. */
+async function waitForJobCli() {
+  const requested = value("wait");
+  const jobId = requested ? path.basename(requested) : null;
+  const timeoutSeconds = Number(value("timeout", "1800"));
+  if (!jobId || jobId !== requested) {
+    if (json) out({ error: "--wait needs a job id" });
+    else console.error("nomarmy jobs: --wait needs a job id");
+    process.exitCode = 2;
+    return;
+  }
+  if (!Number.isFinite(timeoutSeconds) || timeoutSeconds < 0) {
+    if (json) out({ error: "--timeout must be a non-negative number of seconds" });
+    else console.error("nomarmy jobs: --timeout must be a non-negative number of seconds");
+    process.exitCode = 2;
+    return;
+  }
+  const jobDir = path.join(jobsRootDir(), jobId);
+  const lease = path.join(agentStateRoot(), "leases", `${jobId}.json`);
+  if (!fs.existsSync(jobDir) && !fs.existsSync(lease)) {
+    if (json) out({ error: `unknown job id: ${jobId}` });
+    else console.error(`nomarmy jobs: unknown job id: ${jobId}`);
+    process.exitCode = 2;
+    return;
+  }
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  for (;;) {
+    const status = readJsonSafe(path.join(jobDir, "status.json")) ?? {};
+    const meta = readJsonSafe(path.join(jobDir, "metadata.json")) ?? {};
+    if (status.state === "finished" || meta.outcome) {
+      const issues = Array.isArray(meta.issues) ? meta.issues : Array.isArray(status.issues) ? status.issues : [];
+      const result = {
+        jobId,
+        outcome: meta.outcome ?? status.outcome ?? null,
+        coordinatorStatus: meta.coordinatorStatus ?? status.coordinatorStatus ?? null,
+        branch: meta.branch ?? status.branch ?? null,
+        commit: meta.commit?.sha ?? meta.commit ?? status.commit?.sha ?? status.commit ?? null,
+        issues,
+      };
+      if (json) out(result);
+      else {
+        const firstIssue = issues[0];
+        const issueText = firstIssue == null ? null : typeof firstIssue === "string" ? firstIssue : firstIssue.message ?? JSON.stringify(firstIssue);
+        console.log([result.jobId, result.outcome ?? "unknown", result.coordinatorStatus ?? "unknown",
+          result.branch ? `branch=${result.branch}` : null, result.commit ? `commit=${result.commit}` : null,
+          issueText ? `issue=${issueText}` : null].filter(Boolean).join(" "));
+      }
+      process.exitCode = result.coordinatorStatus === "complete" ? 0 : 1;
+      return;
+    }
+    if (Date.now() >= deadline) {
+      if (json) out({ error: `timed out waiting for job ${jobId}` });
+      else console.error(`nomarmy jobs: timed out waiting for job ${jobId}`);
+      process.exitCode = 2;
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(2000, Math.max(1, deadline - Date.now()))));
+  }
+}
+
 /**
  * `nomarmy jobs --prune [--older-than DAYS]`: remove runtime/ (per-job npm
  * cache, harness state such as Codex's, OpenClaw's transcript) from
@@ -2385,6 +2563,7 @@ function pruneJobRuntimeCli() {
 }
 
 async function cmdJobs() {
+  if (flag("wait")) return waitForJobCli();
   if (flag("events")) return streamJobEvents();
   if (flag("prune")) return pruneJobRuntimeCli();
   if (json) return out(collectJobs());
@@ -2431,7 +2610,7 @@ async function cmdStatusline() {
   process.stdout.write(`${statusLineText({ session })}\n`);
 }
 
-const commands = { scan: cmdScan, validate: cmdValidate, sizing: cmdSizing, init: cmdInit, setup: cmdSetup, install: cmdInstall, model: cmdModel, agents: cmdAgents, army: cmdArmy, jobs: cmdJobs, statusline: cmdStatusline, health: cmdHealth, config: cmdConfig, update: cmdUpdate, connect: cmdConnect, start: cmdStart, stop: cmdStop, uninstall: cmdUninstall, help: () => usage(0) };
+const commands = { scan: cmdScan, validate: cmdValidate, sizing: cmdSizing, init: cmdInit, setup: cmdSetup, install: cmdInstall, model: cmdModel, agents: cmdAgents, army: cmdArmy, jobs: cmdJobs, statusline: cmdStatusline, health: cmdHealth, config: cmdConfig, update: cmdUpdate, connect: cmdConnect, sandbox: cmdSandbox, start: cmdStart, stop: cmdStop, uninstall: cmdUninstall, help: () => usage(0) };
 // doctor command
 async function cmdDoctor() {
   // Import lazily to avoid circular dependencies

package/docker/Dockerfile.go

@@ -9,15 +9,17 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 # (verified live: apt installed 1.19 here while go.dev's stable was 1.27) --
 # same reasoning as using rustup instead of apt for Rust in Dockerfile.rust.
 # Pinned, not "latest", for a reproducible build; bump GO_VERSION by hand
-# periodically against https://go.dev/dl/.
+# periodically against https://go.dev/dl/, with both SHA256 values from
+# https://go.dev/dl/?mode=json.
 ENV GO_VERSION=1.27.1
 RUN ARCH="$(dpkg --print-architecture)" \
     && case "$ARCH" in \
-         amd64) GOARCH=amd64 ;; \
-         arm64) GOARCH=arm64 ;; \
+         amd64) GOARCH=amd64; SHA256=63d339f0da5ab53635a56f2490a7984dfe12dfcff22ad749f63edaf590168445 ;; \
+         arm64) GOARCH=arm64; SHA256=3450b45a3f9ee8568792736a5c5e70a1f2e9b36c35a8f74958c03e51d7d92bec ;; \
          *) echo "unsupported architecture for Go install: $ARCH" >&2; exit 1 ;; \
        esac \
     && curl -fsSL "https://go.dev/dl/go${GO_VERSION}.linux-${GOARCH}.tar.gz" -o /tmp/go.tgz \
+    && echo "${SHA256}  /tmp/go.tgz" | sha256sum -c - \
     && tar -C /usr/local -xzf /tmp/go.tgz \
     && rm /tmp/go.tgz
 ENV PATH="/usr/local/go/bin:${PATH}"

package/docker/Dockerfile.rust

@@ -14,6 +14,21 @@ USER node
 ENV RUSTUP_HOME=/home/node/.rustup
 ENV CARGO_HOME=/home/node/.cargo
 ENV PATH="${CARGO_HOME}/bin:${PATH}"
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable
+# rustup-init is pinned by version and checksum instead of piping
+# sh.rustup.rs into sh; rustup then verifies the toolchain it downloads.
+# Bump RUSTUP_VERSION and both hashes together, from
+# https://static.rust-lang.org/rustup/archive/<version>/<target>/rustup-init.sha256.
+ENV RUSTUP_VERSION=1.29.1
+RUN ARCH="$(dpkg --print-architecture)" \
+    && case "$ARCH" in \
+         amd64) TARGET=x86_64-unknown-linux-gnu; SHA256=dda7234360b7f578ca8b0ddcb80145646fa61a67c1720a5abc7051b35c9fcb71 ;; \
+         arm64) TARGET=aarch64-unknown-linux-gnu; SHA256=15f6e4ce9f583b929c996c91562bad6d4454f3281de858b02cdfdef615fac433 ;; \
+         *) echo "unsupported architecture for Rust install: $ARCH" >&2; exit 1 ;; \
+       esac \
+    && curl --proto '=https' --tlsv1.2 -fsSL "https://static.rust-lang.org/rustup/archive/${RUSTUP_VERSION}/${TARGET}/rustup-init" -o /tmp/rustup-init \
+    && echo "${SHA256}  /tmp/rustup-init" | sha256sum -c - \
+    && chmod +x /tmp/rustup-init \
+    && /tmp/rustup-init -y --no-modify-path --profile minimal --default-toolchain stable \
+    && rm /tmp/rustup-init
 WORKDIR /workspace
 CMD ["sleep", "infinity"]

package/harnesses/_template/README.md

@@ -0,0 +1,27 @@
+# Harness name
+
+Write a short summary of what this harness provides.
+
+## Detection
+
+List the markers and packages that match. Explain any `after` layers.
+
+## Installed today
+
+List tools and dependencies, versions, build commands, and known gaps.
+
+## Verification and network
+
+Document each proposed profile. Declare the lowest network level needed.
+For allowlist verification, document operator opt-in and dedicated test tenants
+with throwaway credentials, never production. Workers always remain offline.
+This registry does not enable services or allowlist networking yet.
+
+## Requirements and artifacts
+
+Explain memory, shared memory, KVM, and artifact globs, if any.
+
+## Fixture
+
+Add a tiny repository under `fixture/`. Describe how to verify it and its
+expected results. Keep credentials and host-specific paths out of fixtures.

package/harnesses/_template/harness.yml

@@ -0,0 +1,26 @@
+# Copy this folder to harnesses/<name>. Underscore folders are ignored.
+# name: example-harness # Required kebab-case name, equal to the folder name.
+# summary: Short description of what this installs.
+# detect: # Any matching rule applies. Paths are relative to the repo.
+#   - file: example.config.json
+#   - package: example-package # A Node dependency in a discovered package.json.
+#   - lockfile: example.lock
+# after: [node] # Existing harnesses that must precede this one.
+# image: # Choose declarative apt/run OR builtin, never both.
+#   apt: [example-package] # OS packages installed at image build time.
+#   run: ["example-install --frozen"] # Build commands, not worker commands.
+#   # builtin: node # Install logic implemented in lib/.
+# verification: # Proposed profiles mapped to commands or command lists.
+#   quick: example-test
+#   full: [example-lint, example-test]
+# artifacts: [test-results/**] # Repository-relative artifact globs.
+# requires: # Optional resource requirements.
+#   memoryMb: 1024
+#   shmMb: 512
+#   kvm: false
+# network: none # Default; services and allowlist are future verification levels.
+# services: [] # Service names; omit entirely for network none, even if empty.
+# suggestedRole: # Optional role suggestion.
+#   name: example-qa
+#   description: Runs the example suite.
+# docs: README.md # Default; path relative to this harness folder.

package/harnesses/browser-playwright/README.md

@@ -0,0 +1,35 @@
+# Playwright browser harness
+
+Installs Chromium and its OS dependencies using the repository's installed
+@playwright/test version, after the Node dependency layer. Commit a supported
+Node lockfile. Root and discovered nested packages are supported; browsers live
+in /ms-playwright and are readable by the node user. Installation failure leaves
+a .nomarmy-playwright-install-failed marker in /ms-playwright.
+
+Select the browser verification profile (npx playwright test) in .nomarmy.yml:
+
+```yaml
+verification:
+  browser:
+    commands: [npx playwright test]
+    environment: none
+```
+
+Allow at least 1024 MB memory. nomArmy's verification container allocates 512 MB
+/dev/shm (or the largest shared-memory requirement of the matched harnesses).
+For OpenClaw-managed worker sandboxes, unless OpenClaw exposes a shm setting,
+launch Chromium with --disable-dev-shm-usage via Playwright launchOptions, as
+the fixture does.
+
+The fixture opens its own static HTML with file://: the test needs no network.
+Install its npm dependencies and Chromium before running offline.
+
+Screenshots, traces and reports under test-results/** and playwright-report/**
+become job evidence under artifacts/, listed in verification.artifacts.
+Collection is limited to 200 files and 50 MB; a cap is reported in verification.
+Most of the time the General checks the UI itself after merging. This harness
+is for repositories with a real end-to-end suite as their gate.
+
+## Running the fixture
+
+`fixture/` has no lockfile on purpose: with one, nomArmy's own repository would match this harness and every nomArmy job would build Chromium into its image. To try it, copy the folder somewhere, run `npm install --package-lock-only` there (with network), commit, and verify it with the `browser` profile. Checked this way: headless Chromium passes offline, and the screenshot and trace land in the job's `artifacts/`.

package/harnesses/browser-playwright/fixture/package.json

@@ -0,0 +1 @@
+{"private":true,"type":"module","scripts":{"test":"playwright test"},"devDependencies":{"@playwright/test":"1.55.1"}}

package/harnesses/browser-playwright/fixture/page.html

@@ -0,0 +1 @@
+<!doctype html><title>Offline fixture</title><h1>Browser ready</h1>

package/harnesses/browser-playwright/fixture/page.spec.js

@@ -0,0 +1,5 @@
+import { test, expect } from '@playwright/test';
+test('opens local fixture', async ({ page }) => {
+  await page.goto(new URL('./page.html', import.meta.url).href);
+  await expect(page.getByRole('heading')).toHaveText('Browser ready');
+});

package/harnesses/browser-playwright/fixture/playwright.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from '@playwright/test';
+export default defineConfig({
+  testDir: '.',
+  testMatch: 'page.spec.js',
+  reporter: [['html', { open: 'never' }]],
+  use: { browserName: 'chromium', screenshot: 'on', trace: 'on',
+    launchOptions: { args: ['--disable-dev-shm-usage'] } },
+});

package/harnesses/browser-playwright/harness.yml

@@ -0,0 +1,18 @@
+name: browser-playwright
+summary: Offline Chromium end-to-end tests with the repository's Playwright version
+detect:
+  - package: '@playwright/test'
+  - file: playwright.config.ts
+  - file: playwright.config.js
+  - file: playwright.config.mjs
+after: [node]
+image:
+  builtin: playwright
+verification:
+  browser: npx playwright test
+artifacts: [test-results/**, playwright-report/**]
+requires:
+  memoryMb: 1024
+  shmMb: 512
+network: none
+docs: README.md

package/harnesses/go/README.md

@@ -0,0 +1,45 @@
+# Go harness
+
+Go toolchain with prefetched modules for offline verification.
+
+## Detection
+
+Matches `go.mod` or `go.work` at the repository root.
+
+## Installed today
+
+Installs Go 1.27.1 from the upstream tarball for amd64 or arm64, on the Node 24 Debian bookworm base with Python 3 and pip. Sets GOPATH for the node user.
+
+At image build, copies root `go.mod` and `go.sum` (when present), plus `go.work`, `go.work.sum` and each repository-contained workspace module’s manifests. Runs `go mod download` as node into the default module cache, `/home/node/go/pkg/mod`. Repositories with `vendor/` skip this download. A failed download leaves `/deps/go/.nomarmy-go-mod-download-failed` without failing the image build. Runtime sets `GOPROXY=off` and `GOSUMDB=off`; no `GOFLAGS` override is set, preserving Go’s default module behavior. Copied metadata is hashed into the image tag, so dependency changes rebuild the cache. The layer composes with Node dependencies in mixed repositories.
+
+## Verification and network
+
+Proposes `go test ./...` as the `quick` profile. Network level: `none`. Matched harnesses compose the sandbox image used by workers and verification. The verification profile is a proposal; the registry does not change job profiles or network access.
+
+## Remaining limitations
+
+Private modules and registries use the build-only credentials described below; no credentials are copied into the image. A failure marker means the cache may be incomplete and offline verification can still fail. Workspace modules and local replacements outside the repository are not copied.
+
+## Requirements and artifacts
+
+No additional resource requirements or artifact globs are declared.
+
+
+## Private registries
+
+Use `registries:` in the gitignored `.nomarmy.local.yml` only; the committed
+config rejects it. Values are host credential **file paths**, never tokens.
+Use `go: { netrc: ~/.netrc, private: "github.com/acme/*" }`. Only `go mod download` receives the node-owned netrc plus RUN-local GOPRIVATE and GONOSUMDB; vendored builds need no download mount.
+
+Credentials stay on the host and enter Podman only as build-secret mounts;
+no credential files are copied into the context or passed to sandbox jobs.
+Use a **read-only, least-privilege token** and reviewed dependencies. Secrets
+are accessible to install code during that RUN, so malicious packages are not
+made safe by a mount. Credential rotation invalidates both tag and install
+cache. Credentialed install output/build-error details are withheld.
+
+See [Private registries](../../docs/your-repo.md#private-registries) for the
+configuration and required manual canary check: inspect `podman history
+--no-trunc`, image configuration, the exported filesystem **and every saved
+image layer**, plus failure logs/job records, for absent secret bytes. Unit
+tests stub Podman; live isolation needs independent security review.

package/harnesses/go/harness.yml

@@ -0,0 +1,14 @@
+name: go
+summary: Go toolchain with prefetched modules for offline verification
+detect:
+  - file: go.mod
+  - file: go.work
+after: []
+image:
+  builtin: go
+verification:
+  quick: go test ./...
+artifacts: []
+requires: {}
+network: none
+docs: README.md

package/harnesses/mock-oidc/README.md

@@ -0,0 +1,31 @@
+# Mock OIDC
+
+Enable explicitly in your repository's `.nomarmy.yml` (there are no detection rules):
+
+```yaml
+harnesses: [mock-oidc]
+verification:
+  auth:
+    commands: [npm test]
+```
+
+Point your application's issuer/discovery configuration at `OIDC_ISSUER` or
+`OAUTH2_ISSUER`, both exported as `http://mock-oidc:8080/default` during nomArmy
+verification. Configure your test client ID, redirect URI and audience to match
+what your application expects; allow HTTP only in this test configuration.
+
+The pinned NAV mock OAuth2 server supplies discovery, signing keys, token and
+mock authorization flows. It is not an Okta/Auth0 tenant: it does not prove real
+identity, MFA, tenant policies, upstream federation or production compatibility.
+Never use real credentials with this fake.
+
+nomArmy pulls the pinned image on the host if missing, then starts it without
+published ports on a per-run `--internal` Podman network. Discovery must return
+2xx within 30 seconds before commands run. Containers and the network are
+removed even if verification fails. Workers remain `--network none`; only
+nomArmy's own verification can reach the fake. Env maps in harness manifests
+are non-secret literals, not secret references or host-environment imports.
+
+`fixture/` is a tiny Node-built-ins-only repository. Run its `quick` profile
+through nomArmy verification. It fetches discovery over the private network;
+it requires no internet or npm packages. It is not a host-side unit test.

package/harnesses/mock-oidc/fixture/.nomarmy.yml

@@ -0,0 +1,4 @@
+harnesses: [mock-oidc]
+verification:
+  quick:
+    commands: [node --test discovery.test.mjs]

package/harnesses/mock-oidc/fixture/discovery.test.mjs

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+test('private mock issuer discovery', async () => {
+  const issuer = process.env.OIDC_ISSUER;
+  assert.equal(issuer, 'http://mock-oidc:8080/default');
+  const response = await fetch(`${issuer}/.well-known/openid-configuration`, {
+    redirect: 'error', signal: AbortSignal.timeout(5000),
+  });
+  assert.equal(response.status, 200);
+  const document = await response.json();
+  assert.equal(document.issuer, issuer);
+  assert.equal(new URL(document.jwks_uri).origin, new URL(issuer).origin);
+  assert.equal(new URL(document.authorization_endpoint).origin, new URL(issuer).origin);
+  assert.equal(new URL(document.token_endpoint).origin, new URL(issuer).origin);
+});