nomarmy 0.1.0-alpha.16 → 0.1.0-alpha.17

package/bin/nomarmy.mjs

@@ -20,7 +20,7 @@ import { readGGUFMetadata, resolveModelPath, totalSplitBytes } from "../lib/gguf
 import { recommend, customRecommendation, evaluateConfig, bytesPerKvElementForCacheTypes, MIN_CONTEXT_PER_NOM } from "../lib/sizing.mjs";
 import { connectClaude, connectCodex, connectCursor, cursorAlreadyConnected, deriveWorkerModelEnv, defaultInstallDir, installMcpCopy, SCOPES, claudeUserScoped, portableServerLaunch } from "../lib/connect.mjs";
 import { compareVersions, readPackageVersion, readInstallVersions, copyIsStale } from "../lib/install-freshness.mjs";
-import { loadJobRecords, computeStats, formatStats, parseSince, resolveRepo, agentLookup } from "../lib/stats.mjs";
+import { loadJobRecords, computeStats, formatStats, formatStatsSummary, parseSince, resolveRepo, agentLookup } from "../lib/stats.mjs";
 import { requestJobStop } from "../lib/openclaw-run.mjs";
 import { loadValidators, saveJevKey, removeJev, jevSettings, askJev, validatorsPath, JEV_CHECKS, saveJudge, removeJudge, judgeSettings } from "../lib/validators.mjs";
 import { probeModel } from "../lib/model-probe.mjs";
@@ -31,6 +31,7 @@ import { parseLlamaUrl } from "../lib/execution.mjs";
 import { setupSteps, formatSetupSteps, runSetupPlaybook } from "../lib/setup-steps.mjs";
 import { readUsageSnapshots } from "../lib/usage-limits.mjs";
 import { pickMachine, planResize } from "../lib/sandbox-vm.mjs";
+import { listProcesses, staleSessions, formatStaleSessions } from "../lib/stale-sessions.mjs";
 import { MIN_PODMAN_VM_MB } from "../lib/doctor.mjs";
 import { liveLeases } from "../lib/slots.mjs";
 import { ensureProviderConfig } from "../lib/openclaw-config.mjs";
