nomarmy 0.1.0-alpha.8 → 0.1.0-alpha.9

package/bin/nomarmy.mjs

@@ -19,7 +19,7 @@ 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, defaultInstallDir } from "../lib/connect.mjs";
-import { compareVersions, readPackageVersion, readInstallVersions } from "../lib/install-freshness.mjs";
+import { compareVersions, readPackageVersion, readInstallVersions, copyIsStale } 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";
@@ -543,14 +543,16 @@ function defaultLocalProfile() {
   return spawnSync("nvidia-smi", ["-L"], { stdio: "ignore", timeout: 5000 }).status === 0 ? "nvidia-linux" : "cpu-linux";
 }
 
-function setupChecklist() {
+// Which profile this machine is set up for, the same way for `setup` and
+// `install`: the one setup recorded, else the install marker's, else the
+// execution mode's, else (a working local install) install.sh's default.
+function setupProfileState() {
   const common = path.join(nomarmyRoot, "config", "common.env");
   const chosen = readEnvValue(common, "NOMARMY_SETUP_PROFILE");
   const probeCommand = (binary, args) => {
     const result = spawnSync(binary, args, { encoding: "utf8", timeout: 10000 });
     return result.status === 0 ? result.stdout.trim() : "";
   };
-  const project = setupProjectDir();
   const profileFile = chosen ? path.join(nomarmyRoot, "config", "profiles", `${chosen}.env`) : null;
   const root = (process.env.NOMARMY_INSTALL_ROOT || (profileFile && readEnvValue(profileFile, "NOMARMY_INSTALL_ROOT")) || readEnvValue(common, "NOMARMY_INSTALL_ROOT") || "$HOME/.local/share/nomarmy-local-agents").replace(/\$HOME|\$\{HOME\}/g, os.homedir());
   let marker = null;
@@ -564,6 +566,12 @@ function setupChecklist() {
   const profile = chosen ?? marker?.profile
     ?? (["hosted", "remote", "bedrock"].includes(execution) ? execution : null)
     ?? (registered ? defaultLocalProfile() : null);
+  return { common, profile, marker, version, registered };
+}
+
+function setupChecklist() {
+  const { common, profile, marker, version, registered } = setupProfileState();
+  const project = setupProjectDir();
   return setupSteps({
     mode: () => ({ profile, host: readEnvValue(common, "NOMARMY_LLAMA_HOST"), port: readEnvValue(common, "NOMARMY_LLAMA_PORT") }),
     install: () => ({ marker, version, registered }),
@@ -590,8 +598,9 @@ function runSetupChild(args) {
 }
 
 function cmdInstall() {
-  const profile = value("profile", readEnvValue(path.join(nomarmyRoot, "config", "common.env"), "NOMARMY_SETUP_PROFILE"));
+  const profile = value("profile", null) ?? setupProfileState().profile;
   if (!profile) throw new Error("Choose a profile first: nomarmy setup --choose (or install --profile <name>).");
+  if (!value("profile", null)) console.log(`Installing for profile ${profile} (from nomarmy setup; pass --profile to choose another).`);
   const result = spawnSync("bash", [path.join(nomarmyRoot, "install.sh"), "--profile", profile, ...(flag("no-claude") ? ["--no-claude"] : [])], { stdio: "inherit", cwd: nomarmyRoot });
   process.exitCode = result.status ?? 1;
 }
@@ -1660,8 +1669,18 @@ async function cmdUpdate() {
   const remote = git(["rev-parse", "@{u}"]);
   const base = git(["merge-base", "HEAD", "@{u}"]);
   if (local === remote) {
-    if (json) return out({ updated: false, reason: "already up to date" });
-    console.log(c.green("✓ Already up to date."));
+    // Nothing to pull, but the copy coordinators run can still be behind
+    // this checkout (commits made or pulled here without a reconnect).
+    if (!copyIsStale(defaultInstallDir(), nomarmyRoot)) {
+      if (json) return out({ updated: false, reason: "already up to date" });
+      console.log(c.green("✓ Already up to date, and your coordinators run this checkout."));
+      return;
+    }
+    say(c.bold("🍪 nomArmy update\n"));
+    say("Nothing to pull, but your coordinators run an older copy of this checkout.");
+    const resynced = reconnectCoordinators();
+    if (json) return out({ updated: false, resynced, sha: local });
+    console.log(c.yellow("\nRestart every open Claude Code, Codex and Cursor session: each keeps the code it started with until then."));
     return;
   }
   if (base !== local) {
@@ -1677,25 +1696,7 @@ async function cmdUpdate() {
   say("\nInstalling dependencies...");
   execFileSync("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], { cwd: nomarmyRoot, stdio: json ? "ignore" : "inherit" });
 
-  const resynced = [];
-  const runInherit = (cmd, args, opts = {}) => execFileSync(cmd, args, { stdio: json ? "ignore" : "inherit", ...opts });
-  if (commandExists("claude")) {
-    say("\nRe-syncing the Claude Code MCP install...");
-    connectClaude({ nomarmyRoot, run: runInherit });
-    resynced.push("claude");
-  }
-  if (commandExists("codex")) {
-    say("\nRe-syncing the Codex MCP install...");
-    connectCodex({ nomarmyRoot, run: runInherit });
-    resynced.push("codex");
-  }
-  // Cursor has no CLI/PATH binary to probe with commandExists -- "already
-  // connected" is read from its own config file instead.
-  if (cursorAlreadyConnected()) {
-    say("\nRe-syncing the Cursor MCP install...");
-    connectCursor({ nomarmyRoot, run: runInherit });
-    resynced.push("cursor");
-  }
+  const resynced = reconnectCoordinators();
 
   if (json) return out({ updated: true, sha: git(["rev-parse", "HEAD"]), resynced });
   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."));
@@ -1703,6 +1704,18 @@ async function cmdUpdate() {
 
 // The coordinators nomArmy is registered with. Cursor has no CLI to probe,
 // so it counts when its own config already lists nomArmy.
+// Reconnect every connected coordinator through a child process, so it runs
+// the code now on disk (just pulled or installed) rather than the old code
+// this process loaded. Returns the targets reconnected.
+function reconnectCoordinators() {
+  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" });
+  }
+  return targets;
+}
+
 function connectedTargets() {
   return [commandExists("claude") && "claude", commandExists("codex") && "codex", cursorAlreadyConnected() && "cursor"].filter(Boolean);
 }
@@ -1729,13 +1742,7 @@ async function updateFromNpm() {
     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" });
-  }
+  const targets = reconnectCoordinators();
   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."));
 }

package/lib/connect.mjs

@@ -171,6 +171,14 @@ export function installMcpCopy({ nomarmyRoot, installDir, run = defaultRun }) {
     fs.rmSync(path.join(installDir, "config"), { recursive: true, force: true });
     fs.cpSync(configSrc, path.join(installDir, "config"), { recursive: true });
   }
+  // lib/harnesses.mjs finds its definitions at ../harnesses/, so the copy
+  // needs them too: without this, every connected session matched no
+  // harness and built its jobs in the plain base image, silently.
+  const harnessSrc = path.join(nomarmyRoot, "harnesses");
+  if (fs.existsSync(harnessSrc)) {
+    fs.rmSync(path.join(installDir, "harnesses"), { recursive: true, force: true });
+    fs.cpSync(harnessSrc, path.join(installDir, "harnesses"), { recursive: true });
+  }
   run("npm", ["install", "--omit=dev"], { cwd: installDir });
   run(process.execPath, ["--check", "mcp/server.mjs"], { cwd: installDir });
 }

package/lib/execute.mjs

@@ -212,7 +212,7 @@ export function createExecutor(deps) {
           const recoveryResult = await runOpenClaw({
             task, acceptance, verification, mode, cwd, baseRef: base.ref, baseSha: base.sha,
             timeoutSeconds: timeBudget.reportReserveSeconds, runtimeDir, profile, reasoning, pool, subscriptionWorker, onBehalfOf, model, reportSize, jobDir, workerId: workerId || jobId,
-            overridePrompt: reportRecoveryPrompt({ report: budgetState.budgets.report.implement, changes }), logSuffix: "-recovery",
+            overridePrompt: reportRecoveryPrompt({ report: budgetState.budgets.report.implement, changes, task }), logSuffix: "-recovery",
           });
           const recoveryText = finalText(recoveryResult);
           const recoveryValidation = parseWorkerReport(recoveryText);
@@ -568,7 +568,7 @@ export function createExecutor(deps) {
             task, acceptance, verification: null, mode, cwd: worktree, baseRef: base.ref, baseSha: base.sha,
             timeoutSeconds: remainingSeconds, runtimeDir, profile, reasoning, pool, subscriptionWorker, onBehalfOf, model, reportSize, jobDir, workerId: workerId || jobId,
             evidenceTool: evidencePlaced ? evidenceTool : null,
-            overridePrompt: scoutReportRecoveryPrompt({ report: used.report.scout }), logSuffix: "-recovery",
+            overridePrompt: scoutReportRecoveryPrompt({ report: used.report.scout, question: task, acceptance }), logSuffix: "-recovery",
           });
           const recoveryReport = parseScoutReport(finalText(recoveryResult), (recoveryResult?.budgetsUsed ?? used).scout);
           if (!isScoutReportUnusable(recoveryReport)) {

package/lib/health.mjs

@@ -324,7 +324,9 @@ export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, n
   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 installDir = defaultInstallDir();
+  const { loadHarnesses } = await import("./harnesses.mjs");
+  const install = { ...readInstallVersions(installDir), copyHarnesses: Object.keys(loadHarnesses(path.join(installDir, "harnesses")).harnesses).length };
   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), install });
   const toNotify = recordHealth(path.join(stateRoot, "health.json"), result, { now });

package/lib/install-freshness.mjs

@@ -10,6 +10,7 @@
 //                   (the session wasn't restarted); per session, so it is
 //                   reported by that session's server, not in health.json
 
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -21,8 +22,30 @@ export function readPackageVersion(root) {
   catch { return null; }
 }
 
+/** The checkout's commit, for a git install; null for an npm install. */
+export function readSourceCommit(root) {
+  if (!fs.existsSync(path.join(root, ".git"))) return null;
+  try { return execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || 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");
+  const commit = readSourceCommit(nomarmyRoot);
+  fs.writeFileSync(path.join(installDir, SOURCE_FILE), JSON.stringify({ root: nomarmyRoot, version: readPackageVersion(nomarmyRoot), ...(commit ? { commit } : {}) }, null, 2) + "\n");
+}
+
+/**
+ * Whether the copy in installDir is behind the checkout or package at
+ * nomarmyRoot: an older version, a different commit (a git install moves on
+ * without a version bump), or no record of its source at all.
+ */
+export function copyIsStale(installDir, nomarmyRoot) {
+  let source = null;
+  try { source = JSON.parse(fs.readFileSync(path.join(installDir, SOURCE_FILE), "utf8")); } catch { return true; }
+  const copyVersion = readPackageVersion(installDir), rootVersion = readPackageVersion(nomarmyRoot);
+  if (!copyVersion || !rootVersion || copyVersion !== rootVersion) return true;
+  const commit = readSourceCommit(nomarmyRoot);
+  return Boolean(commit && source.commit !== commit);
 }
 
 /** The copy's version and, when connect recorded it, the version now at its source. */
@@ -52,9 +75,14 @@ export function compareVersions(a, b) {
 
 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 }) {
+/** Health issues for a stale CLI, a stale installed copy, or a copy missing its harnesses. */
+export function freshnessIssues({ copyVersion = null, sourceVersion = null, latestVersion = null, copyHarnesses = null }) {
   const issues = [];
+  if (valid(copyVersion) && copyHarnesses === 0) {
+    issues.push({ id: `nomarmy-harnesses:${copyVersion}`, severity: "error", title: "The nomArmy your coordinators run has no harnesses",
+      detail: "Jobs match no harness, so they run in the plain base image: no dependencies, fake services, browser tests or artifacts.",
+      fix: "nomarmy connect claude (and codex, cursor), then restart those sessions", short: "no harnesses" });
+  }
   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})`,

package/lib/scout.mjs

@@ -435,8 +435,12 @@ export function isScoutReportUnusable(report) {
  * already found -- never asks it to look further, since a fresh read pass is
  * exactly the cost a scout exists to avoid paying twice.
  */
-export function scoutReportRecoveryPrompt({ report = { targetTokens: 600, hardCapTokens: 1024 } } = {}) {
-  return `Your previous reply ended without the required SCOUT REPORT, or was cut off before reaching END.\n\nDo not repeat, redo, retry, or explore further. Do not call any tool. Based only on what you already found, reply with ONLY the report below, nothing before it, nothing after it:\n\nSCOUT REPORT\nQUESTION: <the question restated in one line>\nCONFIDENCE: high | medium | low\nFINDING: <one sentence> [src/example.js:10-24]\nNOT_FOUND: none | <what you looked for and could not find>\nEND\n\nIf you did not actually find anything worth a FINDING, say so under NOT_FOUND rather than inventing one. Target ${report.targetTokens} tokens; ${report.hardCapTokens} is the hard cap.`;
+// The recovery call carries the question itself: a reply cut off mid-run can
+// leave the resumed session without it, and a scout told only to "restate the
+// question" then came back with an empty report (a live PM scout, twice).
+export function scoutReportRecoveryPrompt({ report = { targetTokens: 600, hardCapTokens: 1024 }, question = null, acceptance = [] } = {}) {
+  const asked = question ? `\n\nThe question you were answering:\n${String(question).trim()}${acceptance?.length ? `\n\nA complete answer covers:\n${acceptance.map((a) => `- ${a}`).join("\n")}` : ""}` : "";
+  return `Your previous reply ended without the required SCOUT REPORT, or was cut off before reaching END.${asked}\n\nDo not repeat, redo, retry, or explore further. Do not call any tool. Based only on what you already found, reply with ONLY the report below, nothing before it, nothing after it:\n\nSCOUT REPORT\nQUESTION: <the question restated in one line>\nCONFIDENCE: high | medium | low\nFINDING: <one sentence> [src/example.js:10-24]\nNOT_FOUND: none | <what you looked for and could not find>\nEND\n\nIf you did not actually find anything worth a FINDING, say so under NOT_FOUND rather than inventing one. Target ${report.targetTokens} tokens; ${report.hardCapTokens} is the hard cap.`;
 }
 
 // ---------------------------------------------------------------------------

package/lib/verify.mjs

@@ -135,10 +135,19 @@ function tailOf(result) {
  * command that never started is absence of evidence, so if nothing ever ran the
  * verdict is `not_run`, never `fail`.
  *
+ * A command guarded on nomArmy's changed-file variables (`if [ -n
+ * "$NOMARMY_CHANGED_TEST_FILES" ]; then ...; fi`) exits 0 without running
+ * anything when those are empty, as on an unchanged checkout in mode: verify.
+ * That's skipped, not passed: exit 0, no output at all, and every
+ * NOMARMY_CHANGED_* variable the command names empty. A command with a
+ * fallback (`${NOMARMY_CHANGED_TEST_FILES:-tests/}`) prints test output, so
+ * it counts as run. If every command skipped, nothing was verified: not_run.
+ *
  * @param {Array<object>} results
- * @returns {{ status: "pass"|"fail"|"not_run", detail: string }}
+ * @param {{ env?: Record<string, string> }} [context] the NOMARMY_CHANGED_* values the commands saw
+ * @returns {{ status: "pass"|"fail"|"not_run", detail: string, basis?: string }}
  */
-export function classifyResults(results) {
+export function classifyResults(results, { env = {} } = {}) {
   const list = Array.isArray(results) ? results.filter(Boolean) : [];
   if (list.length === 0) {
     return { status: "not_run", detail: "no commands were executed" };
@@ -176,9 +185,28 @@ export function classifyResults(results) {
     }
   }
 
+  const skipped = list.map((result, index) => ({ index, why: guardedNoOp(result, env) })).filter((s) => s.why);
+  if (skipped.length === total) {
+    return { status: "not_run", basis: "nothing-changed", detail: `every command is scoped to changed files and nothing changed, so none ran (${[...new Set(skipped.map((s) => s.why))].join("; ")}); add an unscoped profile to run the full suite` };
+  }
+  if (skipped.length) {
+    const which = skipped.map((s) => `command ${s.index + 1} (\`${list[s.index].command ?? "?"}\`) did nothing: ${s.why}`).join("; ");
+    return { status: "pass", detail: `${total - skipped.length} of ${total} commands passed; ${skipped.length} skipped: ${which}` };
+  }
   return { status: "pass", detail: `${total} of ${total} commands passed` };
 }
 
+const CHANGED_VAR_RE = /\$\{?(NOMARMY_CHANGED_[A-Z_]+)/g;
+
+/** Why a zero-exit, silent command was a guarded no-op, or null if it ran. */
+function guardedNoOp(result, env) {
+  if (result.exitCode !== 0 || result.timedOut || result.started === false) return null;
+  if (result.silent === false || (result.silent === undefined && `${result.stdout ?? ""}${result.stderr ?? ""}`.trim())) return null;
+  const names = [...new Set([...String(result.command ?? "").matchAll(CHANGED_VAR_RE)].map((m) => m[1]))];
+  if (!names.length || names.some((name) => String(env[name] ?? "").trim())) return null;
+  return `${names.join(" and ")} ${names.length > 1 ? "are" : "is"} empty`;
+}
+
 // ---------------------------------------------------------------------------
 // pure: output capping
 // ---------------------------------------------------------------------------
@@ -853,6 +881,9 @@ export function createVerificationRunner(options = {}) {
             timeoutMs,
             stdout: stdout.text,
             stderr: stderr.text,
+            // Whether the command printed nothing at all, judged before any
+            // output is withheld, so a guarded no-op is still recognized.
+            silent: !String(raw?.stdout ?? "").trim() && !String(raw?.stderr ?? "").trim(),
             truncated: { stdout: stdout.dropped, stderr: stderr.dropped },
           };
           results.push(entry);
@@ -876,7 +907,7 @@ export function createVerificationRunner(options = {}) {
         }
       }
 
-      const verdict = classifyResults(results);
+      const verdict = classifyResults(results, { env: verificationEnv });
       const executed = results.filter((r) => r.started).length;
       const dropped = results.reduce(
         (total, r) => total + (r.truncated?.stdout ?? 0) + (r.truncated?.stderr ?? 0),
@@ -888,7 +919,7 @@ export function createVerificationRunner(options = {}) {
         : "";
 
       if (verdict.status === "not_run") {
-        return notRun(verdict.detail, "sandbox-unavailable", { ...networkInfo, output: renderOutput() });
+        return notRun(verdict.detail, verdict.basis ?? "sandbox-unavailable", { ...networkInfo, output: renderOutput() });
       }
 
       return {

package/lib/worker-prompt.mjs

@@ -69,10 +69,13 @@ export function describeRecoveryChanges(record) {
   return `${record.repoStatusFiles.length} file(s) differ from a clean checkout: ${record.repoStatusFiles.join(", ")}`;
 }
 
-export function reportRecoveryPrompt({ report = { targetTokens: 256, hardCapTokens: 512 }, changes = null } = {}) {
+export function reportRecoveryPrompt({ report = { targetTokens: 256, hardCapTokens: 512 }, changes = null, task = null } = {}) {
+  // The objective itself, so STATUS is judged against it even when the
+  // resumed session lost it with the cut-off reply.
+  const objective = task ? `\nThe objective you were working on:\n${String(task).trim()}\n` : "";
   const changesLine = changes
     ? `\nThe repository (checked independently just now, not from your memory of this session) already shows: ${changes}. Trust this over any uncertainty about what you did or did not do.\n`
     : `\nThe repository (checked independently just now, not from your memory of this session) shows no changes at all.\n`;
-  return `Your previous reply ended without the required final report, or was cut off before completing it.\n${changesLine}\nDo not repeat, redo, retry, or describe any action you already took. Do not call any tool. Reply with ONLY the four lines below, nothing before them, nothing after them:\n\nSTATUS: done | partial | blocked\nTESTS: pass | fail | not_run\nNOT_DONE: none | <brief>\nNOTE: <brief implementation or risk note>\n\nUse the exact field names above, including the underscore in NOT_DONE. Target ${report.targetTokens} tokens; ${report.hardCapTokens} is the hard cap. Base STATUS on the repository state above, not on what you recall attempting: if it shows the edit landed, you may report done; if it shows nothing relevant, report blocked or partial rather than guessing done.`;
+  return `Your previous reply ended without the required final report, or was cut off before completing it.\n${objective}${changesLine}\nDo not repeat, redo, retry, or describe any action you already took. Do not call any tool. Reply with ONLY the four lines below, nothing before them, nothing after them:\n\nSTATUS: done | partial | blocked\nTESTS: pass | fail | not_run\nNOT_DONE: none | <brief>\nNOTE: <brief implementation or risk note>\n\nUse the exact field names above, including the underscore in NOT_DONE. Target ${report.targetTokens} tokens; ${report.hardCapTokens} is the hard cap. Base STATUS on the repository state above, not on what you recall attempting: if it shows the edit landed, you may report done; if it shows nothing relevant, report blocked or partial rather than guessing done.`;
 }
 

package/package.json

@@ -3,7 +3,7 @@
   "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.8",
+  "version": "0.1.0-alpha.9",
   "private": false,
   "type": "module",
   "engines": {