nomarmy 0.1.0-alpha.6 → 0.1.0-alpha.8

package/README.md

@@ -6,20 +6,22 @@
   <a href="https://github.com/rayson-tech/nomarmy/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0"></a>
 </p>
 
-<p align="center"><em>Tiny coders, big appetites for bounded tickets.</em> 🍪</p>
+<p align="center"><em>Every byte verified.</em> 🍪</p>
 
 **Your coding assistant plans; sandboxed workers build; nothing counts until nomArmy has checked it.**
 
+AI coding workers are confident. Their "done, all tests pass" is a claim, not evidence. nomArmy lets your coding assistant (Claude Code, Codex or Cursor) hand work to workers called **noms**, then checks every change itself before anything is committed: the real diff, your tests run in a fresh sandbox, a check that those tests actually catch the change, and a secret scan.
+
 ## TL;DR
 
-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).
+1. **Have** Git, Node 24.16+ (or 26.1+) and [Podman](https://podman.io). On macOS, give Podman 8 GiB: `brew install podman && podman machine init --memory 8192 && podman machine start`.
 2. **Install and set up:**
    ```bash
    npm install -g nomarmy@alpha
    cd your-project
    nomarmy setup
    ```
-   `nomarmy setup` is the playbook. It shows a checklist and runs the next step each time you say yes:
+   `nomarmy setup` is a playbook. It shows a checklist and runs the next step each time you say yes:
    ```text
    ✓ Where models run: hosted
    ✓ Installed: OpenClaw 2026.9.6
@@ -29,34 +31,39 @@
      Check: verify the installation
    Run `nomarmy agents add` now? [Y/n]
    ```
-   In order: pick where models run (API keys and subscriptions for most people), install OpenClaw and the sandbox, add your agents (an API key, or your ChatGPT or Muse Code subscription), put the roles on them, write this repo's `.nomarmy.yml`, then check it all. Stop anytime; `nomarmy setup` picks up where you left off.
-
-   **Want every step spelled out?** [Example setup: Claude Code, Codex and an API key](https://github.com/rayson-tech/nomarmy/blob/main/docs/setup/example.md) walks through a complete setup, command by command.
+   Stop anytime; `nomarmy setup` picks up where you left off. **Want every step spelled out?** [Example setup: Claude Code, Codex and an API key](https://github.com/rayson-tech/nomarmy/blob/main/docs/setup/example.md) goes command by command.
 3. **Use it:** restart Claude Code in the project and ask it to use nomArmy for one small bug that has a test. When that works, try `/feature <what you want built>`.
 
-**Have a GPU or a Mac with plenty of memory?** Choose "a local model" in `nomarmy setup` and workers run on llama.cpp on your own machine: no per-token bill and your code stays home, but you pay in hardware, power and speed, and a model too big for your memory crawls. `nomarmy sizing` tells you what fits; see [Install](https://github.com/rayson-tech/nomarmy/blob/main/docs/install.md#install). A team GPU server works too: [a shared model server](https://github.com/rayson-tech/nomarmy/blob/main/docs/install.md#a-shared-model-server). Codex or Cursor as the coordinator: `nomarmy connect codex cursor`.
+Stuck? `nomarmy doctor` checks the machine and `nomarmy health` checks everything nomArmy runs on. Upgrading later? `nomarmy update`.
 
-Stuck? `nomarmy doctor` checks the machine, and `nomarmy health` checks everything nomArmy runs on.
+## How every byte gets verified
 
-## What it is
+1. Your coding assistant, the **General**, briefs a job: a task, acceptance criteria, and the tests that prove it.
+2. nomArmy creates a git worktree from your branch and runs the nom in a Podman sandbox with no network and no host credentials. (One exception, the Claude subscription: see [Security posture](https://github.com/rayson-tech/nomarmy/blob/main/docs/security.md#security-posture).)
+3. The nom edits, runs tests, and ends with a four-line report: `STATUS`, `TESTS`, `NOT_DONE`, `NOTE`.
+4. nomArmy treats that report as a claim and checks the evidence itself:
+   - reads the real diff from git, not the nom's description of it
+   - runs your verification profile in a fresh sandbox
+   - reverts the production change and reruns the tests: a test that still passes proves nothing, so the job goes to review instead of being committed
+   - blocks on secrets, and flags tests made to pass (new skips, stubbed imports) and code nothing calls
+5. Only then does it commit, on the nom's own branch. It never merges into yours: reviewing and integrating stay with the General, and with you.
 
-Your coding assistant (Claude Code, Codex or Cursor) stays in charge as the **General**: it decides what gets built and whether the result is acceptable. The work goes to **noms**, workers that implement, test and repair in their own git worktree and sandbox, on an API key, your own ChatGPT or Muse Code subscription, or a local model. nomArmy owns everything in between: worktrees, git, sandboxes, verification, and the evidence that decides whether work is accepted.
+Failing verification stays failed, unconditionally. A malformed report isn't automatically a failure: if the repository changed, nomArmy verifies independently and may recover the work. And the checks aren't the General's to waive: a repo's `.nomarmy.yml` policy (on by default for new repos) makes verification and the revert check mandatory for every job.
 
-**What you get is work you don't have to take on faith**, not cheaper work. Delegating costs the General tokens too: briefing and reviewing. On small, already-diagnosed tickets we measured 4 to 8 times more of the General's tokens than fixing the bug directly, and break-even at roughly 150 lines of context a fix needs to read ([the measurements](https://github.com/rayson-tech/nomarmy/blob/main/docs/experiments/2026-09-20-model-bakeoff-and-economics.md)). It pays off on bigger tickets, on parallel work, and anywhere you'd otherwise have to trust an agent's say-so.
+**Checking without building** costs nothing: `mode: verify` runs a verification profile against any branch, with no worker and no model tokens.
 
-Developed and maintained by Rayson Technologies. This is an alpha (`0.1.0-alpha`).
+## Where the work runs
 
-## How it works
+- **Agents** say where a job can run: an API key, your own ChatGPT or Muse Code subscription, or a local model on llama.cpp.
+- **The army** says which role runs on which agent: Sr and Jr devs build, a security analyst and a data architect review, a PM checks the plan, a PO accepts.
+- **`/feature`** runs a whole feature end to end, from plan through build, review and acceptance, and hands you a branch to merge.
+- **Harnesses** give each repo the right sandbox: Go, Rust, Python and Node (mixed repos too), Playwright browser tests, and fake services like a mock login server, all offline. [Adding one](https://github.com/rayson-tech/nomarmy/blob/main/CONTRIBUTING.md#adding-a-harness) never touches core code.
 
-1. The General briefs a job: a task, acceptance criteria, the tests that prove it.
-2. nomArmy creates a worktree from your branch and runs the worker in a Podman sandbox with no network and no host credentials. (One exception, the Claude subscription: see [Security posture](https://github.com/rayson-tech/nomarmy/blob/main/docs/security.md#security-posture).)
-3. The worker edits, runs tests, and ends with a four-line report: `STATUS`, `TESTS`, `NOT_DONE`, `NOTE`.
-4. nomArmy treats that report as a claim. It reads the real diff from git, runs your verification profile itself in a fresh sandbox, reverts the production change to check the tests actually fail without it, and scans for secrets.
-5. Only then does it commit, on the worker's own branch. It never merges into yours: reviewing and integrating stay with the General, and with you.
+**What you get is work you don't have to take on faith**, not cheaper work. Delegating costs the General tokens too, for briefing and review: on small, already-diagnosed tickets we measured 4 to 8 times more of the General's tokens than fixing the bug directly, with break-even around 150 lines of context a fix needs to read ([the measurements](https://github.com/rayson-tech/nomarmy/blob/main/docs/experiments/2026-09-20-model-bakeoff-and-economics.md)). It pays off on bigger tickets, parallel work, and anywhere you'd otherwise trust an agent's say-so.
 
-A malformed report isn't automatically a failure: if the repository changed, nomArmy verifies independently and may recover the work. Failing verification stays failed, unconditionally. And the checks aren't the General's to waive: a repo's `.nomarmy.yml` policy (on by default for new repos) makes verification and the revert check mandatory for every job.
+**Have a GPU or a Mac with plenty of memory?** Choose "a local model" in `nomarmy setup`: no per-token bill and your code stays home, but you pay in hardware, power and speed. `nomarmy sizing` tells you what fits. A [shared model server](https://github.com/rayson-tech/nomarmy/blob/main/docs/install.md#a-shared-model-server) works too.
 
-Around that core: **agents** say where a job can run, the **army** says which role runs on which agent, and **`/feature`** runs a whole feature end to end, from plan through build, review and acceptance, handing you a branch to merge.
+Developed and maintained by Rayson Technologies. This is an alpha (`0.1.0-alpha`).
 
 ## Docs
 
@@ -66,7 +73,7 @@ Around that core: **agents** say where a job can run, the **army** says which ro
 | [Example setup](https://github.com/rayson-tech/nomarmy/blob/main/docs/setup/example.md) | Claude Code, Codex and an API key, command by command |
 | [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 |
+| [Your repository](https://github.com/rayson-tech/nomarmy/blob/main/docs/your-repo.md) | `.nomarmy.yml`, verification, dependencies, private registries, 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 |
@@ -75,23 +82,20 @@ Around that core: **agents** say where a job can run, the **army** says which ro
 
 ## Security
 
-A worker gets a writable git worktree inside a Podman sandbox and nothing else: no network, no host credentials, no Podman socket. Every model call is made by OpenClaw on your machine, never from inside the sandbox. **The exception is a Claude subscription**, whose tools run on your machine, so nomArmy refuses build jobs on it unless you allow it. Never hand a worker production credentials, deployment access or SSH keys. Details: [Security posture](https://github.com/rayson-tech/nomarmy/blob/main/docs/security.md); to report a vulnerability, [SECURITY.md](https://github.com/rayson-tech/nomarmy/blob/main/SECURITY.md).
+A nom gets a writable git worktree inside a Podman sandbox and nothing else: no network, no host credentials, no Podman socket. Every model call is made by OpenClaw on your machine, never from inside the sandbox. Verification can climb a network ladder one rung at a time (fake services on a private network, then an allowlist you approve for a test tenant), but noms never leave `network none`. **The exception is a Claude subscription**, whose tools run on your machine, so nomArmy refuses build jobs on it unless you allow it. Never hand a nom production credentials, deployment access or SSH keys. Details: [Security posture](https://github.com/rayson-tech/nomarmy/blob/main/docs/security.md); to report a vulnerability, [SECURITY.md](https://github.com/rayson-tech/nomarmy/blob/main/SECURITY.md).
 
 ## Status
 
 | Capability | Status |
 |---|---|
-| Delegation core: worktrees, nomArmy-owned git, independent verification, kept failed worktrees | Working, end-to-end tested |
-| Local (llama.cpp) and Bedrock profiles | Working |
-| Scout and decompose modes | Unit and live tested |
-| `auto_union`, `verify_regression`, test-selection and unwired-code checks | Unit and live tested; the heuristics are review flags |
-| Secret scanning (secretlint, hard block) | Unit tested against the real dependency |
-| Agents: api keys | Live-verified with xAI; other providers built to OpenClaw's documented interface |
+| Verification core: worktrees, nomArmy-owned git, independent verification, the revert check, kept failed worktrees | Working, end-to-end tested |
+| `mode: verify`, secret scanning (secretlint, hard block), test-workaround and unwired-code checks | Unit and live tested; the heuristics are review flags |
+| Scout and decompose modes, `auto_union` | Unit and live tested |
+| 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) |
+| Local (llama.cpp) and Bedrock profiles | Working |
 | The army and `/feature` | Driven by a real Claude Code General across three runs, about 18 implement jobs |
-| 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 |
+| Harnesses: Go, Rust, Python, Node and mixed repos; Playwright; fake services | Live-verified offline |
 | 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).
@@ -99,13 +103,13 @@ What we've learned from real runs, including where delegating pays and where it
 ### Known limitations
 
 - **A Claude subscription isn't sandboxed.** Its tools run on your machine, so implement jobs on it are refused unless you set `allow_host_tools: true`. See [Security posture](https://github.com/rayson-tech/nomarmy/blob/main/docs/security.md#security-posture).
-- **A refused model costs one job.** When a vendor refuses a model at run time that OpenClaw lists (gpt-6-sol on a ChatGPT plan), the first job on it fails with `model_not_found`. After that nomArmy refuses to dispatch it until a job or test call on it works. `army assign` tests the job's route and catches this before any job.
-- **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.
+- **Your own compose services aren't started yet.** A verification profile that needs a real database from your compose file (`environment: basic` or higher) reports `not_run` rather than running without it (and the compose parser doesn't resolve YAML anchors). Fake services from harnesses, like the mock login server, do run.
+- **Private registries don't cover Poetry or Yarn Berry** yet: Poetry can't guarantee a credentialed install runs no package code, and Yarn Berry doesn't read `.npmrc`. uv, pip wheels, npm, pnpm, Yarn Classic and bun work. See [Private registries](https://github.com/rayson-tech/nomarmy/blob/main/docs/your-repo.md#private-registries).
+- **A refused model costs one job.** When a vendor refuses a model at run time that OpenClaw lists (gpt-6-sol on a ChatGPT plan), the first job on it fails with `model_not_found`; after that nomArmy won't dispatch it until a job or test call on it works. `army assign` tests the route and catches this before any job.
+- **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.
 - **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 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)).
+- **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.
 
 ## More
 

package/bin/nomarmy.mjs

@@ -18,7 +18,8 @@ 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";
@@ -115,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).
@@ -1642,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); }
@@ -1704,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; }

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/install.sh

@@ -99,9 +99,23 @@ fi
 # on a fresh macOS install nothing has initialized that VM yet at this point.
 if nomarmy_is_cloud; then need aws || { echo 'ERROR: the AWS CLI is required for cloud profiles.'; exit 1; }; fi
 "$ROOT/scripts/install-llama-cpp.sh" "$NOMARMY_PROFILE"
+# A pinned npm release, which npm checks against the registry's integrity
+# hash, rather than piping a remote installer script into bash.
+OPENCLAW_VERSION="${NOMARMY_OPENCLAW_VERSION:-2026.9.6}"
 if ! command -v openclaw >/dev/null 2>&1; then
-  echo '==> Installing OpenClaw (non-interactive)'
-  curl -fsSL https://openclaw.ai/install.sh | bash -s -- --no-onboard
+  if ! node -e 'const [a, b] = process.versions.node.split(".").map(Number); process.exit((a === 24 && b >= 16) || (a === 26 && b >= 1) || a > 26 ? 0 : 1)'; then
+    echo "ERROR: OpenClaw $OPENCLAW_VERSION needs Node 24.16+ or 26.1+; this is Node $(node -v)."
+    echo '       Upgrade Node and re-run this installer, or install OpenClaw yourself first:'
+    echo '         https://openclaw.ai (then re-run this installer)'
+    exit 1
+  fi
+  echo "==> Installing OpenClaw $OPENCLAW_VERSION from npm"
+  if [[ -w "$(npm prefix -g)" ]]; then
+    npm install -g "openclaw@$OPENCLAW_VERSION" --no-audit --no-fund
+  else
+    # No writable global prefix: install for this user, as OpenClaw's own installer does.
+    npm install -g --prefix "$HOME/.npm-global" "openclaw@$OPENCLAW_VERSION" --no-audit --no-fund
+  fi
   export PATH="$HOME/.local/bin:$HOME/.npm-global/bin:$PATH"
 fi
 need openclaw

package/lib/admission.mjs

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { executionMode } from "./execution.mjs";
+import { jobLabel, jobElapsedSeconds } from "./job-format.mjs";
 import { loadConfig } from "./config.mjs";
 import { clampInt } from "./budget-state.mjs";
 import { checkBrief, assessAdmission, describeBudgets } from "./budget.mjs";
@@ -160,7 +161,7 @@ export function createJobRuntime(deps) {
     const who = entry.mode === "verify" ? "verification runner" : entry.agent ? `${entry.agent}${entry.model ? `/${entry.model}` : ""}` : "local model";
     const took = Math.round((Date.now() - Date.parse(entry.startedAt)) / 60000);
     const ok = !error && (result?.ok || m.coordinatorStatus === "complete");
-    notify(`nomArmy: ${entry.role ?? entry.mode ?? "job"} ${ok ? "done" : outcome}`, `${entry.workerId ?? entry.jobId} on ${who}: ${outcome} after ${took}m. ${ok ? "Ready for the General's review." : "Needs a look."}`);
+    notify(`nomArmy: ${entry.role ?? entry.mode ?? "job"} ${ok ? "done" : outcome}`, `${entry.label ? `${entry.label} (${entry.workerId ?? entry.jobId})` : entry.workerId ?? entry.jobId} on ${who}: ${outcome} after ${took}m. ${ok ? "Ready for the General's review." : "Needs a look."}`);
   }
   function admissionHardware() {
     return executionMode(deps.env).managesModelServer ? deps.budgetState.hardwareSnapshot : null;
@@ -349,7 +350,7 @@ export function createJobRuntime(deps) {
   function launch(args) {
     const workerId = args.worker_id || null;
     const jobId = slug(workerId || (args.mode === "scout" ? "scout" : "worker"));
-    return trackInRun(args, track(jobId, { mode: args.mode, workerId: workerId || jobId, lane: jobLane(args), agent: args.agentName ?? null, runId: args.run_id ?? null, role: args.armyRole ?? null, model: args.model ?? null },
+    return trackInRun(args, track(jobId, { mode: args.mode, workerId: workerId || jobId, lane: jobLane(args), agent: args.agentName ?? null, runId: args.run_id ?? null, role: args.armyRole ?? null, model: args.model ?? null, label: jobLabel(args) },
       withAgentSlot(args, jobId, () => executeJob({ ...jobArgs(args, workerId), jobId }))));
   }
   // Best-effort progress signal for a job still mid-run: a plain "phase: worker,
@@ -395,7 +396,7 @@ export function createJobRuntime(deps) {
 
   async function summarize(entry, files, jobDir = null) {
     const status = files.status, meta = files.meta ?? files.failure;
-    const elapsedSeconds = status?.startedAt ? Math.round((Date.now() - Date.parse(status.startedAt)) / 1000) : entry ? Math.round((Date.now() - Date.parse(entry.startedAt)) / 1000) : null;
+    const elapsedSeconds = jobElapsedSeconds({ status, meta, entry });
     const out = { jobId: entry?.jobId ?? status?.jobId ?? meta?.jobId ?? null, workerId: entry?.workerId ?? status?.workerId ?? meta?.workerId ?? null,
       mode: entry?.mode ?? status?.mode ?? meta?.mode ?? null, state: null, phase: status?.phase ?? "starting", elapsedSeconds,
       timeoutSeconds: status?.timeoutSeconds ?? null, coordinatorStatus: meta?.coordinatorStatus ?? null, outcome: meta?.outcome ?? null,

package/lib/agents.mjs

@@ -30,6 +30,7 @@ import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
+import { typeError, isMissingField, isUnknownDiscriminator } from "./zod-issues.mjs";
 
 import { providerEntrySchema, formatDispatchIssues, openclawProviderId, PROVIDER_TYPES, ID_RE, HOST_TOOL_PROVIDERS, agentRunsToolsOnHost } from "./dispatch-schema.mjs";
 
@@ -45,10 +46,10 @@ export const RESERVED_AGENT_NAMES = Object.freeze(["__proto__", "constructor", "
 export const BUILTIN_LOCAL_AGENT = Object.freeze({ kind: "local", slot: "coder" });
 
 const requiredString = () =>
-  z.string({ required_error: "is required", invalid_type_error: "must be a string" })
+  z.string({ error: typeError("a string") })
     .refine((value) => value.trim().length > 0, { message: "must not be empty" });
 const thinkingSchema = z.union([z.boolean(), z.enum(["low", "medium", "high"])]).default(true);
-const positiveInt = () => z.number({ invalid_type_error: "must be a number" }).int("must be a whole number").positive("must be a positive number");
+const positiveInt = () => z.number({ error: typeError("a number") }).int("must be a whole number").positive("must be a positive number");
 
 const localAgentSchema = z.object({
   kind: z.literal("local"),
@@ -62,7 +63,7 @@ const localAgentSchema = z.object({
 // providerEntrySchema in agentsFileSchema's superRefine, so they exist once.
 const apiAgentSchema = z.object({
   kind: z.literal("api"),
-  provider: z.enum(API_PROVIDER_TYPES, { errorMap: () => ({ message: `must be one of ${API_PROVIDER_TYPES.join(", ")}` }) }),
+  provider: z.enum(API_PROVIDER_TYPES, { error: `must be one of ${API_PROVIDER_TYPES.join(", ")}` }),
   model: requiredString().optional(),
   auth_env: requiredString(),
   base_url: z.string().optional(),
@@ -95,7 +96,7 @@ export function hostToolsImplementProblem(name, agent) {
 }
 
 export const agentSchema = z.discriminatedUnion("kind", [localAgentSchema, apiAgentSchema, subscriptionAgentSchema], {
-  errorMap: (issue, ctx) => (issue.code === "invalid_union_discriminator" ? { message: `kind must be one of ${AGENT_KINDS.join(", ")}` } : { message: ctx.defaultError }),
+  error: (issue) => (isUnknownDiscriminator(issue) ? `kind must be one of ${AGENT_KINDS.join(", ")}` : undefined),
 });
 
 /** An api agent as the pool entry the dispatch path understands. `model` may be absent (see resolveAgentModel). */
@@ -148,7 +149,7 @@ export function formatAgentIssues(error) {
   const lines = error.issues.map((issue) => {
     const where = issue.path.length ? issue.path.join(".") : "config";
     if (issue.code === "unrecognized_keys") return `${where}: unexpected field(s) ${issue.keys.map((k) => `"${k}"`).join(", ")}`;
-    if (issue.code === "invalid_type" && issue.received === "undefined") return `${where}: is required`;
+    if (isMissingField(issue)) return `${where}: is required`;
     return `${where}: ${issue.message}`;
   });
   return [...new Set(lines)];

package/lib/army.mjs

@@ -29,6 +29,7 @@ import os from "node:os";
 import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
+import { typeError } from "./zod-issues.mjs";
 import { agentRunsToolsOnHost } from "./dispatch-schema.mjs";
 import { usageStatus } from "./usage-limits.mjs";
 
@@ -116,7 +117,7 @@ const roleSchema = z.object({
   disabled: z.boolean().optional(),
 }).strict();
 
-const positiveNumber = () => z.number({ invalid_type_error: "must be a number" }).positive("must be positive");
+const positiveNumber = () => z.number({ error: typeError("a number") }).positive("must be positive");
 // Limits on one /feature run (lib/runs.mjs). Personal, like the General:
 // global or local only, never a committed project file.
 const runLimitsSchema = z.object({

package/lib/connect.mjs

@@ -28,6 +28,7 @@ import { execFileSync } from "node:child_process";
 import { loadAgents } from "./agents.mjs";
 import { globalConfigDir } from "./army.mjs";
 import { buildNotifierApp } from "./notifier-app.mjs";
+import { recordCopySource } from "./install-freshness.mjs";
 
 export function defaultInstallDir() {
   return process.env.NOMARMY_AGENT_INSTALL_DIR || path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".local", "share", "nomarmy-local-worker");
@@ -142,6 +143,7 @@ export function installMcpCopy({ nomarmyRoot, installDir, run = defaultRun }) {
   fs.mkdirSync(path.join(installDir, "mcp"), { recursive: true });
   fs.copyFileSync(path.join(nomarmyRoot, "package.json"), path.join(installDir, "package.json"));
   fs.copyFileSync(path.join(nomarmyRoot, "mcp", "server.mjs"), path.join(installDir, "mcp", "server.mjs"));
+  recordCopySource(installDir, nomarmyRoot);
   fs.rmSync(path.join(installDir, "lib"), { recursive: true, force: true });
   fs.cpSync(path.join(nomarmyRoot, "lib"), path.join(installDir, "lib"), { recursive: true });
   // lib/sandbox-images.mjs resolves docker/ relative to its own location

package/lib/diff-checks.mjs

@@ -1,3 +1,5 @@
+import path from "node:path";
+
 // ---------------------------------------------------------------------------
 // Test-change classification (plan 16). One tunable constant, on purpose:
 // every heuristic about what counts as a test file lives here and nowhere else.
@@ -416,3 +418,91 @@ export function mergeUntrackedIntoNameStatus(nameStatus, untrackedFiles) {
   return [...(nameStatus ?? []), ...extra];
 }
 
+
+// ---------------------------------------------------------------------------
+// Verification inputs: .nomarmy.yml is read from the operator's checkout so a
+// worker can't weaken its own checks, but the files its commands run come
+// from the worker's worktree. Found live: a worker whose verification ran
+// `node check.js` rewrote check.js to print PASS and exit 0, and the job
+// committed as done. The revert check can't see it: reverting check.js along
+// with the code makes verification fail, which reads as coverage.
+//
+// Blocking (the diff changes what a command runs): a changed non-test file a
+// command names (`node check.js`, `bash scripts/verify.sh`), a changed
+// Makefile or justfile under `make`/`just`, or a changed package.json script
+// that `npm test`/`pnpm run x`/`yarn x`/`bun run x` calls. Test files named by
+// a command are left to the test-change review, since adding cases is normal.
+// Flagged only: test-runner configuration, which is often a legitimate edit.
+// ---------------------------------------------------------------------------
+
+const RUNNER_CONFIG_RE = /(^|\/)(conftest\.py|pytest\.ini|tox\.ini|setup\.cfg|\.coveragerc|(jest|vitest|vite|playwright|karma|cypress)\.config\.[cm]?[jt]s|\.mocharc(\.[a-z]+)?|phpunit\.xml(\.dist)?|\.rspec)$/;
+const TASK_FILES = { make: ["Makefile", "makefile", "GNUmakefile"], just: ["justfile", "Justfile", ".justfile"] };
+
+function shellWords(segment) {
+  return (segment.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((w) => w.replace(/^["']|["']$/g, ""));
+}
+
+// Which package.json script a package-manager command runs, if any.
+function packageScript(words) {
+  const [tool, first, second] = words;
+  if (!["npm", "pnpm", "yarn", "bun"].includes(tool) || !first) return null;
+  if (["run", "run-script"].includes(first)) return second && !second.startsWith("-") ? second : null;
+  if (tool === "npm") return ["test", "t", "tst"].includes(first) ? "test" : ["start", "stop", "restart"].includes(first) ? first : null;
+  if (tool === "bun") return null; // `bun test` is bun's own runner, not a script
+  return first.startsWith("-") || ["install", "add", "remove", "exec", "dlx", "x"].includes(first) ? null : first;
+}
+
+function scriptsOf(text) {
+  try { return JSON.parse(text ?? "")?.scripts ?? {}; } catch { return {}; }
+}
+
+function pytestSection(text) {
+  const match = /^\[tool\.pytest[^\]]*\]\s*$([\s\S]*?)(?=^\[|(?![\s\S]))/m.exec(String(text ?? ""));
+  return match ? match[1].trim() : null;
+}
+
+/**
+ * @param {{ commands: string[], changedFiles: string[], readBase: (file: string) => string|null|Promise<string|null>,
+ *   readHead: (file: string) => string|null|Promise<string|null>, isTestPathFn?: (file: string) => boolean }} input
+ * @returns {Promise<{ blocked: {file: string, command: string, why: string}[], flagged: {file: string, why: string}[] } | null>}
+ */
+export async function detectVerificationInputChanges({ commands = [], changedFiles = [], readBase = () => null, readHead = () => null, isTestPathFn = isTestPath } = {}) {
+  const changed = new Set(changedFiles.map((f) => path.posix.normalize(f)));
+  if (!changed.size) return null;
+  const blocked = [], flagged = [], seen = new Set();
+  const block = (file, command, why) => { if (!seen.has(file)) { seen.add(file); blocked.push({ file, command, why }); } };
+  for (const command of commands) {
+    let dir = "";
+    for (const segment of String(command ?? "").split(/\s*(?:&&|\|\||;|\|)\s*/)) {
+      const all = shellWords(segment);
+      let lead = 0;
+      while (lead < all.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(all[lead])) lead++; // FOO=1 cmd ...
+      const words = all.slice(lead);
+      if (!words.length) continue;
+      const at = (p) => path.posix.normalize(path.posix.join(dir, p));
+      if (words[0] === "cd" && words[1]) { dir = at(words[1]); continue; }
+      for (const word of words) {
+        if (word.startsWith("-") || word.includes("$")) continue;
+        const file = at(word);
+        if (changed.has(file) && !isTestPathFn(file)) block(file, command, `run by \`${command}\``);
+      }
+      for (const name of TASK_FILES[words[0]] ?? []) {
+        const file = at(name);
+        if (changed.has(file)) block(file, command, `read by \`${command}\``);
+      }
+      const script = packageScript(words);
+      const manifest = at("package.json");
+      if (script && changed.has(manifest)) {
+        const before = scriptsOf(await readBase(manifest)), after = scriptsOf(await readHead(manifest));
+        const touched = [script, `pre${script}`, `post${script}`].filter((s) => before[s] !== after[s]);
+        if (touched.length) block(manifest, command, `its script${touched.length > 1 ? "s" : ""} ${touched.map((s) => `"${s}"`).join(", ")} changed, and \`${command}\` runs it`);
+      }
+    }
+  }
+  for (const file of changed) {
+    if (seen.has(file)) continue;
+    if (RUNNER_CONFIG_RE.test(file)) flagged.push({ file, why: "test-runner configuration" });
+    else if (/(^|\/)pyproject\.toml$/.test(file) && pytestSection(await readBase(file)) !== pytestSection(await readHead(file))) flagged.push({ file, why: "its [tool.pytest] settings changed" });
+  }
+  return blocked.length || flagged.length ? { blocked, flagged } : null;
+}

package/lib/dispatch-schema.mjs

@@ -15,10 +15,11 @@
 //     never in a file nomArmy writes or reads back.
 
 import { z } from "zod";
+import { typeError, isMissingField, isUnknownDiscriminator } from "./zod-issues.mjs";
 
 const requiredString = () =>
   z
-    .string({ required_error: "is required", invalid_type_error: "must be a string" })
+    .string({ error: typeError("a string") })
     .refine((value) => value.trim().length > 0, { message: "must not be empty" });
 
 // Exported (not just used internally) so bin/nomarmy.mjs's interactive
@@ -101,11 +102,11 @@ export function isNativeProviderType(type) {
 export const CUSTOM_ENDPOINT_PROVIDER_TYPES = Object.freeze(["bedrock", "azure-openai", "openai-compatible"]);
 
 const idSchema = z
-  .string({ required_error: "is required", invalid_type_error: "must be a string" })
+  .string({ error: typeError("a string") })
   .regex(ID_RE, "must be 1-64 characters of letters, numbers, dot, underscore or hyphen");
 
 const weightSchema = z
-  .number({ required_error: "is required", invalid_type_error: "must be a number" })
+  .number({ error: typeError("a number") })
   .positive("must be a positive number")
   .finite("must be a finite number");
 
@@ -113,13 +114,13 @@ const weightSchema = z
 // one entry at once -- a stand-in for real rate-limit-aware admission (see
 // README's dispatch-pool section for why that's out of scope for now).
 const maxConcurrentSchema = z
-  .number({ invalid_type_error: "must be a number" })
+  .number({ error: typeError("a number") })
   .int("must be a whole number")
   .positive("must be a positive number")
   .default(2);
 
 const authEnvSchema = z
-  .string({ required_error: "is required", invalid_type_error: "must be a string" })
+  .string({ error: typeError("a string") })
   .regex(
     AUTH_ENV_NAME_RE,
     "must be an environment variable NAME (uppercase letters, digits, underscores), never the credential itself",
@@ -127,7 +128,7 @@ const authEnvSchema = z
 
 const urlSchema = () =>
   z
-    .string({ required_error: "is required", invalid_type_error: "must be a string" })
+    .string({ error: typeError("a string") })
     .url("must be a valid URL");
 
 // Whether/how the entry's model uses a thinking/reasoning mode. `true`
@@ -152,7 +153,7 @@ const thinkingSchema = z.union([z.boolean(), z.enum(["low", "medium", "high"])])
 // knows about yet (see lib/model-catalog.mjs), or an operator who wants to
 // be more conservative than the model's rated maximum.
 const contextWindowSchema = z
-  .number({ invalid_type_error: "must be a number" })
+  .number({ error: typeError("a number") })
   .int("must be a whole number")
   .positive("must be a positive number")
   .optional();
@@ -189,7 +190,7 @@ const llamaCppEntrySchema = z
 // `agents add` installs it before registering the key.
 const genericOpenclawEntrySchema = hostedProviderSchema("openclaw", { requireBaseUrl: false }).extend({
   openclaw_provider: z
-    .string({ required_error: "is required", invalid_type_error: "must be a string" })
+    .string({ error: typeError("a string") })
     .regex(OPENCLAW_PROVIDER_ID_RE, "must be an OpenClaw provider id (lowercase letters, digits, dot, underscore, hyphen)")
     .refine((id) => !PROVIDER_TYPES.includes(id) || NATIVE_PROVIDER_TYPES.includes(id), "names a nomArmy provider type with its own setup -- use that type instead"),
   plugin: z.string().regex(/^\S+$/, "must be one plugin install spec, e.g. clawhub:@openclaw/deepseek-provider").optional(),
@@ -205,7 +206,7 @@ export const providerEntrySchema = z.discriminatedUnion("provider", [
 export const poolsSchema = z.record(
   z.string().min(1, "pool name must not be empty"),
   z
-    .array(providerEntrySchema, { invalid_type_error: "must be an array of provider entries" })
+    .array(providerEntrySchema, { error: typeError("an array of provider entries") })
     .min(1, "must list at least one provider entry"),
 );
 
@@ -250,11 +251,11 @@ export function formatDispatchIssues(error) {
       lines.push(`${where}: unexpected field(s) ${keys}`);
       continue;
     }
-    if (issue.code === "invalid_union_discriminator") {
+    if (isUnknownDiscriminator(issue)) {
       lines.push(`${where}: must be one of ${PROVIDER_TYPES.join(", ")}`);
       continue;
     }
-    if (issue.code === "invalid_type" && issue.received === "undefined") {
+    if (isMissingField(issue)) {
       lines.push(`${where}: is required`);
       continue;
     }

package/lib/execute.mjs

@@ -17,7 +17,7 @@ import { describeRecoveryChanges, reportRecoveryPrompt } from "./worker-prompt.m
 import { parseWorkerReport } from "./report.mjs";
 import { OUTCOMES, COORDINATOR_STATUS_BY_OUTCOME } from "./outcomes.mjs";
 import { resolveOutcome, finalText, workerMetadata, applyRefactorContract, applyVerificationPolicy } from "./outcome.mjs";
-import { isTestPath, isDocumentationPath, detectScopedTestSelectionRisk, detectUnwiredNewDefinitions, detectMislabeledTestNames, detectPossibleSecrets } from "./diff-checks.mjs";
+import { isTestPath, isDocumentationPath, detectScopedTestSelectionRisk, detectUnwiredNewDefinitions, detectMislabeledTestNames, detectPossibleSecrets, detectVerificationInputChanges } from "./diff-checks.mjs";
 
 // ---------------------------------------------------------------------------
 // Job status for polling. `status.json` is written at every phase transition
@@ -250,7 +250,7 @@ export function createExecutor(deps) {
         // which reads as evidence about work that never happened.
         independentVerification = normalizeVerification({ status: "not_run", basis: "not-applicable", reason: "the worker changed nothing, so there was none of its work to verify" }, verification ?? null);
       } else if (verificationFlow.verificationRunner || !reportValidation.valid) {
-        independentVerification = await runIndependentVerification({ profile: verification ?? null, cwd, jobId, baseSha: base.sha, branch, mode, record: preCommit });
+        independentVerification = await runIndependentVerification({ profile: verification ?? null, cwd, jobId, baseSha: base.sha, branch, mode, record: preCommit, logFile: path.join(jobDir, "verification.log") });
       }
 
       // verify_regression: on by default whenever there's a verification
@@ -299,12 +299,19 @@ export function createExecutor(deps) {
       // Cheap, always-on, additive: never changes commitAllowed/commitBlockedReason
       // on its own (unlike the regression-check override above), only flags for
       // review -- see detectScopedTestSelectionRisk's own doc comment for why.
-      let selectionRisk = null;
+      let selectionRisk = null, verificationInputs = null;
       if (mode === "implement" && verification) {
         try {
           const loaded = loadConfig(projectDir); // the operator's contract; see registerVerificationRunner's call
           const profileCommands = loaded.found ? (loaded.config?.verification?.[verification]?.commands ?? []) : [];
           selectionRisk = detectScopedTestSelectionRisk({ commands: profileCommands, testChanges: preCommit.testChanges });
+          // A diff that changes what those commands run (see
+          // detectVerificationInputChanges): applied below, after the others.
+          verificationInputs = await detectVerificationInputChanges({
+            commands: profileCommands, changedFiles: preCommit.changedFiles ?? [],
+            readBase: (file) => gitRaw(["show", `${base.sha}:${file}`], cwd).catch(() => null),
+            readHead: (file) => { try { return fs.readFileSync(path.join(cwd, file), "utf8"); } catch { return null; } },
+          });
         } catch { /* a config load failure here is the verification runner's own problem to report, not this check's */ }
       }
       const afterSelectionRisk = selectionRisk
@@ -399,7 +406,21 @@ export function createExecutor(deps) {
             commitBlockedReason: `possible secret detected: ${possibleSecrets.reason}`,
             reasons: [...afterHostInstalls.reasons, `POSSIBLE SECRET DETECTED: ${possibleSecrets.reason}`] }
         : afterHostInstalls;
-      const finalOutcome = applyRefactorContract(applyVerificationPolicy(afterSecrets, independentVerification.status, repoPolicy()),
+      // A worker must not be judged by a check it rewrote: a changed script,
+      // Makefile or package.json script that a verification command runs
+      // blocks the commit; changed test-runner config only asks for review.
+      const blockedInputs = verificationInputs?.blocked ?? [], flaggedInputs = verificationInputs?.flagged ?? [];
+      const inputLine = blockedInputs.map((b) => `${b.file} (${b.why})`).join("; ");
+      const afterInputs = blockedInputs.length
+        ? { ...afterSecrets, outcome: afterSecrets.commitAllowed || afterSecrets.outcome === OUTCOMES.WORKER_DONE ? OUTCOMES.NEEDS_REVIEW : afterSecrets.outcome,
+            reviewRequired: true, commitAllowed: false,
+            commitBlockedReason: afterSecrets.commitAllowed ? `the diff changes what verification runs: ${inputLine}` : afterSecrets.commitBlockedReason,
+            reasons: [...afterSecrets.reasons, `VERIFICATION INPUT CHANGED: the diff changes what profile '${verification}' runs, so its result can't be trusted: ${inputLine}`] }
+        : afterSecrets;
+      const afterConfig = flaggedInputs.length
+        ? { ...afterInputs, reviewRequired: true, reasons: [...afterInputs.reasons, `TEST CONFIG CHANGED: ${flaggedInputs.map((c) => `${c.file} (${c.why})`).join("; ")}`] }
+        : afterInputs;
+      const finalOutcome = applyRefactorContract(applyVerificationPolicy(afterConfig, independentVerification.status, repoPolicy()),
         { refactor, verificationStatus: independentVerification.status, testChanges: preCommit.testChanges });
 
       progress("commit");
@@ -411,6 +432,7 @@ export function createExecutor(deps) {
       let coordinatorStatus = COORDINATOR_STATUS_BY_OUTCOME[finalOutcome.outcome] ?? "incomplete";
       const issues = [...finalOutcome.reasons, ...(preCommit.issues ?? [])];
       if (workerError) issues.push(`worker error: ${String(workerError).split("\n")[0]}`);
+      if ((result ?? attempted)?.salvaged) issues.push(`runner cleanup failed after the run (${(result ?? attempted).salvagedFrom}); the worker's report was recovered from the run's transcript`);
       if (workerFailed || workerTimedOut) { const restarted = vmRestartIssue(vmStartedBefore, deps.podmanVmStartedAt?.() ?? null); if (restarted) issues.unshift(restarted); }
       if (repositoryChanged && !commit.created) {
         if (coordinatorStatus === "complete") coordinatorStatus = "incomplete";
@@ -575,6 +597,7 @@ export function createExecutor(deps) {
       const worker = workerMetadata(result ?? attempted);
       const issues = [...outcome.reasons];
       if (workerError) issues.push(`scout error: ${String(workerError).split("\n")[0]}`);
+      if ((result ?? attempted)?.salvaged) issues.push(`runner cleanup failed after the run (${(result ?? attempted).salvagedFrom}); the scout's report was recovered from the run's transcript`);
       const failures = worker.toolSummary?.failures ?? 0; if (failures > 0) issues.push(`scout recorded ${failures} tool failure(s)`);
       if (dirty) issues.push(`snapshot changed: ${record.repoStatusFiles.join(", ")}`);
       if (reportRecoveryAttempted) {
@@ -706,6 +729,7 @@ export function createExecutor(deps) {
       const worker = workerMetadata(result ?? attempted);
       const issues = [...outcome.reasons];
       if (workerError) issues.push(`decompose error: ${String(workerError).split("\n")[0]}`);
+      if ((result ?? attempted)?.salvaged) issues.push(`runner cleanup failed after the run (${(result ?? attempted).salvagedFrom}); the decomposer's report was recovered from the run's transcript`);
       const failures = worker.toolSummary?.failures ?? 0; if (failures > 0) issues.push(`decomposer recorded ${failures} tool failure(s)`);
       if (dirty) issues.push(`snapshot changed: ${record.repoStatusFiles.join(", ")}`);
       if (overlaps.length) issues.push(`${overlaps.length} subtask pair(s) claim overlapping files; not safe to dispatch as independent jobs as proposed`);

package/lib/health.mjs

@@ -11,6 +11,8 @@
 //   army             a role or the General pointing at something unusable
 //   config           agents.yml unloadable or unsafe
 //   leftovers        retained worktrees, job storage, stale "running" jobs
+//   nomarmy-update   a newer nomArmy on npm; nomarmy-copy: coordinators run
+//                    an older copy than the installed CLI (install-freshness.mjs)
 //
 // Each issue: { id, severity: "error"|"warn"|"info", title, detail, fix,
 // short }. `id` is stable across runs, so a notification goes out once per
@@ -23,6 +25,7 @@ import { executionMode } from "./execution.mjs";
 import { modelRejection } from "./openclaw-errors.mjs";
 import { providerConfigured, readOpenclawConfig } from "./openclaw-config.mjs";
 import { readUsageSnapshots, usageStatus } from "./usage-limits.mjs";
+import { freshnessIssues, readInstallVersions } from "./install-freshness.mjs";
 
 const DAY = 86400000;
 
@@ -213,7 +216,7 @@ export function leftoverIssues({ retainedWorktrees = 0, jobsBytes = 0, staleRunn
  * Run every check. `env` supplies what each needs, with real defaults;
  * tests pass their own.
  */
-export async function runHealthChecks({ now = Date.now(), mode = "local", openclawCmd = process.env.NOMARMY_OPENCLAW_CMD || "openclaw", run = runBounded, armySummary = null, agentsError = null, jobsRoot = null, pidAlive = () => true, agents = null, openclawConfig = null, vendors = {}, modelsInUse = null, autoPruned = null, usageSnapshots = null } = {}) {
+export async function runHealthChecks({ now = Date.now(), mode = "local", openclawCmd = process.env.NOMARMY_OPENCLAW_CMD || "openclaw", run = runBounded, armySummary = null, agentsError = null, jobsRoot = null, pidAlive = () => true, agents = null, openclawConfig = null, vendors = {}, modelsInUse = null, autoPruned = null, usageSnapshots = null, install = null } = {}) {
   const issues = [];
   if (autoPruned?.freedBytes) issues.push({ id: `auto-prune:${new Date(now).toISOString()}`, severity: "info",
     title: `Freed ${(autoPruned.freedBytes / 1024 ** 3).toFixed(2)} GB: ${[autoPruned.pruned ? `runtime data of ${autoPruned.pruned} finished job${autoPruned.pruned === 1 ? "" : "s"} older than ${autoPruned.olderThanHours}h` : null, autoPruned.scratchCleared ? `OpenClaw scratch files of ${autoPruned.scratchCleared} more` : null].filter(Boolean).join(", ")}`,
@@ -230,12 +233,14 @@ export async function runHealthChecks({ now = Date.now(), mode = "local", opencl
         short });
     }
   }
-  const [auth, version, latest, plugins] = await Promise.all([
+  const [auth, version, latest, plugins, nomarmyLatest] = await Promise.all([
     run(openclawCmd, ["models", "auth", "list", "--json"]),
     run(openclawCmd, ["--version"]),
     run("npm", ["view", "openclaw", "version"], { timeoutMs: 15000 }),
     run(openclawCmd, ["plugins", "inspect", "codex"]),
+    install ? run("npm", ["view", "nomarmy", "dist-tags.alpha"], { timeoutMs: 15000 }) : null,
   ]);
+  if (install) issues.push(...freshnessIssues({ ...install, latestVersion: nomarmyLatest?.ok ? nomarmyLatest.stdout : null }));
   if (auth.ok) { try { issues.push(...loginExpiryIssues(JSON.parse(auth.stdout.slice(auth.stdout.indexOf("{"))), { now })); } catch { /* unparseable: skip */ } }
   const pluginVersion = /Version:\s*(\S+)/.exec(plugins.stdout ?? "")?.[1];
   if (version.ok) issues.push(...versionIssues({ installed: version.stdout, latest: latest.ok ? latest.stdout : null, plugins: pluginVersion ? [{ id: "codex", version: pluginVersion }] : [] }));
@@ -318,8 +323,10 @@ export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, n
   let autoPruned = null;
   if (ageMs !== null) { try { autoPruned = { ...pruneJobRuntime({ stateRoot, olderThanMs: ageMs, now }), olderThanHours: ageMs / 3600000 }; } catch { /* best-effort */ } }
   const mode = executionMode(env).mode;
+  const { defaultInstallDir } = await import("./connect.mjs");
+  const install = readInstallVersions(defaultInstallDir());
   const result = await runHealthChecks({ now, mode, armySummary, agentsError, jobsRoot: path.join(stateRoot, "jobs"), pidAlive,
-    agents, openclawConfig: readOpenclawConfig(), vendors: SUBSCRIPTION_VENDORS, modelsInUse, autoPruned, usageSnapshots: readUsageSnapshots(stateRoot) });
+    agents, openclawConfig: readOpenclawConfig(), vendors: SUBSCRIPTION_VENDORS, modelsInUse, autoPruned, usageSnapshots: readUsageSnapshots(stateRoot), install });
   const toNotify = recordHealth(path.join(stateRoot, "health.json"), result, { now });
   return { result, toNotify };
 }

package/lib/install-freshness.mjs

@@ -0,0 +1,83 @@
+// Whether the nomArmy a coordinator runs is current. Claude Code, Codex and
+// Cursor run a copy of the server that `nomarmy connect` puts in the install
+// dir, and each session keeps the code it started with. So an upgrade can
+// stall at three points, each checked here:
+//
+//   nomarmy-update  npm's alpha release is newer than the installed CLI
+//   nomarmy-copy    the CLI is newer than the copy coordinators run
+//                   (`nomarmy connect` wasn't re-run)
+//   restart         the copy on disk changed after this server started
+//                   (the session wasn't restarted); per session, so it is
+//                   reported by that session's server, not in health.json
+
+import fs from "node:fs";
+import path from "node:path";
+
+/** Written into the install dir by `nomarmy connect`: where the copy came from. */
+export const SOURCE_FILE = "source.json";
+
+export function readPackageVersion(root) {
+  try { return JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).version ?? null; }
+  catch { return null; }
+}
+
+export function recordCopySource(installDir, nomarmyRoot) {
+  fs.writeFileSync(path.join(installDir, SOURCE_FILE), JSON.stringify({ root: nomarmyRoot, version: readPackageVersion(nomarmyRoot) }, null, 2) + "\n");
+}
+
+/** The copy's version and, when connect recorded it, the version now at its source. */
+export function readInstallVersions(installDir) {
+  let source = null;
+  try { source = JSON.parse(fs.readFileSync(path.join(installDir, SOURCE_FILE), "utf8")); } catch { /* connected before source.json existed */ }
+  return { copyVersion: readPackageVersion(installDir), sourceVersion: source?.root ? readPackageVersion(source.root) : null };
+}
+
+/** Semver order, prerelease included (0.1.0-alpha.7 < 0.1.0-alpha.10 < 0.1.0). */
+export function compareVersions(a, b) {
+  const split = (v) => { const [main, pre] = String(v).trim().replace(/^v/, "").split("-", 2); return { main: main.split(".").map(Number), pre: pre ? pre.split(".") : null }; };
+  const x = split(a), y = split(b);
+  for (let i = 0; i < 3; i++) if ((x.main[i] || 0) !== (y.main[i] || 0)) return (x.main[i] || 0) < (y.main[i] || 0) ? -1 : 1;
+  if (!x.pre || !y.pre) return x.pre === y.pre ? 0 : x.pre ? -1 : 1;
+  for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+    const p = x.pre[i], q = y.pre[i];
+    if (p === undefined || q === undefined) return p === undefined ? -1 : 1;
+    if (p === q) continue;
+    const pn = /^\d+$/.test(p), qn = /^\d+$/.test(q);
+    if (pn && qn) return Number(p) < Number(q) ? -1 : 1;
+    if (pn !== qn) return pn ? -1 : 1;
+    return p < q ? -1 : 1;
+  }
+  return 0;
+}
+
+const valid = (v) => typeof v === "string" && /^v?\d+\.\d+\.\d+/.test(v.trim());
+
+/** Health issues for a stale CLI or a stale installed copy. */
+export function freshnessIssues({ copyVersion = null, sourceVersion = null, latestVersion = null }) {
+  const issues = [];
+  if (valid(latestVersion) && valid(sourceVersion) && compareVersions(sourceVersion, latestVersion) < 0) {
+    const latest = latestVersion.trim();
+    issues.push({ id: `nomarmy-update:${latest}`, severity: "info", title: `nomArmy ${latest} is out (you have ${sourceVersion})`,
+      detail: "Updating installs it, reconnects your coordinators and tells you which sessions to restart.",
+      fix: "nomarmy update", short: "nomarmy update" });
+  }
+  if (valid(sourceVersion) && valid(copyVersion) && compareVersions(copyVersion, sourceVersion) < 0) {
+    issues.push({ id: `nomarmy-copy:${sourceVersion}`, severity: "warn", title: `Your coordinators run nomArmy ${copyVersion}, but ${sourceVersion} is installed`,
+      detail: "Claude Code, Codex and Cursor run a copy of nomArmy that only `nomarmy connect` refreshes.",
+      fix: "nomarmy connect claude (and codex, cursor), then restart those sessions", short: "nomarmy reconnect" });
+  }
+  return issues;
+}
+
+/**
+ * For the running server: a notice when its copy on disk changed after it
+ * started, so this session still runs the old code. Null when current.
+ */
+export function restartNotice({ serverFile, startedAtMs, runningVersion, stat = fs.statSync, readVersion = readPackageVersion }) {
+  let changedMs;
+  try { changedMs = stat(serverFile).mtimeMs; } catch { return null; }
+  if (!(changedMs > startedAtMs)) return null;
+  const onDisk = readVersion(path.join(path.dirname(serverFile), ".."));
+  const versions = onDisk && onDisk !== runningVersion ? ` (this session runs ${runningVersion}; ${onDisk} is installed)` : "";
+  return `nomArmy was updated after this session started${versions}. Restart this session to use the new version; until then it runs the old code.`;
+}

package/lib/job-format.mjs

@@ -124,3 +124,27 @@ export function formatUnion(union) {
   const artifacts = union.worktree ? `\n\nUnion artifacts: ${path.dirname(union.worktree)}\nWorktree retained for review: ${union.worktree}\nBranch retained for review: ${union.branch}` : "";
   return `${banner}--- UNION RECORD ---\n${JSON.stringify(union, null, 2)}${artifacts}`;
 }
+
+/**
+ * What a person calls a job: its commit subject, else the task's first
+ * sentence, capped. Two jobs on one agent and model differ here even with no
+ * role, so a notification can tell them apart.
+ */
+export function jobLabel(args) {
+  const text = String(args?.commit_subject || args?.task || "").split("\n")[0].split(/(?<=\.)\s/)[0].trim();
+  return text.length > 60 ? `${text.slice(0, 57)}...` : text || null;
+}
+
+/**
+ * Seconds a job has run: to its finish once it has one, not to whenever it's
+ * asked about. The record's total_elapsed covers the whole job; an implement
+ * job's finishedAt marks only the worker's end, before verification and commit.
+ */
+export function jobElapsedSeconds({ status = null, meta = null, entry = null, now = Date.now() } = {}) {
+  const total = meta?.metrics?.total_elapsed;
+  if (Number.isFinite(total)) return Math.round(total / 1000);
+  const startedMs = Date.parse(status?.startedAt ?? entry?.startedAt ?? meta?.startedAt ?? "");
+  if (!Number.isFinite(startedMs)) return null;
+  const finishedMs = Date.parse((status?.state === "finished" ? status.updatedAt : null) ?? meta?.finishedAt ?? "");
+  return Math.round(((Number.isFinite(finishedMs) ? finishedMs : now) - startedMs) / 1000);
+}

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

package/lib/schema.mjs

@@ -12,6 +12,7 @@
 //     approval before the job runs. See `collectElevated`.
 
 import { z } from "zod";
+import { typeError, isMissingField, isUnknownDiscriminator } from "./zod-issues.mjs";
 import { armySchema } from "./army.mjs";
 
 export const SERVICE_SOURCES = Object.freeze([
@@ -57,12 +58,12 @@ export const SERVICE_FIELDS = Object.freeze({
 // the dotted path, so repeating it reads as stutter.
 const requiredString = () =>
   z
-    .string({ required_error: "is required", invalid_type_error: "must be a string" })
+    .string({ error: typeError("a string") })
     .refine((value) => value.trim().length > 0, { message: "must not be empty" });
 
 const enumOf = (values) =>
   z.enum(values, {
-    errorMap: () => ({ message: `must be one of ${values.join(", ")}` }),
+    error: `must be one of ${values.join(", ")}`,
   });
 
 // A plain hostname: no scheme, no path, no port, no whitespace.
@@ -90,7 +91,7 @@ export function hostnameProblem(value) {
 }
 
 const hostnameSchema = z
-  .string({ invalid_type_error: "must be a string hostname" })
+  .string({ error: typeError("a string hostname") })
   .superRefine((value, ctx) => {
     const problem = hostnameProblem(value);
     if (problem) ctx.addIssue({ code: z.ZodIssueCode.custom, message: problem });
@@ -162,7 +163,7 @@ export const serviceSchema = z.discriminatedUnion("source", [
 export const pythonEnvironmentSchema = z
   .object({
     requirements: z
-      .array(requiredString(), { invalid_type_error: "must be an array of strings" })
+      .array(requiredString(), { error: typeError("an array of strings") })
       .min(1, "must list at least one requirements file"),
   })
   .strict();
@@ -211,10 +212,7 @@ export const verificationProfileSchema = z
   .object({
     environment: enumOf(ENVIRONMENT_LEVELS).default("none"),
     commands: z
-      .array(requiredString(), {
-        required_error: "is required",
-        invalid_type_error: "must be an array of strings",
-      })
+      .array(requiredString(), { error: typeError("an array of strings") })
       .min(1, "must list at least one command"),
   })
   .strict();
@@ -235,7 +233,7 @@ export const environmentRetentionSchema = z
     debug: enumOf(RETENTION_ACTIONS).default(DEFAULT_RETENTION.debug),
   })
   .strict()
-  .default({});
+  .prefault({});
 
 // ---------------------------------------------------------------------------
 // root
@@ -295,11 +293,11 @@ export function formatIssues(error) {
       lines.push(`${where}: unexpected field(s) ${keys}`);
       continue;
     }
-    if (issue.code === "invalid_union_discriminator") {
+    if (isUnknownDiscriminator(issue)) {
       lines.push(`${where}: must be one of ${SERVICE_SOURCES.join(", ")}`);
       continue;
     }
-    if (issue.code === "invalid_type" && issue.received === "undefined") {
+    if (isMissingField(issue)) {
       lines.push(`${where}: is required`);
       continue;
     }

package/lib/zod-issues.mjs

@@ -0,0 +1,15 @@
+// Zod 4 helpers shared by nomArmy's config schemas and their issue formatters.
+
+/**
+ * The `error` option for a primitive schema: "is required" when the field is
+ * absent, "must be <expected>" when it has the wrong type. Zod 4 replaced
+ * zod 3's required_error and invalid_type_error with this single function.
+ * @param {string} expected e.g. "a string"
+ */
+export const typeError = (expected) => (issue) => (issue.input === undefined ? "is required" : `must be ${expected}`);
+
+/** A field that is absent entirely, with no custom message of its own. */
+export const isMissingField = (issue) => issue.code === "invalid_type" && / received undefined$/.test(issue.message);
+
+/** A discriminated union whose discriminator matched none of its options. */
+export const isUnknownDiscriminator = (issue) => issue.code === "invalid_union" && issue.note === "No matching discriminator";

package/mcp/server.mjs

@@ -35,8 +35,9 @@ import { OUTCOMES, COORDINATOR_STATUS_BY_OUTCOME } from "../lib/outcomes.mjs";
 import { readUsageSnapshots, usageStatus } from "../lib/usage-limits.mjs";
 import { modelRefusals } from "../lib/health.mjs";
 import { podmanProblem, podmanVmStartedAt } from "../lib/podman-health.mjs";
+import { restartNotice } from "../lib/install-freshness.mjs";
 import { createBuildMetrics, resolveOutcome, finalText, workerMetadata, usageMetrics, policyAdmissionProblems, applyRefactorContract, applyVerificationPolicy, resolveVerifyRegression } from "../lib/outcome.mjs";
-import { compactJobRecord, formatResult, formatUnion, testChangeBanner, regressionCheckBanner, decomposeOverlapBanner } from "../lib/job-format.mjs";
+import { jobLabel, compactJobRecord, formatResult, formatUnion, testChangeBanner, regressionCheckBanner, decomposeOverlapBanner } from "../lib/job-format.mjs";
 
 export { run, mapLimit };
 export { readsMeasurable, measureReads };
@@ -57,6 +58,7 @@ export { TEST_PATH_PATTERNS, isTestPath, testPatternFor, classifyTestChanges, de
 // package.json to the same relative location next to the installed
 // mcp/server.mjs, so this resolves identically in a dev checkout or an
 // installed copy.
+const SERVER_STARTED_MS = Date.now();
 const VERSION = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8")).version;
 // Sent to every coordinator on connect, so no project needs a copied CLAUDE.md.
 const server = new McpServer({ name: "nomarmy-local-worker", version: VERSION }, { instructions: COORDINATOR_INSTRUCTIONS });
@@ -406,9 +408,20 @@ server.tool("local_worker_status", `Status of one job started by this server: ph
   if (full && files.meta) return toolText(JSON.stringify(files.meta, null, 2), summary.coordinatorStatus !== "complete");
   return toolText(JSON.stringify({ ...summary, jobDir, hint: entry?.result || files.meta ? "call again with full=true for the complete report" : null }, null, 2), summary.state === "orphaned" || summary.state === "failed");
 });
+// Set when this session's copy of nomArmy changed on disk after it started
+// (nomarmy connect or update ran): shown first in army and capacity, and
+// notified once, since only a restart of this session picks it up.
+let restartNotified = false;
+function currentRestartNotice() {
+  const notice = restartNotice({ serverFile: fileURLToPath(import.meta.url), startedAtMs: SERVER_STARTED_MS, runningVersion: VERSION });
+  if (notice && !restartNotified) { restartNotified = true; try { notify("nomArmy: restart this session", notice); } catch { /* best-effort */ } }
+  return notice;
+}
+const withRestartNotice = (value) => { const notice = currentRestartNotice(); return notice ? { restartNeeded: notice, ...value } : value; };
+
 server.tool("local_worker_capacity", "What this host can take right now: context per nom and the brief/report budgets derived from it, memory pressure and whether another job would be admitted, and the jobs currently running. Read-only.", {}, async () => {
   await budgetState.refresh();
-  return toolText(JSON.stringify(capacitySnapshot(), null, 2));
+  return toolText(JSON.stringify(withRestartNotice(capacitySnapshot()), null, 2));
 });
 // The only way to know what `verification`/`union_verification`/
 // `verify_regression` profile names are actually valid for this repo used to
@@ -515,7 +528,7 @@ server.tool("army", "Who you, the General, are and who you call for what in this
         role.modelNote = `${role.model} isn't in OpenClaw's catalog for ${role.agent}; \`army assign\` checked it with a real test call when it was set, and the catalog can lag new models. Use it as assigned; if a job reports "Unknown model", reassign.`;
       }
     }
-    return toolText(JSON.stringify(summary, null, 2));
+    return toolText(JSON.stringify(withRestartNotice(summary), null, 2));
   } catch (error) {
     return toolText(error.message, true);
   }
@@ -569,7 +582,7 @@ server.tool("local_workers", "Run independent jobs (implement or scout) with bou
       // so it was invisible to both ceilings while it ran.
       // A batch job waits for its agent's slot (up to its own timeout) rather
       // than failing because an earlier job in the same batch holds it.
-      return trackInRun(j, track(jobId, { mode: j.mode, workerId, lane: jobLane(j), agent: j.agentName ?? null, runId: j.run_id ?? null, role: j.armyRole ?? null, model: j.model ?? null },
+      return trackInRun(j, track(jobId, { mode: j.mode, workerId, lane: jobLane(j), agent: j.agentName ?? null, runId: j.run_id ?? null, role: j.armyRole ?? null, model: j.model ?? null, label: jobLabel(j) },
         withAgentSlot(j, jobId, () => executeJob({ ...jobArgs(effectiveJob, workerId), jobId }), { waitMs: (j.timeout_seconds ?? 600) * 1000 }))).promise;
     }, { staggerMs: WORKER_START_STAGGER_MS });
     indices.forEach((i, laneI) => { results[i] = laneResults[laneI]; });

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "nomarmy",
-  "description": "A harness for AI coding workers whose claims are never trusted: your coding assistant stays in charge while workers implement and test in sandboxes, on local models, API keys or your own subscriptions.",
+  "description": "Every byte verified: a harness for AI coding workers whose claims are never trusted. Your coding assistant stays in charge while workers implement and test in sandboxes, and nomArmy checks every change before it is committed.",
   "author": "Rayson Technologies",
   "license": "Apache-2.0",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.8",
   "private": false,
   "type": "module",
   "engines": {
@@ -21,11 +21,11 @@
     "tag": "alpha"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.30.1",
     "@secretlint/node": "^13.0.5",
     "@secretlint/secretlint-rule-preset-recommend": "^13.0.5",
     "yaml": "^2.5.0",
-    "zod": "^3.24.0"
+    "zod": "^4.6.5"
   },
   "scripts": {
     "test": "node --test tests/*.test.mjs",