nomarmy 0.1.0-alpha.2 → 0.1.0-alpha.21

package/lib/stats.mjs

@@ -0,0 +1,315 @@
+// nomarmy stats: what nomArmy's own job records show, for one repo or all,
+// over a period. Every number comes from a job's verified record
+// (metadata.json), never from a worker's report. What the records can't
+// show (defects the General found at integration) is said, not guessed.
+
+import fs from "node:fs";
+import path from "node:path";
+import { computeSuggestions, formatSuggestions, reviewOf } from "./suggestions.mjs";
+
+const SUGGESTION_WINDOW_MS = 14 * 86400000;
+
+/** Every readable job record under jobsRoot. */
+export function loadJobRecords(jobsRoot) {
+  let names = [];
+  try { names = fs.readdirSync(jobsRoot); } catch { return []; }
+  const records = [];
+  for (const name of names) {
+    try { records.push(JSON.parse(fs.readFileSync(path.join(jobsRoot, name, "metadata.json"), "utf8"))); } catch { /* unfinished or unreadable */ }
+  }
+  return records;
+}
+
+/** An agent name from agents.yml for a provider id, when exactly one agent uses it. */
+export function agentLookup(agents = {}, providerOf) {
+  return (provider) => {
+    if (!provider) return null;
+    const names = Object.entries(agents).filter(([, a]) => { try { return providerOf(a) === provider; } catch { return false; } }).map(([name]) => name);
+    return names.length === 1 ? names[0] : null;
+  };
+}
+
+/** "7d", "24h", or a date; returns epoch ms or null. */
+export function parseSince(value, now = Date.now()) {
+  if (!value) return null;
+  const rel = /^(\d+)\s*([dh])$/i.exec(String(value).trim());
+  if (rel) return now - Number(rel[1]) * (rel[2].toLowerCase() === "d" ? 86400000 : 3600000);
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) throw new Error(`--since must be a date (2026-09-25) or an age (7d, 24h), got "${value}"`);
+  return ms;
+}
+
+/** The army role a job ran as: stamped on newer records, read from the brief on older ones. */
+export function jobRole(record) {
+  if (record.labels?.role) return record.labels.role;
+  const m = /^\[nomArmy role: ([a-z][a-z0-9-]*)/.exec(String(record.objective ?? record.task ?? ""));
+  return m ? m[1] : null;
+}
+
+export function jobModel(record) {
+  const provider = record.metrics?.worker_provider ?? record.worker?.provider ?? null;
+  const model = record.metrics?.worker_model ?? record.worker?.model ?? null;
+  if (record.mode === "verify") return null;
+  return model ? (provider && provider !== "llama-cpp" ? `${model}` : `${model} (local)`) : null;
+}
+
+const count = (items, key) => items.reduce((m, x) => { const k = key(x) ?? "unassigned"; m[k] = (m[k] ?? 0) + 1; return m; }, {});
+const sortDesc = (obj) => Object.fromEntries(Object.entries(obj).sort((a, b) => b[1] - a[1]));
+function percentile(values, p) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.min(sorted.length - 1, Math.ceil((p / 100) * sorted.length) - 1)];
+}
+
+// Review flags and harness notes, counted by the issue line nomArmy wrote.
+const SIGNALS = [
+  ["runner cleanup crash (report recovered)", /runner cleanup failed after the run|OpenClaw's cleanup failed/i],
+  ["scoped test selection risk", /^SCOPED TEST SELECTION RISK/],
+  ["existing tests modified (review)", /^TEST CHANGE REVIEW/],
+  ["code wired to nothing", /^UNWIRED NEW DEFINITION/],
+  ["check rewritten to pass", /^VERIFICATION INPUT CHANGED/],
+  ["mutants survived", /^MUTANTS SURVIVED/],
+  ["report may not match diff (Jev)", /^REPORT MAY NOT MATCH THE DIFF/],
+  ["citations may not support findings (Jev)", /^CITATIONS MAY NOT SUPPORT/],
+  ["judge flag", /^JUDGE \(/],
+  ["possible secret", /^POSSIBLE SECRET/],
+  ["tools outside the sandbox", /^TOOLS OUTSIDE THE SANDBOX/],
+  ["Podman VM restarted mid-job", /Podman (VM|machine).*(restarted|stopped) during this job/i],
+];
+
+/**
+ * A repository by path, or by folder name: an exact folder name wins, then
+ * one ending in it (senti → rayson-senti, not rayson-senti-shared-services),
+ * then one containing it. Throws when it matches none or several.
+ */
+export function resolveRepo(records, value) {
+  if (!value) return null;
+  if (fs.existsSync(value)) return path.resolve(value);
+  const repos = [...new Set(records.map((r) => r.projectDir).filter(Boolean).map((p) => path.resolve(p)))];
+  const exact = repos.filter((p) => path.basename(p) === value);
+  const lower = String(value).toLowerCase();
+  const ending = repos.filter((p) => path.basename(p).toLowerCase().endsWith(`-${lower}`) || path.basename(p).toLowerCase().endsWith(`_${lower}`));
+  const matches = exact.length ? exact : ending.length ? ending : repos.filter((p) => path.basename(p).toLowerCase().includes(lower));
+  if (matches.length === 1) return matches[0];
+  if (!matches.length) throw new Error(`no repository with jobs matches "${value}"; repositories: ${repos.map((p) => path.basename(p)).join(", ") || "(none)"}`);
+  throw new Error(`"${value}" matches several repositories: ${matches.map((p) => path.basename(p)).join(", ")}; use more of the name or a path`);
+}
+
+/**
+ * @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, runId = 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;
+    if (untilMs != null && !(at <= untilMs)) return false;
+    if (repo && r.projectDir && path.resolve(r.projectDir) !== path.resolve(repo)) return false;
+    if (role && jobRole(r) !== role) return false;
+    if (model && (r.metrics?.worker_model ?? r.worker?.model) !== model) return false;
+    if (runId && r.labels?.runId !== runId) return false;
+    return true;
+  });
+  // Verify runs from before records carried the repo can't be placed in one.
+  const unplaced = repo ? inRange.filter((r) => !r.projectDir).length : 0;
+  const jobs = repo ? inRange.filter((r) => r.projectDir) : inRange;
+  const implement = jobs.filter((r) => r.mode === "implement");
+  const scouts = jobs.filter((r) => r.mode === "scout");
+  const committed = implement.filter((r) => r.commit?.created || r.commit?.sha);
+
+  const workerMinutes = implement.map((r) => r.metrics?.worker_elapsed).filter(Number.isFinite).map((ms) => ms / 60000);
+  const jobMinutes = implement.map((r) => r.metrics?.total_elapsed).filter(Number.isFinite).map((ms) => ms / 60000);
+  const tokens = { total: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, untracked: 0 };
+  const spend = {};
+  for (const r of jobs) {
+    const m = r.metrics ?? {};
+    tokens.total += m.worker_tokens_total ?? 0; tokens.input += m.worker_tokens_in ?? 0; tokens.output += m.worker_tokens_out ?? 0;
+    tokens.cacheRead += m.worker_tokens_cache_read ?? 0; tokens.cacheWrite += m.worker_tokens_cache_write ?? 0;
+    if (r.mode !== "verify" && !(m.worker_tokens_total > 0)) tokens.untracked++;
+    if (Number.isFinite(m.worker_cost_usd) && m.worker_cost_usd > 0) spend[jobModel(r) ?? "unknown"] = (spend[jobModel(r) ?? "unknown"] ?? 0) + m.worker_cost_usd;
+  }
+
+  // Claim vs evidence: implement jobs whose worker reported done with tests passing.
+  const claimedDone = implement.filter((r) => r.reportValidation?.status === "done" && r.reportValidation?.tests === "pass");
+  const verificationFailed = claimedDone.filter((r) => r.independentVerification?.status === "fail");
+  const revertStillPassed = claimedDone.filter((r) => r.independentVerification?.status === "pass" && r.regressionCheck?.status === "fail");
+  // Claimed success with an empty diff: there was nothing to verify.
+  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) {
+    const n = jobs.filter((r) => [...(r.issues ?? []), ...(r.runnerNotes ?? [])].some((i) => re.test(i))).length;
+    if (n) signals[name] = n;
+  }
+
+  const reviewers = {};
+  for (const r of scouts) {
+    const role = jobRole(r) ?? "unassigned";
+    const entry = reviewers[role] ??= { runs: 0, outcomes: {}, findings: 0 };
+    entry.runs++;
+    entry.outcomes[r.outcome ?? "unknown"] = (entry.outcomes[r.outcome ?? "unknown"] ?? 0) + 1;
+    entry.findings += r.scout?.findings?.length ?? 0;
+  }
+
+  const times = jobs.map((r) => Date.parse(r.startedAt ?? "")).filter(Number.isFinite);
+  return {
+    period: { from: times.length ? new Date(Math.min(...times)).toISOString() : null, to: times.length ? new Date(Math.max(...times)).toISOString() : null },
+    repo, role, model, unplacedVerifyRuns: role || model ? 0 : unplaced,
+    volume: {
+      jobs: jobs.length,
+      byMode: sortDesc(count(jobs, (r) => r.mode)),
+      byRole: sortDesc(count(jobs.filter((r) => r.mode !== "verify"), jobRole)),
+      byModel: sortDesc(count(jobs.filter((r) => r.mode !== "verify"), jobModel)),
+      byOutcome: sortDesc(count(jobs, (r) => r.outcome)),
+    },
+    code: {
+      committedJobs: committed.length,
+      linesAdded: committed.reduce((s, r) => s + (r.git?.additions ?? r.metrics?.lines_added ?? 0), 0),
+      linesRemoved: committed.reduce((s, r) => s + (r.git?.deletions ?? r.metrics?.lines_removed ?? 0), 0),
+      files: new Set(committed.flatMap((r) => r.git?.changedFiles ?? [])).size,
+      newTestFiles: committed.reduce((s, r) => s + (r.testChanges?.new_tests_added?.length ?? r.metrics?.new_tests_added ?? 0), 0),
+    },
+    workerMinutes: { median: percentile(workerMinutes, 50), p90: percentile(workerMinutes, 90), total: workerMinutes.reduce((a, b) => a + b, 0) },
+    jobMinutes: { median: percentile(jobMinutes, 50), p90: percentile(jobMinutes, 90), total: jobMinutes.reduce((a, b) => a + b, 0) },
+    tokens,
+    spendUsd: { total: Object.values(spend).reduce((a, b) => a + b, 0), byModel: sortDesc(spend) },
+    claimVsEvidence: {
+      claimedDone: claimedDone.length,
+      verificationFailed: verificationFailed.length,
+      revertStillPassed: revertStillPassed.length,
+      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: (() => {
+      // 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, now, includeStale: allSuggestions }),
+    suggestionWindow: sinceMs == null ? "the last 14 days" : "this period",
+  };
+}
+
+const pct = (n, of) => (of ? ` (${Math.round((100 * n) / of)}%)` : "");
+const list = (obj) => Object.entries(obj).map(([k, v]) => `${k} ${v}`).join(" · ") || "none";
+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 ?? []).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)` : ""}`,
+    `  By role       ${list(s.volume.byRole)}`,
+    `  By model      ${list(s.volume.byModel)}`,
+    `  Committed     ${s.code.committedJobs} job(s) · +${s.code.linesAdded} / -${s.code.linesRemoved} lines · ${s.code.files} files · ${s.code.newTestFiles} new test files`,
+    `  Worker time   median ${mins(s.workerMinutes.median)} per implement job, p90 ${mins(s.workerMinutes.p90)}, total ${Math.round(s.workerMinutes.total)} min`,
+    `  Job time      median ${mins(s.jobMinutes.median)}, p90 ${mins(s.jobMinutes.p90)}, total ${Math.round(s.jobMinutes.total)} min (with verification and checks)`,
+    `  Tokens        ${big(s.tokens.total)} total (${big(s.tokens.input)} in, ${big(s.tokens.output)} out, ${big(s.tokens.cacheRead)} cache read)${s.tokens.untracked ? `; ${s.tokens.untracked} job(s) recorded no token counts` : ""}`,
+    `  API spend     $${s.spendUsd.total.toFixed(2)}${Object.keys(s.spendUsd.byModel).length ? ` (${Object.entries(s.spendUsd.byModel).map(([k, v]) => `${k} $${v.toFixed(2)}`).join(", ")})` : ""}; subscriptions aren't billed per call`,
+    "",
+    `CLAIM VS EVIDENCE (implement jobs that reported "done, tests pass": ${c.claimedDone})`,
+    `  Independent verification failed       ${c.verificationFailed}${pct(c.verificationFailed, c.claimedDone)}`,
+    `  Passed, but reverting still passed    ${c.revertStillPassed}${pct(c.revertStillPassed, c.claimedDone)}`,
+    `  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 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",
+    ...(Object.keys(s.notCompleted).length ? Object.entries(s.notCompleted).map(([k, v]) => `  ${k.padEnd(28)} ${v}`) : ["  none"]),
+    "",
+    "REVIEWERS (scouts)",
+    ...(Object.keys(s.reviewers).length ? Object.entries(s.reviewers).map(([role, r]) => `  ${role.padEnd(18)} ${r.runs} run(s), ${r.findings} finding(s); ${list(r.outcomes)}`) : ["  none"]),
+    "",
+    "REVIEW FLAGS AND HARNESS SIGNALS (jobs)",
+    ...(Object.keys(s.signals).length ? Object.entries(s.signals).map(([k, v]) => `  ${k.padEnd(42)} ${v}`) : ["  none"]),
+  ];
+  return lines.join("\n");
+}

package/lib/statusline.mjs

@@ -27,6 +27,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { mergeUsageSnapshot, normalizeClaudeRateLimits, readUsageSnapshots, recordUsageSnapshot, usageStatus } from "./usage-limits.mjs";
 
 function readJson(file) { try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; } }
 function pidAlive(pid) {
@@ -47,6 +48,17 @@ const minutes = (ms) => (ms < 60000 ? `${Math.max(1, Math.round(ms / 1000))}s` :
  */
 export function statusLineText({ session = {}, stateRoot, now = Date.now(), maxLength = Number(process.env.NOMARMY_STATUSLINE_MAX) || 90 } = {}) {
   const root = stateRoot ?? (process.env.NOMARMY_AGENT_STATE || path.join(os.homedir(), ".local", "share", "nomarmy-local-agents"));
+  // Every Claude Code window redraws this line with its own last-seen
+  // limits, idle ones included, so a reading is merged rather than trusted
+  // (mergeUsageSnapshot). Unchanged observations refresh on a bounded interval.
+  try {
+    const snapshot = normalizeClaudeRateLimits(session.rate_limits);
+    if (snapshot) {
+      const previous = readUsageSnapshots(root)["claude-cli"];
+      const merged = mergeUsageSnapshot(previous, { ...snapshot, sourceId: session.session_id, observedAt: now }, now);
+      if (merged !== previous) recordUsageSnapshot(root, "claude-cli", merged);
+    }
+  } catch { /* usage capture must never break the status line */ }
   // workspace.project_dir is where Claude Code was launched -- the repo that
   // session's nomArmy server works in; current_dir can be a subdirectory.
   const cwd = session.workspace?.project_dir ?? session.workspace?.current_dir ?? session.cwd ?? process.cwd();
@@ -99,23 +111,37 @@ export function statusLineText({ session = {}, stateRoot, now = Date.now(), maxL
   try {
     const health = readJson(path.join(root, "health.json"));
     if (health && now - Date.parse(health.checkedAt) < 2 * 86400000) {
-      const top = (health.issues ?? []).find((i) => i.severity !== "info" && i.short);
+      // Usage warnings get their own part below, so they aren't repeated here.
+      const top = (health.issues ?? []).find((i) => i.severity !== "info" && i.short && !String(i.id).startsWith("usage:"));
       if (top) healthPart = ` │ ⚠ ${top.short}`;
     }
   } catch { /* no health yet */ }
   runPart += healthPart;
-  // As many jobs as fit, then "+N": the run summary is never what gets cut.
+  let usageParts = [];
+  try {
+    const warnings = Object.entries(readUsageSnapshots(root)).map(([provider, snapshot]) => {
+      const status = usageStatus(snapshot, now);
+      if (status.level === "ok") return null;
+      return { level: status.level, text: ` │ ${status.level === "over" ? "⛔" : "⚠"} ${provider} ${status.short}` };
+    }).filter(Boolean).sort((a, b) => (a.level === "over" ? 0 : 1) - (b.level === "over" ? 0 : 1));
+    usageParts = warnings.map((warning) => warning.text);
+  } catch { /* usage display is best-effort */ }
+  // As many jobs as fit, then "+N". Only after every job is collapsed may
+  // lower-priority usage warnings be omitted to honor the hard cap.
   const prefix = `${head ? `${head} │ ` : ""}🍪 `;
   const count = jobs.length > 1 ? `${jobs.length}: ` : "";
-  let shown = jobs.length, army;
+  let shown = jobs.length, army, suffix;
   for (;;) {
     const rest = jobs.length - shown;
     army = (!jobs.length ? "idle" : `${count}${jobs.slice(0, shown).join(" · ")}${rest ? `${shown ? " " : ""}+${rest}` : ""}`)
       + (elsewhere ? ` · ${elsewhere} in other repo${elsewhere === 1 ? "" : "s"}` : "");
-    if (shown === 0 || [...`${prefix}${army}${runPart}`].length <= maxLength) break;
-    shown--;
+    suffix = runPart + usageParts.join("");
+    if ([...`${prefix}${army}${suffix}`].length <= maxLength) break;
+    if (shown > 0) { shown--; continue; }
+    if (usageParts.length) { usageParts.pop(); continue; }
+    break;
   }
-  return `${prefix}${army}${runPart}`;
+  return `${prefix}${army}${suffix}`;
 }
 
 const isMain = (() => { try { return path.resolve(process.argv[1] ?? "") === fileURLToPath(import.meta.url); } catch { return false; } })();

package/lib/subscription-setup.mjs

@@ -187,6 +187,19 @@ export function probeOutcome({ stdout = "", stderr = "" } = {}) {
   return { ok: false, reason: message ? message.replace(/\\"/g, '"').slice(0, 300) : null };
 }
 
+/**
+ * A probe answer that means the login itself failed, not the model.
+ * 401, a missing bearer, no usable profiles, or an unavailable selected
+ * profile are sign-in failures. A refusal, rate limit, or timeout is not.
+ */
+export function openclawSignInFailure(text) {
+  const s = String(text ?? "");
+  return /\b401\b/.test(s)
+    || /missing bearer/i.test(s)
+    || /no usable profiles/i.test(s)
+    || /selected auth profile\b[^]{0,240}?\bis unavailable/i.test(s);
+}
+
 /**
  * Muse Code's non-secret login descriptor (~/.config/muse/auth.json) ->
  * { loggedIn, email }. Reads only descriptor fields; the credential itself

package/lib/suggestions.mjs

@@ -0,0 +1,153 @@
+// Routing suggestions from the job records: which role and model pairings
+// are working, which aren't, and what a change would be. Evidence first,
+// with minimum sample sizes; roles do different work, so a comparison across
+// roles is worded as something to try, not a verdict. Never applied: the
+// operator or the General decides, and each suggestion carries the command.
+
+import { jobRole } from "./stats.mjs";
+
+export const MIN_JOBS = 5;
+const OK = /^(WORKER_DONE|RECOVERED_SUCCESS|SCOUT_DONE|SCOUT_NOT_FOUND|DECOMPOSE_DONE|VERIFIED)$/;
+
+const provider = (r) => r.metrics?.worker_provider ?? r.worker?.provider ?? null;
+const model = (r) => r.metrics?.worker_model ?? r.worker?.model ?? null;
+// The local model is the built-in "local" agent, whatever model is loaded.
+const agent = (r) => r.labels?.agent ?? (provider(r) === "llama-cpp" ? "local" : null);
+// New tokens only: cache reads are most of an api job's total and cost a fraction.
+const freshTokens = (r) => (r.metrics?.worker_tokens_in ?? 0) + (r.metrics?.worker_tokens_out ?? 0);
+/** The runner exited before a report: an OpenClaw, sandbox or provider failure, not the model's 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);
+
+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 && 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 };
+  return null;
+}
+
+/**
+ * @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, 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, 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++;
+    if (r.outcome === "SCOUT_UNSUPPORTED") g.unsupported++;
+    if (freshTokens(r) > 0) { g.tokens += freshTokens(r); g.tokenJobs++; }
+    g.agent = g.agent ?? agent(r) ?? agentFor(provider(r));
+    groups.set(key, g);
+  }
+  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.
+    if (g.runner >= 3 && g.runner / g.jobs >= 0.4) {
+      out.push({ level: "warn", key: `runner-failed:${g.role}:${g.model}:${g.mode}`, title: `${who}: the runner failed on ${g.runner} of ${g.jobs} ${kind} before any report`,
+        evidence: "OpenClaw, the sandbox or the provider exited early, so these say nothing about the model's work. Check `nomarmy health` and one job's log (`nomarmy jobs <id>`); a model its vendor refuses fails this way too.", command: null });
+    }
+    // Scouts that come back empty.
+    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) });
+      return;
+    }
+    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) {
+      const better = [...groups.values()].filter((o) => o !== g && o.mode === g.mode && o.rated >= minJobs && o.model && o.ok / o.rated >= g.ok / g.rated + 0.2)
+        .sort((a, b) => b.ok / b.rated - a.ok / a.rated)[0];
+      out.push({ level: "warn", key: `low-success:${g.role}:${g.model}:${g.mode}`, title: `${who} finished ${g.ok} of ${g.rated} ${g.role ? kind : ""}`.trim() + ` (${pct(g.ok, g.rated)}%)${runnerNote}`,
+        evidence: (better ? `${better.model} finished ${pct(better.ok, better.rated)}% of its ${better.rated} ${kind} here${better.role ? ` (as ${better.role})` : ""}.` : "No other model has enough jobs here to compare.") + (g.role ? "" : " These ran with no army role: send this kind of work to a role on a stronger agent instead."),
+        command: g.role ? assign(g, better?.model ?? "<another model>") : null });
+    }
+    // Timeouts.
+    if (g.timeout >= 3 && g.timeout / g.rated >= 0.25) {
+      out.push({ level: "info", key: `timeouts:${g.role}:${g.model}`, title: `${who} timed out on ${g.timeout} of ${g.rated} jobs`,
+        evidence: "Smaller briefs (one outcome each), a longer timeout_seconds, or a faster model would help.", command: null });
+    }
+  }
+
+  // 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 && current(g));
+  for (const heavy of impl) {
+    for (const light of impl) {
+      if (light === heavy || light.role !== heavy.role || light.model === heavy.model) continue;
+      const lightRate = light.ok / light.rated, heavyRate = heavy.ok / heavy.rated;
+      const lightPerJob = light.tokens / light.tokenJobs, heavyPerJob = heavy.tokens / heavy.tokenJobs;
+      if (lightRate >= heavyRate - 0.05 && lightPerJob <= 0.5 * heavyPerJob) {
+        out.push({ level: "info", key: `lighter:${heavy.role}:${heavy.model}:${light.model}`,
+          title: `${heavy.role}: ${light.model} finished ${pct(light.ok, light.rated)}% of its jobs on ${Math.round(lightPerJob / 1000)}k new tokens a job; ${heavy.model} finished ${pct(heavy.ok, heavy.rated)}% on ${Math.round(heavyPerJob / 1000)}k`,
+          evidence: `Same role, so similar work. Moving ${heavy.role} to ${light.model} would cost less; keep ${heavy.model} for the harder pieces with model on the job.${light.agent === "local" ? ` The local agent runs whichever model is loaded; these ran on ${light.model}.` : ""}`,
+          command: light.agent ? `nomarmy army assign ${heavy.role} ${light.agent}${light.agent === "local" ? "" : ` ${light.model}`}` : null });
+      }
+    }
+  }
+
+  // Where the money goes.
+  const spend = new Map();
+  for (const r of work) if (Number.isFinite(r.metrics?.worker_cost_usd) && r.metrics.worker_cost_usd > 0) spend.set(model(r), (spend.get(model(r)) ?? 0) + r.metrics.worker_cost_usd);
+  const total = [...spend.values()].reduce((a, b) => a + b, 0);
+  const [top, topUsd] = [...spend.entries()].sort((a, b) => b[1] - a[1])[0] ?? [];
+  if (top && topUsd >= 5 && topUsd / total >= 0.5) {
+    out.push({ level: "info", key: `spend:${top}`, title: `${top} is ${pct(topUsd, total)}% of API spend ($${topUsd.toFixed(2)} of $${total.toFixed(2)})`,
+      evidence: "Worth knowing rather than changing if it's catching real problems; check its reviews' findings before moving it.", command: null });
+  }
+
+  // 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) {
+    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, now });
+}
+
+export function formatSuggestions(list) {
+  if (!list.length) return ["  none: nothing in the records suggests a routing change"];
+  return list.flatMap((s) => [`  ${{ act: "!!", warn: "!", info: "-" }[s.level] ?? "-"} ${s.title}`, ...(s.evidence ? [`    ${s.evidence}`] : []), ...(s.command ? [`    ${s.command}`] : [])]);
+}

package/lib/thinking.mjs

@@ -0,0 +1,23 @@
+// Thinking levels, as OpenClaw names them (`openclaw agent exec --thinking`).
+// Which ones a model honors is the vendor's business: OpenClaw refuses a level
+// a model lacks and names the ones it has, and nomArmy retries once with the
+// nearest of those (lib/openclaw-run.mjs).
+
+export const THINKING_LEVELS = Object.freeze(["off", "minimal", "low", "medium", "high", "xhigh", "adaptive", "max", "ultra"]);
+
+// Strength order for picking a fallback; "adaptive" lets the model choose, so it sits mid-way.
+const RANK = { off: 0, minimal: 1, low: 2, medium: 3, adaptive: 3.5, high: 4, xhigh: 5, max: 6, ultra: 7 };
+
+/**
+ * The supported level closest to the one refused: the strongest at or below
+ * it, else the weakest above it. The old fallback took the first listed,
+ * often "off", so a refused xhigh would have run with no thinking at all.
+ */
+export function nearestThinkingLevel(requested, supported) {
+  const known = supported.filter((l) => l in RANK);
+  if (!known.length) return supported[0] ?? null;
+  const want = RANK[requested] ?? RANK.medium;
+  const below = known.filter((l) => RANK[l] <= want).sort((a, b) => RANK[b] - RANK[a]);
+  if (below.length && !(below[0] === "off" && want > 0 && known.some((l) => RANK[l] > 0))) return below[0];
+  return known.filter((l) => RANK[l] > 0).sort((a, b) => RANK[a] - RANK[b])[0] ?? below[0];
+}