nomarmy 0.1.0-alpha.5 → 0.1.0-alpha.6

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 20+ 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

@@ -25,6 +25,9 @@ import { loadArmy, mergeArmy, describeArmy, readArmyFile, updateArmyInFile, assi
 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";
@@ -190,7 +193,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 +201,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 +216,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.
@@ -1783,6 +1794,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 +2451,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 +2527,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 +2574,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/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);
+});

package/harnesses/mock-oidc/harness.yml

@@ -0,0 +1,19 @@
+name: mock-oidc
+summary: Mock OAuth2 and OIDC discovery and login on an isolated verification network
+detect: []
+image:
+  apt: []
+  run: []
+network: services
+services:
+  - name: mock-oidc
+    image: ghcr.io/navikt/mock-oauth2-server:2.1.10
+    port: 8080
+    env:
+      SERVER_PORT: '8080'
+    health: /default/.well-known/openid-configuration
+env:
+  OIDC_ISSUER: http://mock-oidc:8080/default
+  OAUTH2_ISSUER: http://mock-oidc:8080/default
+verification:
+  oidc: node discovery.test.mjs

package/harnesses/node/README.md

@@ -0,0 +1,53 @@
+# Node harness
+
+Node dependencies and workspaces installed with npm, pnpm, yarn or bun.
+
+## Detection
+
+Matches `package-lock.json`, `npm-shrinkwrap.json`, `pnpm-lock.yaml`, `yarn.lock`, `bun.lock` or `bun.lockb` at the root or in discovered package directories.
+
+## Installed today
+
+Installs dependencies as the `node` user under `/deps` at image build time, on Node 24 / Debian bookworm:
+
+- npm: `npm ci --no-audit --no-fund` (unchanged).
+- pnpm: Corepack and `pnpm install --frozen-lockfile`.
+- Yarn classic: Corepack and `yarn install --frozen-lockfile`.
+- Yarn Berry: detected by `.yarnrc.yml` or lockfile `__metadata`; `YARN_NODE_LINKER=node-modules yarn install --immutable`.
+- Bun: installed globally at build time, then `bun install --frozen-lockfile`.
+
+Corepack respects `packageManager` in the manifest. Without a pin, Yarn defaults to classic or current stable Berry according to detection. Failed installs leave `.nomarmy-npm-ci-failed` for npm or `.nomarmy-<manager>-install-failed` for other managers (`yarn-berry` for Berry).
+
+A manifest's `workspaces` array (or `workspaces.packages`) or `pnpm-workspace.yaml` causes one install at that workspace root. Member manifests are copied at their relative paths, including members without their own lockfile; workspace members are not installed twice. Workspace globs support `*`, `**`, `?`, brace alternatives and exclusions. Non-workspace packages retain separate installs.
+
+Root dependencies resolve through `/node_modules`; workspace roots and members also receive worktree links into `/deps`, preserving pnpm's relative store links. The root binary PATH remains `/deps/node_modules/.bin`. Copied manifests, lockfiles and workspace/config files participate in the image tag.
+
+Private registries use operator-local build secrets; see the configuration and Yarn Berry limitation below.
+
+## Verification and network
+
+Proposes `npm 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.
+
+## 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.
+npm, pnpm, Yarn Classic and bun read the mounted `.npmrc` as node (uid 1000). Credentialed Yarn Berry builds are currently rejected because Berry does not read `.npmrc`.
+
+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/node/harness.yml

@@ -0,0 +1,18 @@
+name: node
+summary: Node dependencies and workspaces installed with npm, pnpm, yarn or bun
+detect:
+  - lockfile: package-lock.json
+  - lockfile: npm-shrinkwrap.json
+  - lockfile: pnpm-lock.yaml
+  - lockfile: yarn.lock
+  - lockfile: bun.lock
+  - lockfile: bun.lockb
+after: []
+image:
+  builtin: node
+verification:
+  quick: npm test
+artifacts: []
+requires: {}
+network: none
+docs: README.md

package/harnesses/python/README.md

@@ -0,0 +1,46 @@
+# Python harness
+
+Python dependencies from uv, Poetry, pyproject, or requirements files.
+
+## Detection
+
+Matches `uv.lock`, `poetry.lock`, `pyproject.toml`, or `requirements.txt` at the repository root. Explicit `environment.python.requirements` in `.nomarmy.yml` wins; otherwise the install precedence is uv.lock, poetry.lock (or `[tool.poetry]`), `[project]` in pyproject.toml, then requirements.txt.
+
+## Installed dependencies
+
+Installs Python 3, pip, venv, and build-essential alongside the Node 24 base. Dependency downloads happen at image build time, not in the offline sandbox.
+
+- **uv:** installs uv and runs `uv sync --frozen --no-install-project --all-groups`, including dev groups, from the copied pyproject.toml and uv.lock.
+- **Poetry:** installs Poetry and runs `poetry install --no-root --no-interaction` from pyproject.toml and poetry.lock when present. Adds `--with dev` only when a Poetry dev group exists. Legacy dev dependencies follow Poetry's default behavior.
+- **Plain pyproject:** uses Python's TOML parser to install `[project].dependencies` and optional `test`, `tests`, and `dev` dependencies with pip, without installing the project itself. A lockfile makes dependency resolution reproducible; unlocked pyproject dependencies may resolve differently on rebuild.
+- **Requirements:** retains the existing system `pip3 install --no-cache-dir --break-system-packages` path. Uses requirements.txt by default; set `environment.python.requirements` to select other or multiple files. Explicit requirements also activate composition without a registry detect match.
+
+The project-manager paths share `/deps/python/.venv`. `VIRTUAL_ENV` is set, and its bin directory comes first in both the image PATH and worker exec PATH. Install failures leave `/deps/python/.nomarmy-<manager>-install-failed` (uv, poetry, or pyproject) instead of failing the image build. Copied manifests and lockfiles are hashed into the image tag. Local/path dependencies and workspace members not included in the root metadata context may require an explicit requirements configuration.
+
+## Verification and network
+
+The registry proposes `python3 -m unittest discover` as the `quick` profile. Config proposals use test commands found in evidence, or suggest `pytest` for project manifests; review that pytest is declared and appropriate. Network level: `none`. Matched harnesses compose the sandbox image used by workers and verification. Verification profiles are proposals; the registry does not change job profiles or network access.
+
+## 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.
+pip uses `/etc/pip.conf`; for uv or Poetry use `pip: { netrc: ~/.netrc }` and credential-free index/source URLs in project metadata. The secret is mounted only for the root-owned install RUN, including venv installs.
+
+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.