nomarmy 0.1.0-alpha.4 → 0.1.0-alpha.5

package/lib/admission.mjs

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { executionMode } from "./execution.mjs";
+import { loadConfig } from "./config.mjs";
 import { clampInt } from "./budget-state.mjs";
 import { checkBrief, assessAdmission, describeBudgets } from "./budget.mjs";
 import { parseStatusPorcelainZ, isRuntimeJunk } from "./git-record.mjs";
@@ -9,7 +10,8 @@ import { readOpenClawTranscriptTail } from "./transcript.mjs";
 import { readClaudeSessionTranscript } from "./claude-transcript.mjs";
 import { notify } from "./notify.mjs";
 import { readCodexRateLimits, recordUsageSnapshot, readUsageSnapshots, usageStatus } from "./usage-limits.mjs";
-import { recentModelRefusal } from "./health.mjs";
+import { projectDirProblem } from "./server-context.mjs";
+import { recentModelRefusal, refusedModelIn, recordModelRefusal, clearModelRefusal } from "./health.mjs";
 import { writeLease, removeLease, liveLeases, liveSlots, acquireSlot } from "./slots.mjs";
 import { loadRun, runTotals, runAdmissionProblems, recordRunJob, detectUsageLimit } from "./runs.mjs";
 import { agentProviderId, hostToolsImplementProblem } from "./agents.mjs";
@@ -22,7 +24,7 @@ import { policyAdmissionProblems } from "./outcome.mjs";
 // Claude or Codex job took llama-server's only slot and blocked local work
 // it never competed with -- reported from a real Senti run.
 export function jobLane(job) {
-  return job.pool || job.subscription_worker ? "remote" : "local";
+  return job.mode === "verify" || job.pool || job.subscription_worker ? "remote" : "local";
 }
 
 // A static, operator-declared ceiling on how many remote jobs (api and