@@ -238,7 +239,7 @@ Usage: nomarmy <command> [options]
                   project for this repository, committed for the team
                   (.mcp.json or .cursor/mcp.json, running \`nomarmy mcp\`).
                   Codex has only the user scope.
-  stats [--since 7d|<date>] [--until <date>] [--role <role>] [--model <model>]
+  stats [--since 7d|<date>] [--until <date>] [--role <role>] [--model <model>] [--details] [--all-suggestions]
         [--repo <path|name>] [--all-repos] [--json]
                   What nomArmy's job records show for this repository (or
                   all): volume by role and model, code committed, time,
@@ -1714,13 +1715,14 @@ async function cmdUpdate() {
     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."));
+      printSessionRestarts({ quietWhenNone: true });
       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."));
+    printSessionRestarts();
     return;
   }
   if (base !== local) {
@@ -1747,6 +1749,25 @@ async function cmdUpdate() {
 // 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.
+// Each open session keeps the nomArmy it started with: name the ones that
+// started before the installed copy, rather than a blanket "restart".
+function printSessionRestarts({ quietWhenNone = false } = {}) {
+  let list = null;
+  try {
+    const installedAt = fs.statSync(path.join(defaultInstallDir(), "source.json")).mtimeMs;
+    const procs = listProcesses();
+    if (procs) list = staleSessions(procs, { installedAt });
+  } catch { /* no installed copy yet, or ps unavailable */ }
+  if (list === null) {
+    if (!quietWhenNone) console.log(c.yellow("\nRestart every open Claude Code, Codex and Cursor session: each keeps the code it started with until then."));
+    return;
+  }
+  if (!list.length) { if (!quietWhenNone) console.log(c.green("\n✓ No open session runs an older nomArmy.")); return; }
+  console.log(c.yellow(`\n${list.length} open session(s) still run an older nomArmy, until each is restarted:`));
+  for (const line of formatStaleSessions(list)) console.log(line);
+  console.log(c.dim("In Claude Code: /exit, then claude --resume (or /mcp → nomarmy-local-worker → Reconnect). Close any you no longer use."));
+}
+
 function reconnectCoordinators() {
   const targets = connectedTargets();
   // Per-repo registrations run the installed copy (or `nomarmy mcp`), so a
@@ -1791,7 +1812,7 @@ async function updateFromNpm() {
   }
   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."));
+  printSessionRestarts();
 }
 
 function commandExists(cmd) {
@@ -2747,9 +2768,9 @@ function cmdStats() {
   }
   let agentFor = () => null;
   try { agentFor = agentLookup(loadAgents(globalConfigDir()).agents, agentProviderId); } catch { /* no agents.yml: commands name <agent> */ }
-  const stats = computeStats(records, { repo, sinceMs: parseSince(value("since")), untilMs: parseSince(value("until")), role: value("role"), model: value("model"), agentFor });
+  const stats = computeStats(records, { repo, sinceMs: parseSince(value("since")), untilMs: parseSince(value("until")), role: value("role"), model: value("model"), agentFor, allSuggestions: flag("all-suggestions") });
   if (json) return out(stats);
-  console.log(formatStats(stats));
+  console.log(flag("details") ? formatStats(stats) : formatStatsSummary(stats, { c }));
 }
 
 // Read one line without echoing it: stty -echo around the read, restored

package/lib/health.mjs

@@ -337,8 +337,8 @@ export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, n
     const { loadJobRecords, agentLookup } = await import("./stats.mjs");
     const { recentSuggestions } = await import("./suggestions.mjs");
     for (const s of recentSuggestions(loadJobRecords(path.join(stateRoot, "jobs")), { projectDir, agentFor: agents ? agentLookup(agents, agentProviderId) : () => null, now })) {
-      if (s.level !== "warn") continue;
-      result.issues.push({ id: `suggestion:${s.key}`, severity: "warn", title: s.title, detail: s.evidence, fix: s.command ?? "nomarmy stats (routing suggestions)", short: "routing tip" });
+      if (s.level !== "warn" && s.level !== "act") continue;
+      result.issues.push({ id: `suggestion:${s.key}`, severity: "warn", title: s.title, detail: s.evidence, fix: s.command ?? "nomarmy stats (routing suggestions)", short: s.level === "act" ? "review needed" : "routing tip" });
     }
   } catch { /* suggestions never break a health check */ }
   const toNotify = recordHealth(path.join(stateRoot, "health.json"), result, { now });

package/lib/stale-sessions.mjs

@@ -0,0 +1,60 @@
+// Which open coordinator sessions still run an older nomArmy. Each Claude
+// Code, Codex or Cursor session starts its own nomArmy server and keeps the
+// code it started with, so after an update "restart your sessions" wasn't
+// enough: one real afternoon had a session on alpha.14 for hours and four
+// more, days old, on alpha.6 to alpha.12. This names each one.
+
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+// The installed copy's server, or the portable `nomarmy mcp` launcher.
+const SERVER_RE = /nomarmy-local-worker[\\/]mcp[\\/]server\.mjs|\bnomarmy(?:\.mjs)?\s+mcp\b/;
+
+/** `ps -A -o pid=,ppid=,tty=,lstart=,args=` lines. lstart reads "Sun Sep 27 21:33:11 2026" on macOS and Linux alike. */
+export function parsePs(text) {
+  const out = [];
+  for (const line of String(text ?? "").split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{2}:\d{2}:\d{2})\s+(\d{4})\s+(.*)$/.exec(line);
+    if (!m) continue;
+    const startedAt = new Date(`${m[4]} ${m[5]} ${m[7]} ${m[6]}`).getTime();
+    if (!Number.isFinite(startedAt)) continue;
+    out.push({ pid: Number(m[1]), ppid: Number(m[2]), tty: /^\?+$/.test(m[3]) ? null : m[3], startedAt, args: m[8].trim() });
+  }
+  return out;
+}
+
+/** The app a server belongs to, from its parent's command line. */
+export function appName(args) {
+  const first = String(args ?? "").split(/\s+/)[0] ?? "";
+  const base = path.basename(first).toLowerCase();
+  if (base === "claude" || /claude/.test(base)) return "Claude Code";
+  if (base === "codex" || /codex/.test(base)) return "Codex";
+  if (/cursor/i.test(first)) return "Cursor";
+  return base || "a session";
+}
+
+/** Servers that started before the copy they'd now load was installed. */
+export function staleSessions(procs, { installedAt }) {
+  if (!Number.isFinite(installedAt)) return [];
+  const byPid = new Map(procs.map((p) => [p.pid, p]));
+  return procs
+    .filter((p) => SERVER_RE.test(p.args) && p.startedAt < installedAt)
+    .map((p) => {
+      const parent = byPid.get(p.ppid);
+      return { pid: p.pid, appPid: parent?.pid ?? p.ppid, app: appName(parent?.args), tty: p.tty ?? parent?.tty ?? null, startedAt: p.startedAt };
+    })
+    .sort((a, b) => a.startedAt - b.startedAt);
+}
+
+/** Running processes, or null where `ps` isn't available (Windows). */
+export function listProcesses({ run = spawnSync, platform = process.platform } = {}) {
+  if (platform === "win32") return null;
+  const res = run("ps", ["-A", "-o", "pid=,ppid=,tty=,lstart=,args="], { encoding: "utf8", timeout: 10000 });
+  return res.status === 0 ? parsePs(res.stdout) : null;
+}
+
+export function formatStaleSessions(list, { now = Date.now() } = {}) {
+  const when = (ms) => new Date(ms).toLocaleString("en-US", { weekday: "short", hour: "numeric", minute: "2-digit" });
+  const age = (ms) => { const h = Math.round((now - ms) / 3600000); return h < 24 ? `${h}h ago` : `${Math.round(h / 24)}d ago`; };
+  return list.map((s) => `  ${s.app}${s.tty ? ` on ${s.tty}` : ""}, started ${when(s.startedAt)} (${age(s.startedAt)}), pid ${s.appPid}`);
+}

package/lib/stats.mjs

@@ -99,7 +99,7 @@ export function resolveRepo(records, value) {
  * @param {object[]} records
  * @param {{ repo?: string|null, sinceMs?: number|null, untilMs?: number|null, role?: string|null, model?: string|null }} filter
  */
-export function computeStats(records, { repo = null, sinceMs = null, untilMs = null, role = null, model = null, agentFor = () => null, now = Date.now() } = {}) {
+export function computeStats(records, { repo = null, sinceMs = null, untilMs = null, role = null, model = null, agentFor = () => null, now = Date.now(), allSuggestions = false } = {}) {
   const inRange = records.filter((r) => {
     const at = Date.parse(r.startedAt ?? r.finishedAt ?? "");
     if (sinceMs != null && !(at >= sinceMs)) return false;
@@ -136,6 +136,8 @@ export function computeStats(records, { repo = null, sinceMs = null, untilMs = n
   const changedNothing = claimedDone.filter((r) => r.independentVerification?.status === "not_run");
   const passedBoth = claimedDone.filter((r) => r.independentVerification?.status === "pass" && r.regressionCheck?.status !== "fail");
   const flaggedAfterPassing = passedBoth.filter((r) => (r.issues ?? []).some((i) => /^(MUTANTS SURVIVED|REPORT MAY NOT MATCH|JUDGE \(|VERIFICATION INPUT CHANGED)/.test(i)));
+  // New tests the revert check showed would catch their change going away.
+  const provenTestFiles = committed.filter((r) => r.regressionCheck?.status === "pass").reduce((n, r) => n + (r.testChanges?.new_tests_added?.length ?? r.metrics?.new_tests_added ?? 0), 0);
 
   const signals = {};
   for (const [name, re] of SIGNALS) {
@@ -181,16 +183,18 @@ export function computeStats(records, { repo = null, sinceMs = null, untilMs = n
       passedBoth: passedBoth.length,
       changedNothing: changedNothing.length,
       flaggedAfterPassing: flaggedAfterPassing.length,
+      provenTestFiles,
     },
     notCompleted: sortDesc(count(jobs.filter((r) => !/^(WORKER_DONE|RECOVERED_SUCCESS|VERIFIED|SCOUT_DONE|DECOMPOSE_DONE|SCOUT_NOT_FOUND)$/.test(r.outcome ?? "")), (r) => r.outcome)),
     reviewers,
     signals: sortDesc(signals),
     highStakes: (() => {
-      const high = implement.filter((r) => r.stakes === "high");
+      // Work that landed: an uncommitted partial isn't accepted work.
+      const high = implement.filter((r) => r.stakes === "high" && r.commit?.created);
       return { jobs: high.length, reviewed: high.filter((r) => reviewOf(r, records)).length };
     })(),
     // How you're set up now: the last 14 days unless a period was asked for.
-    suggestions: computeSuggestions(sinceMs == null ? jobs.filter((r) => Date.parse(r.startedAt ?? "") >= now - SUGGESTION_WINDOW_MS) : jobs, { agentFor }),
+    suggestions: computeSuggestions(sinceMs == null ? jobs.filter((r) => Date.parse(r.startedAt ?? "") >= now - SUGGESTION_WINDOW_MS) : jobs, { agentFor, now, includeStale: allSuggestions }),
     suggestionWindow: sinceMs == null ? "the last 14 days" : "this period",
   };
 }
@@ -200,14 +204,83 @@ const list = (obj) => Object.entries(obj).map(([k, v]) => `${k} ${v}`).join(" ·
 const mins = (m) => (m == null ? "n/a" : `${m.toFixed(1)} min`);
 const big = (n) => (n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n));
 
+/** The headline: claims that didn't hold up, and tests shown to catch their change. */
+function caughtLines(c) {
+  if (!c.claimedDone) return ["  no implement job reported \"done, tests pass\" in this period"];
+  const wrong = c.verificationFailed + c.revertStillPassed;
+  const parts = [c.verificationFailed && `${c.verificationFailed} failed when nomArmy ran the tests itself`, c.revertStillPassed && `${c.revertStillPassed} had tests that still pass with the change reverted`].filter(Boolean);
+  return [
+    wrong ? `  ${wrong} of ${c.claimedDone} "done, tests pass" claims didn't hold up: ${parts.join(", ")}` : `  all ${c.claimedDone} "done, tests pass" claims held up when nomArmy checked them`,
+    ...(c.flaggedAfterPassing ? [`  ${c.flaggedAfterPassing} more passed both but were flagged (mutants, Jev, judge, a rewritten check)`] : []),
+    ...(c.provenTestFiles ? [`  ${c.provenTestFiles} new test file(s) shown to fail without their change`] : []),
+  ];
+}
+
+/**
+ * The default view: one screen. What nomArmy caught, what needs you, the top
+ * tips, and the totals. `--details` prints formatStats. `c` paints (the CLI
+ * passes its colors, plain when not a terminal); left out, it's plain text.
+ */
+const PLAIN = { bold: String, dim: String, red: String, green: String, yellow: String, cyan: String };
+export function formatStatsSummary(s, { c = PLAIN, width = 28 } = {}) {
+  const cv = s.claimVsEvidence;
+  const where = s.repo ? path.basename(s.repo) : "all repositories";
+  const month = (iso) => new Date(iso).toLocaleString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+  const when = s.period.from ? `${month(s.period.from)} to ${month(s.period.to)}` : "no jobs yet";
+  const act = (s.suggestions ?? []).filter((x) => x.level === "act");
+  // The spend share is on the totals line already.
+  const tips = (s.suggestions ?? []).filter((x) => x.level !== "act" && x.key !== "stale" && !x.key.startsWith("spend:"));
+  const hidden = (s.suggestions ?? []).find((x) => x.key === "stale");
+  const shown = tips.slice(0, 3), more = tips.length - shown.length;
+  const label = (t) => c.bold(t.padEnd(9));
+  const lines = [`${c.bold("nomArmy stats")}  ${c.dim(`${where} · ${when} · ${s.volume.jobs} jobs · ${s.code.committedJobs} committed`)}`, ""];
+
+  // What the checks caught: the reason to run nomArmy, first.
+  if (cv.claimedDone) {
+    const wrong = cv.verificationFailed + cv.revertStillPassed, held = cv.claimedDone - wrong;
+    const bad = wrong ? Math.max(1, Math.round((width * wrong) / cv.claimedDone)) : 0;
+    lines.push(`${label("CAUGHT")}${c.green("█".repeat(width - bad))}${c.red("░".repeat(bad))}  ${held} of ${cv.claimedDone} "done, tests pass" claims held up${wrong ? c.red(` · ${wrong} didn't`) : ""}`);
+    const why = [cv.verificationFailed && `${cv.verificationFailed} failed when nomArmy ran the tests itself`, cv.revertStillPassed && `${cv.revertStillPassed} had tests that pass with the change reverted`, cv.flaggedAfterPassing && `${cv.flaggedAfterPassing} passed but were flagged`].filter(Boolean);
+    if (why.length) lines.push(`${" ".repeat(9)}${c.dim(why.join(" · "))}`);
+  } else lines.push(`${label("CAUGHT")}${c.dim('no job reported "done, tests pass" in this period')}`);
+  if (cv.provenTestFiles) lines.push(`${label("PROVEN")}${c.green("✓")} ${cv.provenTestFiles} new test files fail without their change`);
+
+  for (const x of act) {
+    const ids = /: (.+)$/.exec(x.title)?.[1]?.split(", ") ?? [];
+    const head = x.title.replace(/: .+$/, "");
+    lines.push("", `${c.red(c.bold("⚠ REVIEW BEFORE MERGING"))}  ${head}`);
+    for (let i = 0; i < ids.length; i += 2) lines.push(`   ${ids.slice(i, i + 2).map((id) => id.padEnd(32)).join("")}`.trimEnd());
+    lines.push(`   ${c.cyan("→")} a scout on another vendor with ${c.cyan("reviews: <job id>")} (army_role security-analyst); a failed review doesn't count`);
+  }
+
+  lines.push("");
+  if (!shown.length) lines.push(`${label("TIPS")}${c.dim("none: nothing in the records suggests a routing change")}`);
+  shown.forEach((t, i) => {
+    lines.push(`${i ? " ".repeat(9) : label("TIPS")}${t.level === "warn" ? c.yellow("▲") : c.dim("·")} ${t.title}`);
+    if (t.command) lines.push(`${" ".repeat(11)}${c.cyan(`→ ${t.command}`)}`);
+  });
+  const staleCount = hidden ? Number(/^\d+/.exec(hidden.title)?.[0] ?? 0) : 0;
+  const notes = [more > 0 && `${more} more (--details)`, staleCount && `${staleCount} about pairings unused for 3+ days (--all-suggestions)`].filter(Boolean);
+  if (notes.length) lines.push(`${" ".repeat(11)}${c.dim(notes.join(" · "))}`);
+
+  const top = Object.entries(s.spendUsd.byModel)[0];
+  lines.push("", `${label("SPEND")}$${s.spendUsd.total.toFixed(2)} API${top ? c.dim(` (${top[0]} ${Math.round((100 * top[1]) / (s.spendUsd.total || 1))}%)`) : ""} · ${Math.round(s.jobMinutes.total)} min of jobs · ${big(s.tokens.total)} tokens`);
+  lines.push("", c.dim("Everything else (volume, reviewers, flags, what didn't finish): nomarmy stats --details"));
+  return lines.join("\n");
+}
+
 /** The terminal report. */
 export function formatStats(s) {
   const c = s.claimVsEvidence;
   const lines = [
     `nomArmy stats${s.repo ? ` for ${s.repo}` : " (all repositories)"}${s.role ? `, role ${s.role}` : ""}${s.model ? `, model ${s.model}` : ""}, ${s.period.from ? `${s.period.from.slice(0, 10)} to ${s.period.to.slice(0, 10)}` : "no jobs"}`,
     "",
+    "WHAT NOMARMY CAUGHT",
+    ...caughtLines(c),
+    ...(() => { const act = (s.suggestions ?? []).filter((x) => x.level === "act"); return act.length ? ["", "NEEDS YOUR ATTENTION", ...formatSuggestions(act)] : []; })(),
+    "",
     `SUGGESTIONS (from ${s.suggestionWindow ?? "this period"}; never applied for you)`,
-    ...formatSuggestions(s.suggestions ?? []),
+    ...formatSuggestions((s.suggestions ?? []).filter((x) => x.level !== "act")),
     "",
     "VOLUME",
     `  Jobs          ${s.volume.jobs}: ${list(s.volume.byMode)}${s.unplacedVerifyRuns ? ` (plus ${s.unplacedVerifyRuns} older verify run(s) that don't record their repository)` : ""}`,
@@ -225,7 +298,7 @@ export function formatStats(s) {
     `  Passed both                           ${c.passedBoth}${pct(c.passedBoth, c.claimedDone)}`,
     `    of those, flagged by another check  ${c.flaggedAfterPassing} (mutants, Jev, judge, rewritten checks)`,
     ...(c.changedNothing ? [`  Changed nothing, nothing to verify    ${c.changedNothing}${pct(c.changedNothing, c.claimedDone)}`] : []),
-    `  High-stakes jobs                      ${s.highStakes?.jobs ?? 0}, ${s.highStakes?.reviewed ?? 0} with an independent review`,
+    `  High-stakes jobs committed            ${s.highStakes?.jobs ?? 0}, ${s.highStakes?.reviewed ?? 0} with a finished independent review`,
     "  Defects the General found at integration aren't in the records; count them in your own review.",
     "",
     "DIDN'T COMPLETE",

package/lib/suggestions.mjs

@@ -19,10 +19,15 @@ const freshTokens = (r) => (r.metrics?.worker_tokens_in ?? 0) + (r.metrics?.work
 export const runnerFailed = (r) => r.outcome === "WORKER_FAILED" && [...(r.issues ?? []), ...(r.reasons ?? [])].some((x) => /^(worker|scout|decomposer) process failed/.test(x));
 const pct = (n, of) => Math.round((100 * n) / of);
 
-/** Whether a high-stakes job has had an independent review: a scout, or a judge, on another vendor. */
+const REVIEW_FINISHED = /^(SCOUT_DONE|SCOUT_NOT_FOUND)$/;
+// How recently a pairing must have run for a suggestion about it to still be
+// about how you work now: a week-old local-model experiment led Senti's list.
+export const CURRENT_DAYS = 3;
+
+/** Whether a high-stakes job has had an independent review: a finished scout, or a judge, on another vendor. A review that timed out or failed isn't one. */
 export function reviewOf(job, records) {
   const workerProvider = provider(job);
-  const scout = records.find((r) => r.mode === "scout" && r.reviews === job.jobId && provider(r) && provider(r) !== workerProvider);
+  const scout = records.find((r) => r.mode === "scout" && r.reviews === job.jobId && REVIEW_FINISHED.test(r.outcome ?? "") && provider(r) && provider(r) !== workerProvider);
   if (scout) return { by: "scout", jobId: scout.jobId, provider: provider(scout) };
   const judge = job.validators?.judge;
   if (judge?.answer && judge.provider && judge.provider !== workerProvider) return { by: "judge", provider: judge.provider };
@@ -33,16 +38,18 @@ export function reviewOf(job, records) {
  * @param {object[]} records this repo's records, already filtered to a period
  * @returns {{ level: "warn"|"info", key: string, title: string, evidence: string, command: string|null }[]}
  */
-export function computeSuggestions(records, { minJobs = MIN_JOBS, agentFor = () => null } = {}) {
+export function computeSuggestions(records, { minJobs = MIN_JOBS, agentFor = () => null, now = Date.now(), includeStale = false } = {}) {
   const out = [];
+  let stale = 0;
   const work = records.filter((r) => r.mode === "implement" || r.mode === "scout");
 
   // Per role and model.
   const groups = new Map();
   for (const r of work) {
     const key = `${jobRole(r) ?? ""}|${model(r) ?? ""}|${r.mode}`;
-    const g = groups.get(key) ?? { role: jobRole(r), model: model(r), mode: r.mode, agent: agent(r), provider: provider(r), jobs: 0, rated: 0, ok: 0, runner: 0, timeout: 0, unsupported: 0, tokens: 0, tokenJobs: 0 };
+    const g = groups.get(key) ?? { role: jobRole(r), model: model(r), mode: r.mode, agent: agent(r), provider: provider(r), jobs: 0, rated: 0, ok: 0, runner: 0, timeout: 0, unsupported: 0, tokens: 0, tokenJobs: 0, lastAt: 0 };
     g.jobs++;
+    g.lastAt = Math.max(g.lastAt, Date.parse(r.startedAt ?? "") || 0);
     if (runnerFailed(r)) g.runner++; else g.rated++;
     if (OK.test(r.outcome ?? "")) g.ok++;
     if (r.outcome === "WORKER_TIMEOUT") g.timeout++;
@@ -53,8 +60,15 @@ export function computeSuggestions(records, { minJobs = MIN_JOBS, agentFor = ()
   }
   const assign = (g, to = "<another model>") => (g.role ? `nomarmy army assign ${g.role} ${g.agent ?? "<agent>"} ${to}` : null);
 
+  const current = (g) => includeStale || g.lastAt >= now - CURRENT_DAYS * 86400000;
   for (const g of groups.values()) {
     if (!g.model) continue;
+    // A stale pairing's suggestions are worked out, then only counted.
+    const before = out.length;
+    groupSuggestions(g);
+    if (!current(g)) stale += out.splice(before).length;
+  }
+  function groupSuggestions(g) {
     const kind = g.mode === "scout" ? "scouts" : "implement jobs";
     const who = g.role ? `${g.role} on ${g.model}` : `${kind} with no role on ${g.model}`;
     // The runner failing isn't the model doing poor work: say so apart, and leave those out of its rate.
@@ -66,9 +80,9 @@ export function computeSuggestions(records, { minJobs = MIN_JOBS, agentFor = ()
     if (g.mode === "scout" && g.rated >= 3 && g.unsupported / g.rated >= 0.4) {
       out.push({ level: "warn", key: `scout-unsupported:${g.role}:${g.model}`, title: `${who}: ${g.unsupported} of ${g.rated} scouts came back unsupported`,
         evidence: "Their findings couldn't be tied to cited lines. A different agent, or report: full, usually fixes it.", command: assign(g) });
-      continue;
+      return;
     }
-    if (g.rated < minJobs) continue;
+    if (g.rated < minJobs) return;
     const runnerNote = g.runner ? ` (plus ${g.runner} the runner failed on, not counted)` : "";
     // A pairing that rarely finishes.
     if (g.ok / g.rated < 0.5) {
@@ -87,7 +101,7 @@ export function computeSuggestions(records, { minJobs = MIN_JOBS, agentFor = ()
 
   // A lighter model doing as well on the same role's implement work, for much less. Only
   // within one role: different roles do different work, so across roles the numbers don't compare.
-  const impl = [...groups.values()].filter((g) => g.mode === "implement" && g.role && g.model && g.rated >= minJobs && g.tokenJobs >= minJobs);
+  const impl = [...groups.values()].filter((g) => g.mode === "implement" && g.role && g.model && g.rated >= minJobs && g.tokenJobs >= minJobs && current(g));
   for (const heavy of impl) {
     for (const light of impl) {
       if (light === heavy || light.role !== heavy.role || light.model === heavy.model) continue;
@@ -112,22 +126,28 @@ export function computeSuggestions(records, { minJobs = MIN_JOBS, agentFor = ()
       evidence: "Worth knowing rather than changing if it's catching real problems; check its reviews' findings before moving it.", command: null });
   }
 
-  // High-stakes work without an independent review.
-  const unreviewed = records.filter((r) => r.mode === "implement" && r.stakes === "high" && !reviewOf(r, records));
+  // Committed high-stakes work without an independent review. Only work that
+  // landed: a partial never committed isn't accepted work, and one finished by
+  // a later job is that job's to review.
+  const unreviewed = records.filter((r) => r.mode === "implement" && r.stakes === "high" && r.commit?.created && !reviewOf(r, records));
   if (unreviewed.length) {
-    out.push({ level: "warn", key: `unreviewed:${unreviewed.map((r) => r.jobId).sort().join(",")}`, title: `${unreviewed.length} high-stakes job(s) without an independent review: ${unreviewed.slice(0, 5).map((r) => r.jobId).join(", ")}`,
-      evidence: "Send a scout on another vendor with reviews: <job id> before accepting them (or configure a judge on another vendor).", command: null });
+    const ids = unreviewed.map((r) => r.jobId).sort();
+    out.unshift({ level: "act", key: `unreviewed:${ids.join(",")}`, title: `${ids.length} high-stakes job(s) committed without an independent review: ${ids.join(", ")}`,
+      evidence: "Review each before merging: a scout on another vendor (army_role security-analyst, say) with reviews: <job id>. A review that failed or timed out doesn't count.", command: null });
   }
+  const rank = { act: 0, warn: 1, info: 2 };
+  out.sort((a, b) => rank[a.level] - rank[b.level]);
+  if (stale) out.push({ level: "info", key: "stale", title: `${stale} more about role and model pairings you haven't used in ${CURRENT_DAYS} days, hidden (nomarmy stats --all-suggestions)`, evidence: null, command: null });
   return out;
 }
 
 /** This repository's suggestions from its last 14 days of jobs. */
 export function recentSuggestions(records, { projectDir, agentFor = () => null, now = Date.now(), days = 14 } = {}) {
   const since = now - days * 86400000;
-  return computeSuggestions(records.filter((r) => r.projectDir === projectDir && Date.parse(r.startedAt ?? "") >= since), { agentFor });
+  return computeSuggestions(records.filter((r) => r.projectDir === projectDir && Date.parse(r.startedAt ?? "") >= since), { agentFor, now });
 }
 
 export function formatSuggestions(list) {
   if (!list.length) return ["  none: nothing in the records suggests a routing change"];
-  return list.flatMap((s) => [`  ${s.level === "warn" ? "!" : "-"} ${s.title}`, `    ${s.evidence}`, ...(s.command ? [`    ${s.command}`] : [])]);
+  return list.flatMap((s) => [`  ${{ act: "!!", warn: "!", info: "-" }[s.level] ?? "-"} ${s.title}`, ...(s.evidence ? [`    ${s.evidence}`] : []), ...(s.command ? [`    ${s.command}`] : [])]);
 }

package/mcp/server.mjs

@@ -37,7 +37,7 @@ import { modelRefusals } from "../lib/health.mjs";
 import { podmanProblem, podmanVmStartedAt } from "../lib/podman-health.mjs";
 import { restartNotice } from "../lib/install-freshness.mjs";
 import { requestJobStop } from "../lib/openclaw-run.mjs";
-import { loadJobRecords, computeStats, formatStats, parseSince, resolveRepo, agentLookup } from "../lib/stats.mjs";
+import { loadJobRecords, computeStats, formatStats, formatStatsSummary, parseSince, resolveRepo, agentLookup } from "../lib/stats.mjs";
 import { recentSuggestions } from "../lib/suggestions.mjs";
 import { probeModel } from "../lib/model-probe.mjs";
 import { jevSettings, judgeSettings } from "../lib/validators.mjs";
@@ -453,13 +453,14 @@ server.tool("stats", "What nomArmy's own job records show for this repository (o
   role: z.string().regex(/^[a-z][a-z0-9-]{0,63}$/).optional().describe("Only jobs dispatched as this army role (e.g. sr-dev)."),
   model: z.string().regex(/^\S{1,200}$/).optional().describe("Only jobs that ran on this model (e.g. grok-4.7)."),
   format: z.enum(["text", "json"]).optional().describe("text (default) is the report; json is the raw numbers."),
-}, async ({ since, until, all_repos, repo, role, model, format }) => {
+  details: z.boolean().optional().describe("The full report (volume, reviewers, flags, what didn't finish). Default is the one-screen summary: what nomArmy caught, high-stakes work needing review, the top routing tips, spend."),
+}, async ({ since, until, all_repos, repo, role, model, format, details }) => {
   try {
     const records = loadJobRecords(jobsRoot);
     let agentFor = () => null;
     try { agentFor = agentLookup(agentsConfig().agents, agentProviderId); } catch { /* commands name <agent> */ }
     const stats = computeStats(records, { repo: repo ? resolveRepo(records, repo) : all_repos ? null : projectDir, sinceMs: parseSince(since), untilMs: parseSince(until), role: role ?? null, model: model ?? null, agentFor });
-    return toolText(format === "json" ? JSON.stringify(stats, null, 2) : formatStats(stats));
+    return toolText(format === "json" ? JSON.stringify(stats, null, 2) : details ? formatStats(stats) : formatStatsSummary(stats));
   } catch (error) { return toolText(error.message, true); }
 });
 

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.16",
+  "version": "0.1.0-alpha.17",
   "private": false,
   "type": "module",
   "engines": {