nomarmy 0.1.0-alpha.0 → 0.1.0-alpha.2

package/README.md

@@ -8,9 +8,29 @@
 
 <p align="center"><em>Tiny coders, big appetites for bounded tickets.</em> 🍪</p>
 
-**An agent harness where a worker's claims are never trusted, and the environment your tests need is declared, disposable and reproducible.**
+**Your coding assistant plans; sandboxed workers build; nothing counts until nomArmy has checked it.**
 
-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. A nom can run on a local model at no token cost, on an API key, or on your own Claude, ChatGPT or Muse Code subscription. nomArmy owns everything in between: worktrees, git, sandboxes, verification, and the evidence that decides whether work is accepted.
+## TL;DR
+
+1. **Have** Git, Node 20+ and [Podman](https://podman.io) (on macOS: `brew install podman && podman machine init && podman machine start`).
+2. **Install** (builds the local model server, OpenClaw and the sandbox, and registers nomArmy with Claude Code):
+   ```bash
+   git clone https://github.com/rayson-tech/nomarmy.git && cd nomarmy
+   ./install.sh --profile macbook-pro   # or nvidia-linux, cpu-linux, dgx-spark, bedrock
+   ./e2e.sh --profile macbook-pro       # should end with: === E2E PASS ===
+   ```
+   No local model? See [hosted workers only](#hosted-workers-only) or [a shared model server](#a-shared-model-server).
+3. **Set up your repo:** in the project, run `nomarmy init`. It proposes a `.nomarmy.yml` with your test command.
+4. **Use it:** restart Claude Code in that project and ask it to use nomArmy for one small bug that has a test. When that works, try `/feature <what you want built>`.
+5. **Optional:** add hosted workers with `nomarmy agents add`, give roles to them with `nomarmy army init`, or connect Codex or Cursor with `nomarmy connect codex cursor`.
+
+Stuck? `nomarmy doctor` checks the machine, and `nomarmy health` checks everything nomArmy runs on.
+
+## What it is
+
+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 a local model, an API key, or your own ChatGPT or Muse Code subscription. nomArmy owns everything in between: worktrees, git, sandboxes, verification, and the evidence that decides whether work is accepted.
+
+**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](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.
 
 Developed and maintained by Rayson Technologies. This is an alpha (`0.1.0-alpha`).
 
@@ -22,35 +42,10 @@ Developed and maintained by Rayson Technologies. This is an alpha (`0.1.0-alpha`
 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.
 
-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.
+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.
 
 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.
 
-## Quick start
-
-You need Git, Node 20+, and [Podman](https://podman.io).
-
-```bash
-npm install -g nomarmy@alpha
-nomarmy doctor          # what's missing on this machine, and how to fix it
-nomarmy setup           # pick a profile and model; prints the install.sh command to run
-nomarmy connect claude  # or codex, cursor: registers nomArmy with your coordinator
-```
-
-Installing from a clone is the most tested path, and it's what `install.sh` expects: see [Install](#install). `install.sh` builds llama.cpp for local inference, installs and configures [OpenClaw](https://github.com/openclaw/openclaw) (the host-side broker every model call goes through), builds the sandbox image and registers the MCP server.
-
-`nomarmy connect` also installs the `/feature` command, Claude Code's status line and (on macOS) nomArmy's notifier. The coordinator gets nomArmy's instructions from the MCP server itself, so there's nothing to copy into your projects.
-
-Then, in any git repository:
-
-```bash
-nomarmy init                  # propose a .nomarmy.yml with your test command
-nomarmy agents add            # optional: an API key or a subscription
-nomarmy army init             # optional: the default roster of roles
-```
-
-Ask your coordinator to delegate one small, well-tested ticket before anything bigger. When that works, try `/feature <what you want built>`.
-
 ## Install
 
 | Platform | Guide |
@@ -59,10 +54,16 @@ Ask your coordinator to delegate one small, well-tested ticket before anything b
 | Linux, with or without an NVIDIA GPU | [Linux](#linux) |
 | Windows | [Windows](#windows) |
 | NVIDIA DGX Spark | [DGX Spark](#dgx-spark) |
-| No GPU, or no local inference | [Cloud (Bedrock)](#cloud-bedrock) |
+| No local model: API keys and subscriptions only | [Hosted workers only](#hosted-workers-only) |
+| A shared GPU server (or a tunnel to one) | [A shared model server](#a-shared-model-server) |
+| No GPU, with Bedrock | [Cloud (Bedrock)](#cloud-bedrock) |
 
 Every platform needs Git and Podman. `nomarmy doctor` checks the host and prints a fix for anything missing.
 
+`install.sh` builds llama.cpp for local inference, installs and configures [OpenClaw](https://github.com/openclaw/openclaw) (the host-side broker every model call goes through), builds the sandbox image, and registers the MCP server if Claude Code is installed. `nomarmy connect` (run by `install.sh`, or by hand for Codex and Cursor) also installs the `/feature` command, Claude Code's status line and, on macOS, nomArmy's notifier. The coordinator gets nomArmy's instructions from the MCP server itself, so there's nothing to copy into your projects.
+
+**From npm:** `npm install -g nomarmy@alpha` gives you the `nomarmy` command; `nomarmy setup` then picks a profile and model and prints the `install.sh` command to run (`nomarmy setup --hosted` or `--llama-url <server>` without a local model). Installing from a clone, as in the TL;DR, is the most tested path.
+
 ### macOS (Apple Silicon)
 
 ```bash
@@ -105,7 +106,7 @@ CPU-only Linux works but is slow for interactive use: see [Sizing](#sizing).
 
 1. **WSL2** (the supported path): install a Linux distro under WSL2, install Podman inside it, and follow the [Linux](#linux) guide entirely inside the distro. Watch WSL2's default cap of about half your RAM (`.wslconfig`), and set `git config --global core.longpaths true` (`nomarmy doctor` checks this).
 2. **Native llama.cpp on Windows**, built from source: more RAM, more setup. Prebuilt binaries aren't a safe shortcut; some CPUs crash every backend at startup.
-3. **No local inference**: `./install.sh --profile bedrock` (see [Cloud (Bedrock)](#cloud-bedrock)), or hosted agents only.
+3. **No local inference**: [hosted workers only](#hosted-workers-only), or [Bedrock](#cloud-bedrock).
 
 `nomarmy sizing` reports what your hardware can support.
 
@@ -121,6 +122,34 @@ chmod +x install.sh e2e.sh scripts/*.sh
 
 Moving from a Mac install? Don't copy a Mac binary or model cache over: clone fresh and let `install.sh` build llama.cpp for CUDA on that machine.
 
+### Hosted workers only
+
+No GPU and no local model: every job runs on an API key or a subscription (ChatGPT, Muse Code) you add as an agent. Git worktrees, the sandbox and verification still run on your machine, so you still need Git, Node and Podman.
+
+```bash
+git clone https://github.com/rayson-tech/nomarmy.git && cd nomarmy
+npm install && npm link              # or: npm install -g nomarmy@alpha
+nomarmy setup --hosted               # records that this install has no local model
+./install.sh --profile hosted        # OpenClaw, the sandbox, and the Claude Code registration; no llama.cpp
+nomarmy agents add                   # an API key or a subscription login
+nomarmy army init --agent <name>     # every role on that agent (add --model <model> to pick one)
+nomarmy doctor
+```
+
+A hosted install refuses a job that names no role or agent, rather than falling back to a local model that isn't there. `nomarmy health` warns about any role still on `local`. `e2e.sh` tests the local model, so it has nothing to do here; `nomarmy army assign` tests each role's route instead.
+
+### A shared model server
+
+A team GPU box (a DGX, a workstation) runs one llama-server; everyone else points nomArmy at it. That works through an SSH tunnel too (`ssh -L 8080:localhost:8080 gpu-box`, then `http://127.0.0.1:8080`).
+
+```bash
+nomarmy setup --llama-url http://gpu-box:8080   # checks /health, records the address
+./install.sh --profile remote                   # no llama.cpp build; OpenClaw points at that server
+./e2e.sh --profile remote
+```
+
+nomArmy doesn't start, stop or size that server: whoever runs it sets its model, context and slots, and `install.sh` reads the model name and context from the server. Your machine still runs the sandbox and verification for your jobs. Several people sharing one server share its slots, so keep `NOMARMY_MAX_WORKERS` low (the profile sets 1). Run the server itself with any local profile's `install.sh` on the GPU machine, with `NOMARMY_LLAMA_HOST=0.0.0.0` so others can reach it, on a network you trust: llama-server has no authentication.
+
 ### Cloud (Bedrock)
 
 No GPU, no local build:
@@ -179,6 +208,8 @@ Changes apply to the next job with no restart. The exception is a **new** api ag
 
 **Your plan decides which models run.** A model can be listed and still refused: on a ChatGPT plan, the Codex route runs gpt-6-astra and the gpt-5.6 models but refuses gpt-6-sol and gpt-6-luna. `army assign` and `agents update --probe` test the exact route a job takes, so they catch this before a job does.
 
+**Vendor terms and platform risk.** Every model call goes through [OpenClaw](https://github.com/openclaw/openclaw), and subscriptions are reached through each vendor's own CLI or login. We've read the terms that apply (see above), but using a personal subscription through a harness is exactly the kind of use vendors tighten, and a change in a vendor's terms or in OpenClaw can stop a subscription agent from working. Local models and API keys don't carry that risk. Plan on subscriptions as a convenience, not the only way your roles can run.
+
 **Picking an agent.** Build work goes to a sandboxed agent: `local`, an api key, Codex or Muse. `local` for a bounded change against a written spec with a test; your code never leaves your machine. An api or subscription agent when the work needs more than the local model, knowing it sends code to that vendor. That's a decision about where your source travels, separate from the trust boundary, which is the same for every agent. The General itself when the answer isn't known yet.
 
 ## The army: who does what
@@ -270,6 +301,18 @@ verification:
 
 `nomarmy validate` checks the file against the schema; `nomarmy scan --check` diffs it against what the repo actually contains.
 
+**Policy: what no job can skip.**
+
+```yaml
+policy:
+  require_verification: true       # every implement job needs a verification profile; only passing work commits
+  require_regression_check: true   # verify_regression can't be switched off per job
+```
+
+`nomarmy init` proposes both for new repos. Without them, a job with no verification profile still commits (flagged for review, not blocked), and the General decides per job whether to run the revert check. With them, those are the repo's rules, not the General's judgment calls, and since nomArmy reads this file only from your checkout, neither the General nor a worker can relax it.
+
+**Refactors.** Reverting a behavior-preserving change restores code that works, so the revert check can't prove anything about it. A job can declare `refactor: true` instead: nomArmy then commits it only if verification passes **and no test file was added, changed or deleted**. The existing tests passing unchanged is the evidence. A change that alters behavior has to alter tests to show it, so it can't pass as a refactor.
+
 **Add a check for what unit tests can't see.** A module left out of a deploy bundle passes every unit test and crashes at deploy. When `nomarmy init` sees a bundle or packaging step (Lambda asset scripts, SAM, Serverless, CDK), it suggests a profile that runs it and then imports each entry point from the built bundle.
 
 ### Languages and dependencies
@@ -458,7 +501,7 @@ What we've learned from real runs, including where delegating pays and where it
 - **Deploy-time failures need your own check.** See [Add a check for what unit tests can't see](#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.
 - **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 only**: the MCP server and OpenClaw run on the machine with the coordinator. There's no remote-worker mode yet.
+- **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](#a-shared-model-server)).
 
 ## Troubleshooting
 

package/bin/nomarmy.mjs

@@ -18,10 +18,11 @@ 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 } from "../lib/connect.mjs";
+import { connectClaude, connectCodex, connectCursor, cursorAlreadyConnected, deriveWorkerModelEnv } from "../lib/connect.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, AGENT_KINDS, API_PROVIDER_TYPES, RESERVED_AGENT_NAMES, BUILTIN_LOCAL_AGENT } from "../lib/agents.mjs";
+import { loadAgents, readAgentsFile, writeAgentsFile, agentsConfigPath, apiAgentAsPoolEntry, describeAgent as describeAgentLabel, agentRunsToolsOnHost, AGENT_KINDS, API_PROVIDER_TYPES, RESERVED_AGENT_NAMES, BUILTIN_LOCAL_AGENT } from "../lib/agents.mjs";
 import { loadArmy, describeArmy, readArmyFile, updateArmyInFile, assignRoleInFile, parseTargetSpec, armyLayerPath, globalConfigDir, DEFAULT_ARMY, ARMY_PHASES, LOCAL_CONFIG_FILENAME } from "../lib/army.mjs";
+import { parseLlamaUrl } from "../lib/execution.mjs";
 import { ensureProviderConfig } from "../lib/openclaw-config.mjs";
 import { recordProbeSuccess } from "../lib/health.mjs";
 import { pruneJobRuntime } from "../lib/prune.mjs";
@@ -93,6 +94,8 @@ Usage: nomarmy <command> [options]
                   write config/profiles/<name>.env (+ config/common.env).
                   Prints the install.sh command; never runs it.
                   --tier <more|nominal>   with --json, skip the prompt
+                  --hosted               skip hardware/model questions
+                  --llama-url <url>       use a llama-server on another machine
   model           Change the configured model later, without the rest of
                   setup's questions. Offers to also resync the MCP
                   registration's worker-routing env vars, and to restart
@@ -168,7 +171,9 @@ Usage: nomarmy <command> [options]
                             UI/UX, data architect, security analyst, PM,
                             PO, stakeholder, all on \`local\`) to --global
                             (default), --project or --local; --force
-                            replaces an existing one
+                            replaces an existing one; --agent <name>
+                            starts every role there, optionally with
+                            --model <model|auto>
                   assign <role> <agent|none> [model|auto]
                             give a role an agent, and optionally the model
                             to run on it ("auto" lets the General pick per
@@ -516,6 +521,55 @@ async function chooseModel(rl) {
  * command itself does.
  */
 async function cmdSetup() {
+  const hosted = flag("hosted");
+  const hasLlamaUrl = flag("llama-url");
+  if (hosted && hasLlamaUrl) throw new Error("--hosted and --llama-url cannot be used together.");
+
+  if (hosted || hasLlamaUrl) {
+    const commonPath = path.join(nomarmyRoot, "config", "common.env");
+
+    if (hosted) {
+      const next = [
+        `${path.join(nomarmyRoot, "install.sh")} --profile hosted`,
+        "nomarmy agents add",
+        "nomarmy army init --agent <name>",
+      ];
+      fs.mkdirSync(path.dirname(commonPath), { recursive: true });
+      writeEnvLine(commonPath, "NOMARMY_EXECUTION", "hosted");
+      if (json) return out({ written: commonPath, execution: "hosted", next });
+      console.log(c.green(`✓ Wrote NOMARMY_EXECUTION=hosted to ${path.relative(nomarmyRoot, commonPath)}.`));
+      console.log(c.dim("\nNext:"));
+      for (const step of next) console.log(`  ${c.bold(step)}`);
+      return;
+    }
+
+    const llamaInput = value("llama-url");
+    if (!llamaInput) throw new Error("--llama-url requires an http:// URL, for example http://server:8080.");
+    const { host: llamaHost, port: llamaPort } = parseLlamaUrl(llamaInput);
+    const urlHost = llamaHost.includes(":") ? `[${llamaHost}]` : llamaHost;
+    const healthUrl = `http://${urlHost}:${llamaPort}/health`;
+    let reachable = false;
+    try {
+      await fetch(healthUrl, { signal: AbortSignal.timeout(5000) });
+      reachable = true;
+    } catch {
+      // A server may simply be offline during setup; retain its validated address.
+    }
+    fs.mkdirSync(path.dirname(commonPath), { recursive: true });
+    writeEnvLine(commonPath, "NOMARMY_EXECUTION", "remote");
+    writeEnvLine(commonPath, "NOMARMY_LLAMA_HOST", llamaHost);
+    writeEnvLine(commonPath, "NOMARMY_LLAMA_PORT", llamaPort);
+    const next = `${path.join(nomarmyRoot, "install.sh")} --profile remote`;
+    if (json) return out({ written: commonPath, execution: "remote", llamaHost, llamaPort, reachable, next });
+    console.log(reachable
+      ? c.green(`✓ llama-server is reachable at ${healthUrl}.`)
+      : c.yellow(`⚠ llama-server is not reachable at ${healthUrl} right now; configuration was still written.`));
+    console.log(c.green(`✓ Wrote the remote llama-server settings to ${path.relative(nomarmyRoot, commonPath)}.`));
+    console.log(c.dim("\nNext:"));
+    console.log(`  ${c.bold(next)}`);
+    return;
+  }
+
   const execution = value("execution", process.env.NOMARMY_EXECUTION || "local");
   const isCloud = execution !== "local";
   const hardware = isCloud ? null : await detectHardware();
@@ -1962,16 +2016,45 @@ async function cmdArmyShow() {
 async function cmdArmyInit() {
   const layer = armyLayerFlag("global");
   const filePath = armyLayerPath(layer, { projectDir: repoDir });
+  const agentName = value("agent");
+  let selectedAgent = null;
+  let roleModel = null;
+  if (flag("agent") && !agentName) throw new Error("--agent requires a name from agents.yml.");
+  if (agentName) {
+    const agents = loadAgentsOrExit().agents;
+    if (!Object.prototype.hasOwnProperty.call(agents, agentName)) {
+      throw new Error(`Unknown agent "${agentName}". Pick one of: ${Object.keys(agents).join(", ")}`);
+    }
+    selectedAgent = agents[agentName];
+    if (flag("model") && !value("model")) throw new Error("--model requires a model name or auto.");
+    roleModel = value("model") ?? (selectedAgent.model ? null : "auto");
+  }
   const existing = readArmyFile(filePath, { armyOnly: layer !== "project" });
   if (existing?.roles && Object.keys(existing.roles).length && !flag("force")) {
     throw new Error(`${filePath} already defines an army (${Object.keys(existing.roles).join(", ")}). Re-run with --force to replace it.`);
   }
   // Keep a General already defined in this layer; the roster is what init resets.
-  updateArmyInFile(filePath, (army) => ({ ...structuredClone(DEFAULT_ARMY), ...(army.general ? { general: army.general } : {}) }));
+  const roster = structuredClone(DEFAULT_ARMY);
+  if (agentName) {
+    for (const role of Object.values(roster.roles)) {
+      role.agent = agentName;
+      if (roleModel) role.model = roleModel;
+    }
+  }
+  updateArmyInFile(filePath, (army) => ({ ...roster, ...(army.general ? { general: army.general } : {}) }));
   if (layer === "local") ensureLocalLayerIgnored();
   if (json) return out({ written: filePath, layer, roles: Object.keys(DEFAULT_ARMY.roles) });
   console.log(c.green(`✓ Wrote the default army to ${filePath} (${layer}).`));
-  console.log(c.dim("Every role starts on the local model. Next: `nomarmy army general <agent>` (the agent your coordinator session runs on), then `nomarmy army assign <role> <agent>` for any role you want elsewhere."));
+  if (!agentName) {
+    console.log(c.dim("Every role starts on the local model. Next: `nomarmy army general <agent>` (the agent your coordinator session runs on), then `nomarmy army assign <role> <agent>` for any role you want elsewhere."));
+    return;
+  }
+  console.log(c.dim(roleModel === "auto"
+    ? `Every role starts on ${agentName} with model auto; the coordinator picks a model per job.`
+    : `Every role starts on ${agentName}${roleModel ? ` with model ${roleModel}` : ` using its default model ${selectedAgent.model}`}.`));
+  if (agentRunsToolsOnHost(selectedAgent)) {
+    console.log(c.yellow(`⚠ ${agentName} runs its tools on the host. Build roles on it will be refused unless allow_host_tools is set in agents.yml.`));
+  }
 }
 
 async function cmdArmyAssign() {
@@ -2206,10 +2289,18 @@ async function cmdJobs() {
 
 // `nomarmy health`: run the checks now (the MCP server also runs them every
 // 6 hours) and record them, which also refreshes the status line's warning.
+// This install's settings from config/common.env (the execution mode and the
+// model server's address, as `nomarmy connect` gives the MCP server), under
+// anything set (non-empty) in the environment.
+function installEnv() {
+  const set = Object.fromEntries(Object.entries(process.env).filter(([, v]) => v !== ""));
+  return { ...deriveWorkerModelEnv(nomarmyRoot), ...set };
+}
+
 async function cmdHealth() {
   const { checkAndRecordHealth } = await import("../lib/health.mjs");
   const stateRoot = process.env.NOMARMY_AGENT_STATE || path.join(os.homedir(), ".local", "share", "nomarmy-local-agents");
-  const { result } = await checkAndRecordHealth({ projectDir: repoDir, stateRoot, configDir: globalConfigDir() });
+  const { result } = await checkAndRecordHealth({ projectDir: repoDir, stateRoot, configDir: globalConfigDir(), env: installEnv() });
   if (json) return out(result);
   console.log(c.bold("🍪 nomArmy health") + c.dim(`  ${new Date(result.checkedAt).toLocaleString()}`));
   if (!result.issues.length) { console.log(c.green("\n✓ Nothing to fix.")); return; }
@@ -2234,7 +2325,7 @@ const commands = { scan: cmdScan, validate: cmdValidate, sizing: cmdSizing, init
 async function cmdDoctor() {
   // Import lazily to avoid circular dependencies
   const { runDoctor } = await import("../lib/doctor.mjs");
-  await runDoctor({ json, exit: true });
+  await runDoctor({ json, exit: true, env: installEnv() });
 }
 commands.doctor = cmdDoctor;
 if (!command || flag("help") || !commands[command]) usage(command && !commands[command] ? 2 : 0);

package/config/common.env

@@ -16,8 +16,10 @@ NOMARMY_MAX_WORKERS=1
 NOMARMY_AGENT_IMAGE=openclaw-nomarmy-coder:bookworm
 NOMARMY_INSTALL_ROOT=$HOME/.local/share/nomarmy-local-agents
 
-# Execution layer: 'local' runs llama-server on this machine, 'bedrock' calls a
-# hosted OpenAI-compatible endpoint. Profiles override this.
+# Where models run: 'local' runs llama-server on this machine, 'remote' uses
+# one nomArmy doesn't run (nomarmy setup --llama-url), 'hosted' has no local
+# model at all (nomarmy setup --hosted), 'bedrock' calls Bedrock. Profiles
+# override this.
 NOMARMY_EXECUTION=local
 
 # Worker model routing. The MCP server composes "<provider>/<model>" for

package/config/profiles/hosted.env

@@ -0,0 +1,6 @@
+# Hosted workers only: no local model on this machine. Every job runs on an
+# api or subscription agent (nomarmy agents add); the sandbox, git worktrees
+# and verification still run here. `nomarmy setup --hosted` writes this
+# mode into config/common.env as well, so the MCP server knows it.
+NOMARMY_PROFILE=hosted
+NOMARMY_EXECUTION=hosted

package/config/profiles/remote.env

@@ -0,0 +1,9 @@
+# A llama-server nomArmy doesn't run, e.g. a team's GPU server or an SSH
+# tunnel to one. Set its address with `nomarmy setup --llama-url
+# http://host:8080`, which writes NOMARMY_LLAMA_HOST / NOMARMY_LLAMA_PORT
+# into config/common.env. nomArmy
+# doesn't start, stop or size that server; the sandbox, git worktrees and
+# verification still run on this machine.
+NOMARMY_PROFILE=remote
+NOMARMY_EXECUTION=remote
+NOMARMY_MAX_WORKERS=1

package/e2e.sh

@@ -24,6 +24,12 @@ load_profile "$PROFILE"
 
 echo "=== nomArmy E2E: $NOMARMY_PROFILE ==="
 
+if [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  echo "e2e.sh runs a job on the local model, and profile '$NOMARMY_PROFILE' has none."
+  echo "Check each agent with: nomarmy doctor"
+  exit 0
+fi
+
 "$ROOT/scripts/start-inference.sh" "$NOMARMY_PROFILE"
 
 if nomarmy_is_cloud; then
@@ -56,18 +62,35 @@ fi
 # bind-mounting paths under the host home directory, and the cleanup step
 # below bind-mounts this directory into a container.
 TMP="$(mktemp -d "$HOME/.nomarmy-e2e.XXXXXX")"
+# OpenClaw's own state for this run, also under $HOME, the way nomArmy's
+# real dispatch keeps it (--state-dir). Left unset, OpenClaw puts its
+# working files in the system temp folder, which the Podman sandbox can't
+# mount on macOS, and it uses the operator's main state, whose memory index
+# holds their past sessions.
+STATE="$(mktemp -d "$HOME/.nomarmy-e2e-state.XXXXXX")"
 
 cleanup() {
   local exit_code=$?
 
-  if [[ -n "${TMP:-}" && -d "$TMP" ]]; then
+  # OpenClaw leaves this run's sandbox container running; its name carries
+  # the hash recorded under the state dir (as nomArmy's job cleanup does).
+  if [[ -n "${STATE:-}" && -d "$STATE/state/sandbox/skills-workspaces" ]] && command -v podman >/dev/null 2>&1; then
+    for ws in "$STATE"/state/sandbox/skills-workspaces/workspace-*; do
+      [[ -d "$ws" ]] || continue
+      podman ps -a --filter "name=${ws##*/workspace-}" --format '{{.Names}}' 2>/dev/null \
+        | xargs -r podman rm -f -v >/dev/null 2>&1 || true
+    done
+  fi
+
+  for dir in "${TMP:-}" "${STATE:-}"; do
+  if [[ -n "$dir" && -d "$dir" ]]; then
 
     # OpenClaw's Podman sandbox may create files that the host user
     # cannot delete directly. Use a disposable container to clean
     # the temporary workspace first.
     if command -v podman >/dev/null 2>&1 && podman info >/dev/null 2>&1; then
       podman run --rm \
-        -v "$TMP:/cleanup" \
+        -v "$dir:/cleanup" \
         alpine:3.20 \
         sh -c '
           find /cleanup -mindepth 1 -maxdepth 1 -exec rm -rf -- {} + \
@@ -76,13 +99,14 @@ cleanup() {
         >/dev/null 2>&1 || true
     fi
 
-    rm -rf "$TMP" 2>/dev/null || true
+    rm -rf "$dir" 2>/dev/null || true
 
-    if [[ -d "$TMP" ]]; then
+    if [[ -d "$dir" ]]; then
       echo "WARN: E2E temporary directory could not be completely removed:"
-      echo "      $TMP"
+      echo "      $dir"
     fi
   fi
+  done
 
   exit "$exit_code"
 }
@@ -126,15 +150,29 @@ PROMPT='Fix the bug so npm test passes. Work only in the workspace. Run npm test
 
 OUT="$TMP/openclaw.json"
 
+# The same privacy settings every nomArmy job gets (lib/openclaw-run.mjs
+# withJobPrivacy): OpenClaw's memory search and session-memory hook off, so
+# nothing is indexed or sent for embedding.
+CONFIG="$STATE/openclaw.job.json"
+mkdir -p "$STATE/state"
+node --input-type=module -e '
+  import fs from "node:fs";
+  import { readOpenclawConfig } from "'"$ROOT"'/lib/openclaw-config.mjs";
+  import { withJobPrivacy } from "'"$ROOT"'/lib/openclaw-run.mjs";
+  fs.writeFileSync(process.argv[1], JSON.stringify(withJobPrivacy(readOpenclawConfig() ?? {})), { mode: 0o600 });
+' "$CONFIG"
+
 openclaw agent exec "$PROMPT" \
   --model "$NOMARMY_WORKER_PROVIDER/$NOMARMY_WORKER_MODEL" \
   --cwd "$TMP" \
+  --state-dir "$STATE/state" \
+  --config "$CONFIG" \
   --code-mode direct \
   --local-model-lean \
   --thinking off \
   --timeout 600 \
   --json \
-  > "$OUT"
+  > "$OUT" 2> "$STATE/openclaw.stderr.log"
 
 # Independent verification. We do not trust the worker's claim
 # that its implementation is correct.

package/install.sh

@@ -15,7 +15,7 @@ case "$OS_NAME" in
     command -v curl >/dev/null 2>&1 || brew install curl
     command -v git >/dev/null 2>&1 || brew install git
     command -v node >/dev/null 2>&1 || brew install node
-    if ! nomarmy_is_cloud; then
+    if nomarmy_manages_model_server; then
       command -v xcode-select >/dev/null 2>&1 && xcode-select -p >/dev/null 2>&1 || { echo 'ERROR: Xcode Command Line Tools are required. Run: xcode-select --install'; exit 1; }
       command -v cmake >/dev/null 2>&1 || brew install cmake
     fi
@@ -24,8 +24,8 @@ case "$OS_NAME" in
     command -v podman >/dev/null 2>&1 || brew install podman
     ;;
   Linux)
-    if nomarmy_is_cloud; then
-      # No local model is built or served, so the C++ toolchain is not needed.
+    if ! nomarmy_manages_model_server; then
+      # No model is built or served here, so the C++ toolchain is not needed.
       need curl; need git; need node; need npm
     else
       if ! command -v cmake >/dev/null 2>&1 || ! command -v c++ >/dev/null 2>&1 || ! command -v curl >/dev/null 2>&1 || ! command -v git >/dev/null 2>&1 || ! command -v node >/dev/null 2>&1 || ! command -v npm >/dev/null 2>&1; then install_build_dependencies; fi
@@ -105,7 +105,7 @@ if ! command -v openclaw >/dev/null 2>&1; then
   export PATH="$HOME/.local/bin:$HOME/.npm-global/bin:$PATH"
 fi
 need openclaw
-if ! nomarmy_is_cloud; then openclaw plugins install @openclaw/llama-cpp-provider || true; fi
+if nomarmy_has_local_model; then openclaw plugins install @openclaw/llama-cpp-provider || true; fi
 "$ROOT/scripts/start-inference.sh" "$NOMARMY_PROFILE"
 # Sandbox before provider config: configure-openclaw.sh refuses to store a real
 # Bedrock credential unless the coder sandbox is already network-isolated.
@@ -122,4 +122,8 @@ if nomarmy_is_cloud && [[ "${NOMARMY_ORCHESTRATOR_RUNTIME:-}" == "claude-code" ]
   echo "    ./scripts/configure-orchestrator.sh $NOMARMY_PROFILE          # print the settings"
   echo "    ./scripts/configure-orchestrator.sh $NOMARMY_PROFILE --apply  # write them to Claude Code"
 fi
-echo "==> Install complete. Run: ./e2e.sh --profile $NOMARMY_PROFILE"
+if [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  echo "==> Install complete. Add an agent (nomarmy agents add), give roles to it (nomarmy army init --agent <name>), then run: nomarmy doctor"
+else
+  echo "==> Install complete. Run: ./e2e.sh --profile $NOMARMY_PROFILE"
+fi