@@ -114,7 +116,7 @@ export function createJobRuntime(deps) {
    * batch queue for a slot instead of failing.
    */
   function withAgentSlot(args, jobId, fn, { waitMs = 0 } = {}) {
-    const max = args.agentName ? agentMaxConcurrent(args.agentName) : null;
+    const max = args.mode !== "verify" && args.agentName ? agentMaxConcurrent(args.agentName) : null;
     if (!max) return fn();
     return (async () => {
       const slot = await acquireSlot(slotsRoot, args.agentName, max, { jobId, waitMs });
@@ -148,8 +150,14 @@ export function createJobRuntime(deps) {
     } catch { /* Usage telemetry must never affect the job result. */ }
     if (!entry.lane) return; // only tracked jobs, never internal helpers
     const m = result?.manifest ?? {};
+    // Remember a model its vendor refused, until something on it works.
+    try {
+      const refused = refusedModelIn(m);
+      if (refused) recordModelRefusal(stateRoot, refused, String(m.workerError ?? m.worker?.error ?? "").split("\n")[0].slice(0, 300) || null);
+      else if (m.worker?.provider && m.worker?.model && !m.workerError && !error) clearModelRefusal(stateRoot, `${m.worker.provider}/${m.worker.model}`);
+    } catch { /* best-effort, like the usage reading */ }
     const outcome = error ? "failed" : String(m.outcome ?? (result?.ok ? "done" : "finished")).toLowerCase().replace(/_/g, " ");
-    const who = entry.agent ? `${entry.agent}${entry.model ? `/${entry.model}` : ""}` : "local model";
+    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."}`);
@@ -173,12 +181,14 @@ export function createJobRuntime(deps) {
     };
   }
   async function admit(jobs) {
-    await deps.budgetState.refresh();
-    if (jobs.some((j) => jobLane(j) === "remote")) await modelCatalogReady();
+    if (jobs.some(j => j.mode !== "verify")) await deps.budgetState.refresh();
+    if (jobs.some((j) => j.mode !== "verify" && jobLane(j) === "remote")) await modelCatalogReady();
     const problems = [];
+    const notARepo = (deps.projectDirProblem ?? projectDirProblem)(projectDir);
+    if (notARepo) problems.push(notARepo);
     const snapshots = readUsageSnapshots(stateRoot);
     jobs.forEach((j, i) => {
-      if (!j.agentName || j.confirm_over_limit === true) return;
+      if (j.mode === "verify" || !j.agentName || j.confirm_over_limit === true) return;
       let provider;
       try { provider = agentProviderId(agentsConfig().agents[j.agentName]); } catch { return; }
       const snapshot = snapshots[provider];
@@ -195,6 +205,13 @@ export function createJobRuntime(deps) {
     // (see budgetsForSubscriptionWorker) -- there's no "which entry" unknown
     // the way a weighted pool has, since the name given IS the entry.
     jobs.forEach((j, i) => {
+      if (j.mode === "verify") {
+        try {
+          const profiles = Object.keys(loadConfig(projectDir)?.config?.verification ?? {});
+          if (!j.verification || !profiles.includes(j.verification)) problems.push(`${jobs.length > 1 ? `job ${i + 1}: ` : ""}verify requires a verification profile from .nomarmy.yml; available profiles: ${profiles.join(", ") || "(none)"}`);
+        } catch (error) { problems.push(error.message); }
+        return;
+      }
       const jobBudgets = budgetsForJob(j);
       for (const p of checkBrief(j, jobBudgets)) problems.push(jobs.length > 1 ? `job ${i + 1}: ${p}` : p);
     });
@@ -213,6 +230,7 @@ export function createJobRuntime(deps) {
     // clean, so a missing on_behalf_of is never reported twice in two
     // different shapes.
     jobs.forEach((j, i) => {
+      if (j.mode === "verify") return;
       const fieldProblems = subscriptionJobFieldProblems(j);
       for (const p of fieldProblems) problems.push(jobs.length > 1 ? `job ${i + 1}: ${p}` : p);
       if (fieldProblems.length === 0 && j.on_behalf_of) {
@@ -228,7 +246,7 @@ export function createJobRuntime(deps) {
     // Claude CLI) isn't bounded by the sandbox, so it's refused unless that
     // agent says allow_host_tools (lib/agents.mjs). Scouts and reviews still run.
     jobs.forEach((j, i) => {
-      if (!j.agentName || (j.mode ?? "implement") !== "implement") return;
+      if (j.mode === "verify" || !j.agentName || (j.mode ?? "implement") !== "implement") return;
       let problem = null;
       try { problem = hostToolsImplementProblem(j.agentName, agentsConfig().agents[j.agentName]); } catch { return; }
       if (problem) problems.push(`${jobs.length > 1 ? `job ${i + 1}: ` : ""}${problem}`);
@@ -236,7 +254,7 @@ export function createJobRuntime(deps) {
     // A model its vendor refused on a job today, with nothing working on it
     // since, isn't sent another job (lib/health.mjs recentModelRefusal).
     jobs.forEach((j, i) => {
-      if (!j.agentName || !j.model) return;
+      if (j.mode === "verify" || !j.agentName || !j.model) return;
       let provider = null;
       try { provider = agentProviderId(agentsConfig().agents[j.agentName]); } catch { return; }
       if (!provider) return;
@@ -247,7 +265,7 @@ export function createJobRuntime(deps) {
     // queue for its slot at launch instead (withAgentSlot's waitMs).
     if (jobs.length === 1) {
       const [j] = jobs;
-      const max = j.agentName ? agentMaxConcurrent(j.agentName) : null;
+      const max = j.mode !== "verify" && j.agentName ? agentMaxConcurrent(j.agentName) : null;
       const held = max ? liveSlots(slotsRoot, j.agentName) : 0;
       if (max && held >= max) problems.push(`not admitted (capacity): agent "${j.agentName}" already has ${held} job(s) running across this machine's nomArmy sessions, at its max_concurrent of ${max}`);
     }
@@ -258,7 +276,7 @@ export function createJobRuntime(deps) {
         const run = loadRun(runsRoot, j.run_id);
         if (run.repo !== projectDir) problems.push(`${jobs.length > 1 ? `job ${i + 1}: ` : ""}run "${run.id}" belongs to ${run.repo}, not this repository`);
         const running = liveLeases(leasesRoot, { runId: run.id }).length + jobs.slice(0, i).filter((o) => o.run_id === run.id).length;
-        for (const p of runAdmissionProblems(run, { agentName: j.agentName ?? "local", running })) problems.push(jobs.length > 1 ? `job ${i + 1}: ${p}` : p);
+        for (const p of runAdmissionProblems(run, { agentName: j.mode === "verify" ? null : j.agentName ?? "local", running })) problems.push(jobs.length > 1 ? `job ${i + 1}: ${p}` : p);
       } catch (error) { problems.push(jobs.length > 1 ? `job ${i + 1}: ${error.message}` : error.message); }
     });
     // Slot capacity only concerns local jobs: a remote job's inference runs
@@ -271,7 +289,7 @@ export function createJobRuntime(deps) {
     const anyLocal = jobs.some((j) => jobLane(j) === "local");
     const admission = anyLocal
       ? assessAdmission({ hardware: admissionHardware(), runningJobs: runningCount("local"), slots: deps.budgetState.contextInfo.slots, maxWorkers: currentMaxWorkers() })
-      : assessAdmission({ hardware: admissionHardware(), runningJobs: 0, slots: null, maxWorkers: Infinity });
+      : assessAdmission({ hardware: jobs.every(j => j.mode === "verify") ? null : admissionHardware(), runningJobs: 0, slots: null, maxWorkers: Infinity });
     if (!admission.admit) problems.push(...admission.reasons.map(r => `not admitted (${admission.level}): ${r}`));
     if (jobs.some((j) => jobLane(j) === "remote")) {
       const remoteCeiling = currentMaxPoolWorkers(), runningRemote = runningCount("remote");
@@ -302,17 +320,17 @@ export function createJobRuntime(deps) {
    */
   function recordJobInRun(args, jobId, result, error = null) {
     if (!args.run_id) return;
-    const kind = args.pool ? "api" : args.subscription_worker ? "subscription" : "local";
+    const kind = args.mode === "verify" ? "verify" : args.pool ? "api" : args.subscription_worker ? "subscription" : "local";
     const m = result?.manifest ?? {};
     const errorLines = [m.worker?.error, error?.message,
       ...String(m.workerError ?? "").split(/\r?\n/).filter((l) => /error|limit|429/i.test(l))].filter(Boolean).join("\n");
-    const usageLimit = kind === "local" ? null : detectUsageLimit(errorLines);
+    const usageLimit = (kind === "local" || kind === "verify") ? null : detectUsageLimit(errorLines);
     try {
       const before = runTotals(loadRun(runsRoot, args.run_id)).warnings;
       const updated = recordRunJob(runsRoot, args.run_id, {
-        jobId, agent: args.agentName ?? "local", kind, model: args.model ?? null, role: args.armyRole ?? null, mode: args.mode,
-        outcome: m.outcome ?? (error ? "ERROR" : null), costUsd: m.metrics?.worker_cost_usd ?? null,
-        tokens: m.metrics?.worker_tokens_total ?? null, usageLimit,
+        jobId, agent: kind === "verify" ? null : args.agentName ?? "local", kind, model: kind === "verify" ? null : args.model ?? null, role: args.armyRole ?? null, mode: args.mode,
+        outcome: m.outcome ?? (error ? "ERROR" : null), costUsd: kind === "verify" ? 0 : m.metrics?.worker_cost_usd ?? null,
+        tokens: kind === "verify" ? 0 : m.metrics?.worker_tokens_total ?? null, usageLimit,
       });
       // A limit crossed or an agent paused by this job is worth interrupting for.
       const fresh = runTotals(updated).warnings.filter((w) => !before.includes(w) && /OVER|paused/.test(w));
@@ -380,6 +398,7 @@ export function createJobRuntime(deps) {
       timeoutSeconds: status?.timeoutSeconds ?? null, coordinatorStatus: meta?.coordinatorStatus ?? null, outcome: meta?.outcome ?? null,
       reviewRequired: meta?.reviewRequired ?? null, issues: (meta?.issues ?? []).slice(0, 6), worktree: meta?.worktree ?? null, branch: meta?.branch ?? null,
       commit: meta?.commit?.sha ?? null, scout: meta?.scout ? { supported: meta.scout.supported, unsupported: meta.scout.unsupported } : null };
+    if (meta?.mode === "verify") Object.assign(out, { verification: meta.verification, baseRef: meta.baseRef, baseSha: meta.baseSha });
     if (entry && !entry.settled) out.state = "running";
     else if (entry?.error) { out.state = "failed"; out.error = String(entry.error.message ?? entry.error).split("\n")[0]; }
     else if (meta) out.state = "finished";

package/lib/army.mjs

@@ -404,7 +404,7 @@ export function describeArmy(loaded, { agents = {}, describeAgent = null, usageS
     roles,
     layers: loaded.layers,
     howToDispatch: Object.keys(roles).length
-      ? "Pass army_role: \"<role>\" on a job (plus on_behalf_of when its agent is a subscription). The role's description goes at the top of the brief; set `mode` on the job yourself, the role's is only a suggestion. A role with model \"auto\" needs model on the job, picked from that agent's models below; any job may pass model to override the role's. Use agent: \"<name>\" instead to pick an agent directly."
+      ? "Pass army_role: \"<role>\" on a job (plus on_behalf_of when its agent is a subscription). The role's description goes at the top of the brief; set `mode` on the job yourself, the role's is only a suggestion. A role with model \"auto\" needs model on the job, picked from that agent's models below (never its refusedModels: its vendor turned those down on a job); any job may pass model to override the role's. Use agent: \"<name>\" instead to pick an agent directly."
       : "No army is configured. Run `nomarmy army init` for the default roster, or dispatch with agent: \"<name>\".",
   };
 }

package/lib/connect.mjs

@@ -45,8 +45,10 @@ export function defaultInstallDir() {
 // `<!-- nomarmy:... -->` marker; a same-named file WITHOUT it is the
 // operator's own and is never overwritten, only reported as skipped.
 //   Claude Code  ~/.claude/commands/feature.md          -> /feature <request>
-//   Codex        ~/.codex/skills/nomarmy-feature/SKILL.md (confirmed from
-//                codex 0.156's own $CODEX_HOME/skills loader)
+//   Codex        ~/.agents/skills/nomarmy-feature/SKILL.md (where the Codex
+//                CLI, desktop app and IDE extension all look for user
+//                skills; older nomArmy put it in $CODEX_HOME/skills, which
+//                connectCodex cleans up)
 //   Cursor       ~/.cursor/commands/feature.md (Cursor's documented
 //                user-level commands directory; not verified against a
 //                real install here)
@@ -63,7 +65,7 @@ export function defaultCommandDirs(env = process.env) {
   const home = os.homedir();
   return {
     claude: env.NOMARMY_CLAUDE_COMMANDS_DIR ? path.resolve(env.NOMARMY_CLAUDE_COMMANDS_DIR) : path.join(home, ".claude", "commands"),
-    codex: env.NOMARMY_CODEX_SKILLS_DIR ? path.resolve(env.NOMARMY_CODEX_SKILLS_DIR) : path.join(env.CODEX_HOME || path.join(home, ".codex"), "skills"),
+    codex: env.NOMARMY_CODEX_SKILLS_DIR ? path.resolve(env.NOMARMY_CODEX_SKILLS_DIR) : path.join(home, ".agents", "skills"),
     cursor: env.NOMARMY_CURSOR_COMMANDS_DIR ? path.resolve(env.NOMARMY_CURSOR_COMMANDS_DIR) : path.join(home, ".cursor", "commands"),
   };
 }
@@ -334,15 +336,32 @@ export function connectClaude({ nomarmyRoot, installDir = defaultInstallDir(), r
 /**
  * @param {{ nomarmyRoot: string, installDir?: string, run?: Function }} input
  */
-export function connectCodex({ nomarmyRoot, installDir = defaultInstallDir(), run = defaultRun, skillsDir = defaultCommandDirs().codex }) {
+export function connectCodex({ nomarmyRoot, installDir = defaultInstallDir(), run = defaultRun, configDir = globalConfigDir(), skillsDir = defaultCommandDirs().codex, legacySkillsDir = path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "skills") }) {
   installMcpCopy({ nomarmyRoot, installDir, run });
   const commands = installPlaybooks({ nomarmyRoot, target: "codex", dir: skillsDir });
+  removeLegacyCodexSkill(legacySkillsDir, skillsDir);
   const notifier = buildNotifierApp({ nomarmyRoot });
+  // The same environment Claude's registration gets (connectClaude): the
+  // install's execution mode and worker model always win, anything else an
+  // operator set on the old registration is kept.
+  let preservedEnv = {};
+  try { preservedEnv = JSON.parse(run("codex", ["mcp", "get", SERVER_NAME, "--json"], { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" }))?.transport?.env ?? {}; } catch { /* not registered yet */ }
+  const finalEnv = { ...derivePoolAuthEnvPlaceholders(configDir), ...preservedEnv, ...deriveWorkerModelEnv(nomarmyRoot) };
   quietRun(run, "codex", ["mcp", "remove", SERVER_NAME]);
   const serverPath = path.join(installDir, "mcp", "server.mjs");
-  run("codex", ["mcp", "add", SERVER_NAME, "--", "node", serverPath]);
+  const envArgs = Object.entries(finalEnv).flatMap(([k, v]) => ["--env", `${k}=${v}`]);
+  run("codex", ["mcp", "add", SERVER_NAME, ...envArgs, "--", "node", serverPath]);
   run("codex", ["mcp", "list"]);
-  return { installDir, serverPath, commands, notifier };
+  return { installDir, serverPath, preservedEnv: finalEnv, commands, notifier };
+}
+
+/** Remove the skill older nomArmy installed under $CODEX_HOME/skills (only nomArmy's own copy, by its marker). */
+function removeLegacyCodexSkill(legacyDir, currentDir) {
+  const file = path.join(legacyDir, "nomarmy-feature", "SKILL.md");
+  if (path.resolve(legacyDir) === path.resolve(currentDir)) return;
+  try {
+    if (fs.readFileSync(file, "utf8").includes(COMMAND_MARKER)) fs.rmSync(path.dirname(file), { recursive: true, force: true });
+  } catch { /* nothing there */ }
 }
 
 export function defaultCursorConfigPath() {
@@ -381,7 +400,7 @@ export function readCursorConfig(configPath) {
 /**
  * @param {{ nomarmyRoot: string, installDir?: string, configPath?: string }} input
  */
-export function connectCursor({ nomarmyRoot, installDir = defaultInstallDir(), configPath = defaultCursorConfigPath(), run = defaultRun, commandsDir = defaultCommandDirs().cursor }) {
+export function connectCursor({ nomarmyRoot, installDir = defaultInstallDir(), configPath = defaultCursorConfigPath(), run = defaultRun, configDir = globalConfigDir(), commandsDir = defaultCommandDirs().cursor }) {
   installMcpCopy({ nomarmyRoot, installDir, run });
   const commands = installPlaybooks({ nomarmyRoot, target: "cursor", dir: commandsDir });
   const notifier = buildNotifierApp({ nomarmyRoot });
@@ -392,8 +411,12 @@ export function connectCursor({ nomarmyRoot, installDir = defaultInstallDir(), c
   // connectClaude's captureExistingEnv guards against: silently dropping an
   // operator-set NOMARMY_WORKER_MODEL on every reinstall) -- every OTHER
   // configured server in the file is left completely untouched.
+  // As for Claude and Codex, the install's own settings (execution mode,
+  // worker model, api-key placeholders) win over whatever the entry had.
   const existing = config.mcpServers[SERVER_NAME];
-  const preservedEnv = (existing && typeof existing.env === "object" && existing.env) || {};
+  // Cursor starts a global MCP server in the home folder, not the open
+  // project; ${workspaceFolder} is Cursor's own placeholder for the latter.
+  const preservedEnv = { ...derivePoolAuthEnvPlaceholders(configDir), ...((existing && typeof existing.env === "object" && existing.env) || {}), ...deriveWorkerModelEnv(nomarmyRoot), NOMARMY_PROJECT_DIR: "${workspaceFolder}" };
   config.mcpServers[SERVER_NAME] = { command: "node", args: [serverPath], env: preservedEnv };
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");

package/lib/coordinator-instructions.mjs

@@ -13,6 +13,7 @@ Before dispatching:
 - Call army to see this repo's roles and which agent each runs on; dispatch by army_role when a role fits. A job on a subscription agent needs on_behalf_of set to that agent's owner.
 - Agents' usage limits show in army and local_worker_capacity; a job on an agent at its limit is held. Ask the operator before resubmitting with confirm_over_limit: true, or move the job to another agent. Never set it on your own.
 - A Claude subscription agent (claude-cli) runs its tools on this machine, outside the sandbox: use it for scout and review work. nomArmy refuses implement jobs on it unless the operator set allow_host_tools; send build work to a sandboxed agent.
+- To run tests without changing anything, use mode: verify; it costs no model usage.
 - Brief outcomes, not edits: a task, explicit acceptance criteria, and the tests that prove it. Put facts you've already resolved in evidence.
 - Prefer local_worker_start + local_worker_status for anything longer than a few minutes. For a whole feature, use /feature (run_start keeps a run's jobs, spend and hours bounded).
 

package/lib/execute.mjs

@@ -40,7 +40,7 @@ export function createExecutor(deps) {
     ensureJobsRoot();
     // Fire-and-forget: sweeps whatever this or any other nomArmy install left
     // behind, without adding container-CLI round-trip latency to this job's own start.
-    sweepStaleSandboxContainers().catch(() => {});
+    if (mode !== "verify") sweepStaleSandboxContainers().catch(() => {});
     const jobStartedMs = Date.now();
     const base = await resolveBase(baseRef), jobId = presetJobId || slug(workerId || (mode === "scout" ? "scout" : mode === "decompose" ? "decompose" : "worker")), jobDir = path.join(jobsRoot, jobId), runtimeDir = path.join(jobDir, "runtime");
     fs.mkdirSync(runtimeDir, { recursive: true });
@@ -48,13 +48,44 @@ export function createExecutor(deps) {
       jobId, workerId: workerId || jobId, mode, phase, state: phase === "finished" ? "finished" : "running",
       serverPid: process.pid, baseSha: base.sha, timeoutSeconds, ...extra
     });
-    progress("starting", { startedAt: new Date().toISOString(), agent: pool ?? subscriptionWorker ?? "local", model: model ?? null });
+    progress("starting", { startedAt: new Date().toISOString(), agent: mode === "verify" ? null : pool ?? subscriptionWorker ?? "local", model: model ?? null });
     const common = { task, acceptance, base, jobId, jobDir, runtimeDir, timeoutSeconds, profile, reasoning, pool, subscriptionWorker, onBehalfOf, model, reportSize, workerId, progress, jobStartedMs };
+    if (mode === "verify") return executeVerify({ ...common, verification });
     if (mode === "scout") return executeScout(common);
     if (mode === "decompose") return executeDecompose(common);
     return executeImplement({ ...common, verification, evidence, verifyRegression, commitSubject, refactor });
   }
 
+  async function executeVerify({ task, verification: profile, base, jobId, jobDir, workerId, progress, jobStartedMs }) {
+    const worktree = path.join(jobDir, "worktree");
+    let verification, record = null, error = null;
+    try {
+      progress("worktree");
+      await run("git", ["worktree", "add", "--detach", worktree, base.sha], { cwd: projectDir });
+      record = await collectGitRecord({ cwd: worktree, baseSha: base.sha, baseRef: base.ref, branch: null, jobId });
+      progress("verification");
+      verification = await runIndependentVerification({ profile, cwd: worktree, jobId, baseSha: base.sha, branch: null, mode: "verify", record, logFile: path.join(jobDir, "verification.log") });
+    } catch (err) {
+      error = err.message;
+      verification = normalizeVerification({ status: "not_run", reason: error }, profile);
+    } finally {
+      try { await run("git", ["worktree", "remove", "--force", worktree], { cwd: projectDir }); }
+      catch (err) { error = [error, err.message].filter(Boolean).join("\n"); }
+    }
+    const retained = fs.existsSync(worktree);
+    const outcome = retained ? OUTCOMES.VERIFICATION_NOT_RUN : {
+      pass: OUTCOMES.VERIFIED, fail: OUTCOMES.VERIFICATION_FAILED, not_run: OUTCOMES.VERIFICATION_NOT_RUN
+    }[verification.status];
+    const manifest = { version: VERSION, jobId, workerId: workerId || jobId, mode: "verify", task,
+      baseRef: base.ref, baseSha: base.sha, branch: null, worktree: retained ? worktree : null, worktreeRetained: retained,
+      startedAt: new Date(jobStartedMs).toISOString(), finishedAt: new Date().toISOString(),
+      outcome, coordinatorStatus: COORDINATOR_STATUS_BY_OUTCOME[outcome], verification, git: record, error,
+      metrics: { total_elapsed: Date.now() - jobStartedMs, worker_cost_usd: 0, worker_tokens_total: 0, model_calls: 0 } };
+    fs.writeFileSync(path.join(jobDir, "metadata.json"), JSON.stringify(manifest, null, 2));
+    progress("finished", { outcome, coordinatorStatus: manifest.coordinatorStatus });
+    return { ok: outcome === OUTCOMES.VERIFIED, manifest, jobDir, report: "" };
+  }
+
   async function executeImplement({ task, acceptance, verification, base, jobId, jobDir, runtimeDir, timeoutSeconds, profile, reasoning, pool = null, subscriptionWorker = null, onBehalfOf = null, model = null, reportSize = null, workerId, evidence, verifyRegression = false, commitSubject = null, refactor = false, progress, jobStartedMs }) {
     const mode = "implement";
     let branch = `agent/${jobId}`, worktree = path.join(jobDir, "worktree");

package/lib/health.mjs

@@ -94,16 +94,21 @@ export function armyIssues(summary, mode = "local") {
  * from job records. A listed model isn't proof it runs: Muse was listed
  * while every job on it failed this way (a real Senti review).
  */
+/** The "<provider>/<model>" a job record says its vendor refused, or null. */
+export function refusedModelIn(record) {
+  const text = `${record?.workerError ?? ""} ${record?.worker?.error ?? ""}`;
+  // A job's own model_not_found line first (mcp/server.mjs names the model
+  // it attempted), then any raw vendor wording in older records.
+  const tagged = /model_not_found: ([\w.-]+\/[\w.:-]+)/.exec(text)?.[1];
+  return (tagged ?? modelRejection(text)?.model)?.replace(/[.:]+$/, "") ?? null; // the sentence's own trailing period isn't part of the name
+}
+
 export function unknownModelIssues(jobRecords, { now = Date.now(), inUse = null, probedOk = {} } = {}) {
   const failed = new Map(), lastOk = new Map(Object.entries(probedOk));
   for (const m of jobRecords) {
     const at = Date.parse(m.finishedAt ?? "");
     if (now - at > DAY) continue;
-    const text = `${m.workerError ?? ""} ${m.worker?.error ?? ""}`;
-    // A job's own model_not_found line first (mcp/server.mjs names the model
-    // it attempted), then any raw vendor wording in older records.
-    const tagged = /model_not_found: ([\w.-]+\/[\w.:-]+)/.exec(text)?.[1];
-    const model = (tagged ?? modelRejection(text)?.model)?.replace(/[.:]+$/, ""); // the sentence's own trailing period isn't part of the name
+    const model = refusedModelIn(m);
     if (model) { const f = failed.get(model) ?? { n: 0, last: 0 }; f.n++; f.last = Math.max(f.last, at); failed.set(model, f); }
     else if (m.worker?.provider && m.worker?.model && !m.workerError) {
       const ran = `${m.worker.provider}/${m.worker.model}`;
@@ -148,6 +153,28 @@ export function recordProbeSuccess(stateRoot, model, { now = Date.now() } = {})
   try { seen = JSON.parse(fs.readFileSync(file, "utf8")); } catch { /* first */ }
   seen[model] = new Date(now).toISOString();
   try { fs.writeFileSync(file, JSON.stringify(seen, null, 2)); } catch { /* best-effort */ }
+  clearModelRefusal(stateRoot, model);
+}
+
+// Models a vendor refused on a job, kept until a job or test call on them
+// works. A plan's model limit doesn't expire overnight (gpt-6-luna was
+// refused again days after the first time), so this isn't a 24-hour memory.
+// <stateRoot>/model-refusals.json: { "<provider>/<model>": { at, reason } }.
+const REFUSALS_FILE = "model-refusals.json";
+export function modelRefusals(stateRoot) {
+  try { const data = JSON.parse(fs.readFileSync(path.join(stateRoot, REFUSALS_FILE), "utf8")); return data && typeof data === "object" && !Array.isArray(data) ? data : {}; } catch { return {}; }
+}
+function writeRefusals(stateRoot, data) {
+  try { fs.mkdirSync(stateRoot, { recursive: true }); fs.writeFileSync(path.join(stateRoot, REFUSALS_FILE), JSON.stringify(data, null, 2)); } catch { /* best-effort */ }
+}
+export function recordModelRefusal(stateRoot, model, reason = null, { now = Date.now() } = {}) {
+  writeRefusals(stateRoot, { ...modelRefusals(stateRoot), [model]: { at: new Date(now).toISOString(), reason } });
+}
+export function clearModelRefusal(stateRoot, model) {
+  const data = modelRefusals(stateRoot);
+  if (!(model in data)) return;
+  delete data[model];
+  writeRefusals(stateRoot, data);
 }
 function readProbeSuccesses(stateRoot) {
   try { return Object.fromEntries(Object.entries(JSON.parse(fs.readFileSync(path.join(stateRoot, "probe-ok.json"), "utf8"))).map(([k, v]) => [k, Date.parse(v)])); } catch { return {}; }
@@ -160,6 +187,8 @@ function readProbeSuccesses(stateRoot) {
  * ChatGPT plan failed job after job before health noticed). The issue, or null.
  */
 export function recentModelRefusal(stateRoot, model, { now = Date.now() } = {}) {
+  const kept = modelRefusals(stateRoot)[model];
+  if (kept) return { id: `unknown-model:${model}`, severity: "warn", title: `${model} was refused on a job (${kept.at.slice(0, 10)}) and hasn't worked since`, detail: kept.reason ?? "The provider won't run it, though it may be listed in the catalog.", fix: "nomarmy army assign <role> <agent> <another model>", short: `${model.split("/").pop()} not running` };
   const jobsRoot = path.join(stateRoot, "jobs");
   const records = [];
   let names = [];

package/lib/job-format.mjs

@@ -77,7 +77,14 @@ function compactImplementRecord(m) {
     startedAt: m.startedAt ?? null, finishedAt: m.finishedAt ?? null,
     issues: m.issues ?? [], error: m.error ?? null };
 }
+function compactVerifyRecord(m) {
+  return { jobId: m.jobId, workerId: m.workerId, mode: m.mode, outcome: m.outcome,
+    coordinatorStatus: m.coordinatorStatus, baseRef: m.baseRef, baseSha: m.baseSha,
+    verification: m.verification, elapsedSeconds: Math.round(m.metrics.total_elapsed / 1000),
+    worktreeRetained: m.worktreeRetained, error: m.error };
+}
 export function compactJobRecord(meta) {
+  if (meta.mode === "verify") return compactVerifyRecord(meta);
   return meta.mode === "scout" ? compactScoutRecord(meta) : meta.mode === "decompose" ? compactDecomposeRecord(meta) : compactImplementRecord(meta);
 }
 
@@ -87,6 +94,7 @@ export function compactJobRecord(meta) {
 // worker said, including a truncated or garbled reply -- exactly backwards
 // for a tool whose whole premise is not trusting that reply.
 export function formatResult(r) {
+  if (r.manifest?.mode === "verify") return `OUTCOME: ${r.manifest.outcome}\n\n--- VERIFICATION RECORD ---\n${JSON.stringify(compactVerifyRecord(r.manifest), null, 2)}\n\nJob artifacts: ${r.jobDir}`;
   const banner = orchestratorTrust === "degraded" ? DEGRADED_BANNER : "";
   const outcomeLine = r.manifest?.outcome ? `OUTCOME: ${r.manifest.outcome}\n\n` : "";
   const workerReport = `--- WORKER REPORT (a claim, not evidence) ---\n${r.report}`;

package/lib/outcomes.mjs

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

package/lib/runs.mjs

@@ -80,10 +80,16 @@ function writeRun(runsDir, run) {
 export function createRun(runsDir, { name, repo, limits, now = Date.now() }) {
   const slug = String(name ?? "feature").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "feature";
   const id = `run-${slug}-${crypto.randomBytes(3).toString("hex")}`;
-  return writeRun(runsDir, {
+  const run = writeRun(runsDir, {
     id, name: name ?? slug, repo, status: "running", createdAt: new Date(now).toISOString(),
     limits, jobs: [], pausedAgents: {}, logPath: path.join(runsDir, `${id}.md`), finishedAt: null, summary: null,
   });
+  // The General keeps this log (playbooks/feature.md); start it with the
+  // sections it fills in, so the path it's handed already exists.
+  if (!fs.existsSync(run.logPath)) {
+    fs.writeFileSync(run.logPath, `# ${run.name} (${id})\n\nRepository: ${repo}\nStarted: ${run.createdAt}\n\n## Plan\n\n## Decisions\n\n## Jobs\n\n## Review\n\n## What's left\n`);
+  }
+  return run;
 }
 
 export function loadRun(runsDir, id) {

package/lib/server-context.mjs

@@ -1,8 +1,17 @@
 import os from "node:os";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 
+// The repository jobs run against: NOMARMY_PROJECT_DIR (set by `nomarmy
+// connect cursor` to Cursor's ${workspaceFolder}), else Claude Code's
+// CLAUDE_PROJECT_DIR, else the folder the server was started in (Claude Code
+// and Codex start it in the open project; Cursor starts a global server in
+// the home folder). A value still holding an unexpanded ${...} counts as
+// unset, and a leading ~ is the home folder (Cursor fills ${workspaceFolder}
+// in as "~/...", and nothing on the way expands it).
 export function createServerContext({ env = process.env, homedir = os.homedir(), cwd = process.cwd() } = {}) {
-  const projectDir = path.resolve(env.CLAUDE_PROJECT_DIR || cwd);
+  const fromEnv = [env.NOMARMY_PROJECT_DIR, env.CLAUDE_PROJECT_DIR].find((v) => v && !v.includes("${"));
+  const projectDir = path.resolve(fromEnv ? fromEnv.replace(/^~(?=$|[\\/])/, homedir) : cwd);
   const stateRoot = env.NOMARMY_AGENT_STATE || path.join(homedir, ".local", "share", "nomarmy-local-agents");
   const jobsRoot = path.join(stateRoot, "jobs");
   const runsRoot = path.join(stateRoot, "runs");
@@ -11,3 +20,14 @@ export function createServerContext({ env = process.env, homedir = os.homedir(),
   const slotsRoot = path.join(stateRoot, "slots");
   return Object.freeze({ projectDir, stateRoot, jobsRoot, runsRoot, leasesRoot, slotsRoot });
 }
+
+/**
+ * Why jobs can't run against projectDir, or null. Jobs need a git
+ * repository (worktrees, nomArmy's commits); anything else, like the home
+ * folder a coordinator started the server in, is refused before dispatch.
+ */
+export function projectDirProblem(projectDir, { run = (args) => spawnSync("git", args, { encoding: "utf8" }) } = {}) {
+  const result = run(["-C", projectDir, "rev-parse", "--is-inside-work-tree"]);
+  if (result.status === 0 && String(result.stdout).trim() === "true") return null;
+  return `nomArmy's project folder is ${projectDir}, which isn't a git repository, so no job was sent. The coordinator started nomArmy's server outside the project: set NOMARMY_PROJECT_DIR to the repository in its MCP settings (\`nomarmy connect cursor\` does this for Cursor), or start the coordinator from inside the repository.`;
+}

package/lib/verification-flow.mjs

@@ -230,7 +230,15 @@ export function createVerificationFlow(deps) {
       return normalizeVerification({ status: "not_run", basis: "none",
         reason: "no verification runner registered; profile execution is owned by the verification component" }, context.profile);
     }
-    try { return normalizeVerification(await verificationRunner(context), context.profile); }
+    try {
+      const value = await verificationRunner(context);
+      const normalized = normalizeVerification(value, context.profile);
+      // A caller that asks for a log (mode: verify) gets the full output kept.
+      if (context.logFile && typeof value?.output === "string") {
+        try { fs.writeFileSync(context.logFile, value.output); normalized.log = context.logFile; } catch { /* best-effort */ }
+      }
+      return normalized;
+    }
     catch (error) {
       // A crashed runner produced no evidence. `not_run` is the truthful state:
       // it can never promote a recovery to success, and it never fabricates a

package/lib/verify.mjs

@@ -693,6 +693,8 @@ export function createVerificationRunner(options = {}) {
       basis: `${basis}; ${executed} executed in ${sandboxImage}`,
       reason: null,
       detail: `${verdict.detail}${detailSuffix}`,
+      // Each command's full (capped) output, for a caller that keeps a log.
+      output: results.map((r) => `$ ${r.command}  (exit ${r.exitCode ?? "none"}${r.timedOut ? ", timed out" : ""})\n${r.stdout}${r.stderr ? `\n[stderr]\n${r.stderr}` : ""}`).join("\n\n"),
     };
   };
 }

package/mcp/server.mjs

@@ -33,6 +33,7 @@ import { createRun, loadRun, runTotals, finishRun, resolveRunLimits, describeLow
 import { agentDispatchFields, resolveAgentModel, agentProviderId, describeAgent } from "../lib/agents.mjs";
 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 { 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";
 
@@ -216,6 +217,10 @@ export function expandJobs(jobs, { getArmy = currentArmy, getAgents = () => agen
   const expanded = jobs.map((job, i) => {
     try {
       let j = runId && !job.run_id ? { ...job, run_id: runId } : job;
+      if (j.mode === "verify") {
+        const { agent, model, army_role, on_behalf_of, agentName, pool, subscription_worker, roleModel, ...rest } = j;
+        return { ...rest, ...(army_role ? { armyRole: army_role } : {}) };
+      }
       if (j.army_role) { army ??= getArmy().army; j = expandArmyRole(j, army); }
       const { agent, roleModel = null, ...rest } = j;
       if (!agent) {
@@ -273,7 +278,7 @@ export const jobSchema = z.object({
   verify_regression: z.boolean().optional().describe(
     "implement only: after the diff passes `verification` and touches production files, temporarily revert just those production files, re-run the SAME verification profile (expected to fail without the fix), then restore them. A re-run that still PASSES proves no test would catch this regression, and the outcome is downgraded to NEEDS_REVIEW regardless of the worker's report -- never silently committed as done. This is the ONLY mechanism that catches a verification profile that passes for the wrong reason (a test-selection flag that accidentally excludes the changed file's own tests reports a real, honest, green run that never touched the diff -- exit-code checking alone cannot see the difference). Defaults to true whenever `verification` is set, since that gap is exactly what nomArmy's trust boundary claims to close; pass `false` explicitly to skip the doubled wall-clock cost (can matter on repos with thousands of tests) and accept the risk instead. No effect with no `verification` profile -- there is nothing to re-run. Ignored by scouts."
   ),
-  mode: z.enum(["scout", "implement", "decompose"]).default("implement").describe("implement: edit in an isolated worktree, coordinator commits on a valid report. scout: read-only research; every finding must cite [path:start-end] and nomArmy attaches the cited lines after verifying them against the base commit. decompose: read-only; proposes 2+ independent, evidence-grounded subtasks for a broad objective instead of doing everything in one worker turn. Never auto-dispatched -- the proposal is reviewed like a scout's findings, and the coordinator makes its own separate dispatch call with whatever subtasks it chooses to use."),
+  mode: z.enum(["scout", "implement", "decompose", "verify"]).default("implement").describe("verify: run a required verification profile with no worker and no model tokens; base_ref selects the branch or commit (default current HEAD), task is a short record label, agent/model are unused and army_role is only a label. implement: edit in an isolated worktree, coordinator commits on a valid report. scout: read-only research; every finding must cite [path:start-end] and nomArmy attaches the cited lines after verifying them against the base commit. decompose: read-only; proposes 2+ independent, evidence-grounded subtasks for a broad objective instead of doing everything in one worker turn. Never auto-dispatched -- the proposal is reviewed like a scout's findings, and the coordinator makes its own separate dispatch call with whatever subtasks it chooses to use."),
   base_ref: z.string().optional(),
   timeout_seconds: z.number().int().min(30).max(1800).default(600),
   reasoning: z.enum(["low", "medium", "high"]).default("medium").describe("Thinking level passed to the worker model. On the local model it takes effect when that model supports thinking (NOMARMY_MODEL_THINKING); on an api or subscription agent it applies per that agent's own `thinking` setting (false = off, a fixed level = always that level). Default is medium, not high, on real measured evidence: on an identical ticket, gpt-oss-20b at high took 318s with 21 tool calls and 4 failures, and at medium took 62s with 9 calls and 0 failures -- high did not produce a better answer, it thrashed. A separate open-ended task made Qwen3.6-27B time out completely at high (630s, zero output) and succeed at medium. Do not raise this to high by default reasoning that more thinking should help -- it has only ever hurt or timed out in testing so far. Reach for high only after a task has already failed once at medium and the failure looks like an under-thinking problem specifically (wrong root cause, not a formatting or scope issue)."),
@@ -356,9 +361,9 @@ server.tool("local_worker_start", "Start one worker or scout in the background a
       poll: { tool: "local_worker_status", job_id: entry.jobId, wait_seconds: MAX_STATUS_WAIT_SECONDS },
       // This job's own lane and budget: a subscription job used to be
       // reported with the local model's figures.
-      lane: jobLane(args), agent: args.agentName ?? "local", model: args.model ?? null,
+      lane: jobLane(args), agent: args.mode === "verify" ? null : args.agentName ?? "local", model: args.model ?? null,
       ...(args.run_id ? { run: runBrief(args.run_id) } : {}),
-      admission: { level: admission.level, notes: admission.reasons }, budgets: describeBudgets(budgetsForJob(args)) }, null, 2));
+      admission: { level: admission.level, notes: admission.reasons }, budgets: args.mode === "verify" ? null : describeBudgets(budgetsForJob(args)) }, null, 2));
   });
 // A long poll must return inside the MCP client's own idle-timeout: it aborts
 // a tool call after N seconds with no response or progress notification,
@@ -481,12 +486,17 @@ server.tool("army", "Who you, the General, are and who you call for what in this
     // Each agent's models, from OpenClaw's catalog, so the General can pick
     // one for a role set to "auto". The catalog can lag a brand-new model.
     const catalog = await modelCatalogReady();
+    // A model its vendor refused on a job is listed apart, so a role on
+    // "auto" isn't sent to it (the catalog lists what a plan may refuse).
+    const refusals = modelRefusals(stateRoot);
     summary.agents = Object.fromEntries(Object.entries(agents).map(([name, agent]) => {
       const provider = agentProviderId(agent);
-      const models = provider && catalog ? [...catalog.keys()].filter((k) => k.startsWith(`${provider}/`)).map((k) => k.slice(provider.length + 1)) : [];
+      const listed = provider && catalog ? [...catalog.keys()].filter((k) => k.startsWith(`${provider}/`)).map((k) => k.slice(provider.length + 1)) : [];
+      const models = listed.filter((m) => !refusals[`${provider}/${m}`]);
+      const refusedModels = listed.filter((m) => refusals[`${provider}/${m}`]);
       const snapshot = usageSnapshots[provider];
       const usage = snapshot ? (() => { const { level, text } = usageStatus(snapshot); return { level, text }; })() : null;
-      return [name, { runsOn: describeAgent(agent), defaultModel: agent.model ?? null, models, usage }];
+      return [name, { runsOn: describeAgent(agent), defaultModel: agent.model ?? null, models, ...(refusedModels.length ? { refusedModels } : {}), usage }];
     }));
     // A pinned model missing from the catalog isn't necessarily wrong:
     // `army assign` proves an unlisted model with a real test call, and the

package/package.json

@@ -3,7 +3,7 @@
   "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.",
   "author": "Rayson Technologies",
   "license": "Apache-2.0",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.5",
   "private": false,
   "type": "module",
   "engines": {

package/playbooks/feature.md

@@ -15,7 +15,7 @@ Follow the army's workflow, calling only the roles the work needs:
 1. **Plan.** Scout the repo as needed (`repo_evidence` first; a scout only for research that would pull many files into your context). Write the plan into the run log: the outcome, acceptance criteria, the pieces, and which role gets each.
 2. **Build.** Dispatch with `army_role` (and `on_behalf_of` when the role's agent is a subscription). The Sr Dev takes the core and harder work; the Jr Dev takes simple, fully specified pieces; UI/UX takes UI. For a role on `auto`, pick the model from the agent's list in the `army` tool: the lighter model for routine work, the frontier one for subtle work.
 3. **Review.** When the build is in, call the specialists that apply (data architect for data work, security analyst for anything touching auth, input, secrets or data exposure), then the PM against the plan. Send what they find back to the builders as new, bounded jobs.
-4. **Acceptance.** PO and stakeholder test end to end. Fix what they find the same way.
+4. **Acceptance.** PO and stakeholder test end to end. Checks that only run existing tests use mode: verify; writing new e2e checks is still an implement job. Fix what they find the same way.
 5. **Integrate.** Review every diff against nomArmy's verified record -- a worker's report is a claim, not evidence -- and bring the accepted work together on one branch. **Never merge into the developer's branch, and never push.** The finished state is a branch ready for the operator to review and merge.
 
 ## Decisions along the way