@claude-flow/cli 3.56.8 → 3.56.10

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.42.0
+3.56.9

package/.claude/helpers/helpers.manifest.json

@@ -1,14 +1,14 @@
 {
   "manifest": {
-    "version": "3.56.8",
+    "version": "3.56.10",
     "files": {
       "auto-memory-hook.mjs": "631fac9d518835e2852a406888316bbbddddb49e7ed8e406d2e971f46833df9a",
-      "hook-handler.cjs": "0f855c667b8d2d04cb4fe91b14b351d14c3dfb30516dcd9d7ae156acbe0a689d",
-      "intelligence.cjs": "f486be296eb2f0518f34b8f4453d9d0a988845e4aec6d18d8d47725aca6dd38b",
+      "hook-handler.cjs": "bc12b3cae92d5a7c8deef699fa00d0ef07b57625c18dbeac4387f15725b8e09f",
+      "intelligence.cjs": "a95ac9ee2759c340b14f9ff656765bcb05e0cefe2f018116bd26b3ba9987f3e4",
       "statusline.cjs": "d72417ecb38634011a19f095a30e07b9929e6f97663520172ece9be7491b2eaa",
       "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d"
     }
   },
-  "signature": "ld9RNoF9lnGKjlUpofQLwCZgtE9Y5QiNNkYZLGsSQhZGp51JhBnHymH9YWpFC3F1HBslxRnea6U2TVczJKK5Bg==",
+  "signature": "hZ0iy15VIKpZOjC2iG2fPsV68csqXrMhn2mifCIvzsjngaB/wmP0P4iMF38nAo57MeANEM6wW1nhK7YvteUXCg==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/hook-handler.cjs

@@ -682,7 +682,8 @@ const handlers = {
     const dangerous = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:'];
     // Join literal quote fragments and normalize root paths without shell evaluation.
     function hasRootDelete(command, depth = 0) {
-      let word = '', quote = '', started = false, redirect = false
+      // mask has one letter per character of word: 'u' unquoted, 'q' quoted or escaped (only unquoted braces expand).
+      let word = '', mask = '', quote = '', started = false, redirect = false
       let ansiNul = false // a NUL inside $'...' ends that string, as in bash
       let inRm = false, optionsEnded = false, recursive = false, force = false, root = false
       const isRoot = (operand) => {
@@ -712,23 +713,92 @@ const handlers = {
         if (c === 'c' && at + 1 < s.length) return [String.fromCharCode(s.charCodeAt(at + 1) & 31), at + 1]
         return ['\\' + c, at]
       }
-      const finishWord = () => {
-        if (!started) return false
-        // Literal shell strings (e.g. sh -c 'rm -rf /') also carried the old guard.
-        // Bound rescanning to four levels; beyond that retain its conservative check.
-        if (/[\s;&|()\x60]/.test(word)) {
-          if (depth < 4 ? hasRootDelete(word, depth + 1) : word.includes('rm -rf /')) return true
+      // Past the rescan bound (or the brace budget), a string is judged by its tokens: an rm and a possible root operand
+      // anywhere in it deny. Quote characters are dropped first, so r"m" is still rm; a path token with braces may expand to /.
+      const looseRootDelete = (text) => {
+        const tokens = text.replace(/["'\\]/g, '').split(/[\s;&|()\x60$]+/)
+        return tokens.some(t => t === 'rm' || t.endsWith('/rm')) && tokens.some(t => isRoot(t) || (t.includes('/') && /[{}]/.test(t)))
+      }
+      // Bash brace expansion of one word ({a,b} lists, nested or glued to text), and nothing else: no {1..3} sequences, and
+      // nothing inside parameter braces after a dollar sign. Only unquoted braces and commas count. Iterative and bounded:
+      // past BRACE_WORDS words or BRACE_CHARS characters of work in this call it returns undefined.
+      const BRACE_WORDS = 4096
+      let braceChars = 1_000_000
+      // The leftmost expandable group: an unquoted {...} with an unquoted comma at its own level, outside any dollar-brace parameter. One pass.
+      const firstGroup = (text, marks) => {
+        const stack = []
+        let dollars = 0
+        let best
+        for (let k = 0; k < text.length; k++) {
+          if (marks[k] !== 'u') continue
+          const c = text[k]
+          if (c === '{') {
+            const dollar = k > 0 && text[k - 1] === '$' && marks[k - 1] === 'u'
+            if (dollar) dollars++
+            stack.push({ open: k, commas: [], dollar: dollar || dollars > 0 })
+          } else if (c === ',' && stack.length > 0) stack[stack.length - 1].commas.push(k)
+          else if (c === '}' && stack.length > 0) {
+            const top = stack.pop()
+            if (top.dollar && text[top.open - 1] === '$' && marks[top.open - 1] === 'u') dollars--
+            if (!top.dollar && top.commas.length > 0 && (best === undefined || top.open < best[0])) best = [top.open, top.commas, k]
+          }
+        }
+        return best
+      }
+      const braceExpand = (text, marks) => {
+        const out = []
+        const todo = [[text, marks]]
+        while (todo.length > 0) {
+          const [t, m] = todo.pop()
+          if ((braceChars -= t.length) < 0) return undefined
+          const group = firstGroup(t, m)
+          if (group === undefined) {
+            out.push(t)
+            if (out.length > BRACE_WORDS) return undefined
+            continue
+          }
+          const [open, commas, close] = group
+          const cuts = [open, ...commas, close]
+          // Pushed in reverse, so the words come out in bash's left-to-right order.
+          for (let c = cuts.length - 2; c >= 0; c--) {
+            const from = cuts[c] + 1, to = cuts[c + 1]
+            todo.push([t.slice(0, open) + t.slice(from, to) + t.slice(close + 1), m.slice(0, open) + m.slice(from, to) + m.slice(close + 1)])
+          }
+          if (todo.length > BRACE_WORDS) return undefined
         }
-        if (!inRm) inRm = word === 'rm' || word.endsWith('/rm')
-        else if (!optionsEnded && word === '--') optionsEnded = true
-        else if (!optionsEnded && word.startsWith('-')) {
+        return out
+      }
+      const takeWord = (w) => {
+        if (!inRm) inRm = w === 'rm' || w.endsWith('/rm')
+        else if (!optionsEnded && w === '--') optionsEnded = true
+        else if (!optionsEnded && w.startsWith('-')) {
           // GNU getopt accepts any unambiguous long-option prefix: --r, --recur, --forc.
-          recursive = recursive || (word.length > 2 && '--recursive'.startsWith(word)) || /^-[a-z]*r[a-z]*$/.test(word)
-          force = force || (word.length > 2 && '--force'.startsWith(word)) || /^-[a-z]*f[a-z]*$/.test(word)
-        } else root = root || isRoot(word)
-        word = ''; started = false
+          recursive = recursive || (w.length > 2 && '--recursive'.startsWith(w)) || (/^-[a-z]*$/.test(w) && w.includes('r'))
+          force = force || (w.length > 2 && '--force'.startsWith(w)) || (/^-[a-z]*$/.test(w) && w.includes('f'))
+        } else root = root || isRoot(w)
         return inRm && recursive && force && root
       }
+      const finishWord = () => {
+        if (!started) return false
+        const text = word, marks = mask
+        word = ''; mask = ''; started = false
+        // Literal shell strings (e.g. sh -c 'rm -rf /', or sh -c '{rm,-rf,/}') also carried the old guard.
+        // Bound rescanning to four levels; beyond that judge the string by its tokens.
+        if (/[\s;&|()\x60{]/.test(text)) {
+          if (depth < 4 ? hasRootDelete(text, depth + 1) : looseRootDelete(text)) return true
+        }
+        // An unquoted {a,b} becomes separate words, as bash expands it: rm -rf {/*,} is rm -rf /*.
+        const words = text.includes('{') ? braceExpand(text, marks) : [text]
+        if (words === undefined) {
+          // Too many alternatives to check: one of them may be the root (an rm in progress fails closed), or the
+          // list itself may spell the rm: judge its tokens.
+          if (inRm) root = true
+          if (looseRootDelete(text.replace(/[{},]/g, ' '))) return true
+          return takeWord(text)
+        }
+        for (const w of words) if (w !== '' && takeWord(w)) return true
+        return false
+      }
       // A command substitution's body, from just after its opening backtick. Bash removes a
       // backslash only before $, a backtick or a backslash (and " inside double quotes) and
       // drops backslash-newline; any other backslash stays for the nested scan.
@@ -742,7 +812,7 @@ const handlers = {
           }
           body += command[j]
         }
-        return [j, depth < 4 ? hasRootDelete(body, depth + 1) : body.includes('rm -rf /')]
+        return [j, depth < 4 ? hasRootDelete(body, depth + 1) : looseRootDelete(body)]
       }
       const finishCommand = () => {
         const denied = inRm && recursive && force && root
@@ -759,8 +829,8 @@ const handlers = {
             else if (char === '\\' && i + 1 < command.length) {
               const [text, last] = ansiEscape(command, i + 1)
               i = last
-              if (!ansiNul) { const nul = text.indexOf('\0'); if (nul < 0) word += text; else { word += text.slice(0, nul); ansiNul = true } }
-            } else if (!ansiNul) word += char
+              if (!ansiNul) { const nul = text.indexOf('\0'); const kept = nul < 0 ? text : text.slice(0, nul); word += kept; mask += 'q'.repeat(kept.length); if (nul >= 0) ansiNul = true }
+            } else if (!ansiNul) { word += char; mask += 'q' }
             continue
           }
           if (char === quote) quote = ''
@@ -770,20 +840,20 @@ const handlers = {
             // The substitution is gone from the word, as bash's empty output is (a quoted empty substitution glued to -rf leaves -rf).
             // A # right after it is still inside the word: a placeholder keeps a rescan (sh -c "...")
             // from reading it as the start of a comment.
-            if (command[end + 1] === '#') word += '\u0001'
+            if (command[end + 1] === '#') { word += '\u0001'; mask += 'q' }
             i = end
           }
           else if (quote === '"' && char === '\\' && i + 1 < command.length &&
             (command[i + 1] === '"' || command[i + 1] === '\\' || command[i + 1] === '$' ||
               command.charCodeAt(i + 1) === 96 || command[i + 1] === '\n')) {
             const next = command[++i]
-            if (next !== '\n') word += next
-          } else word += char
+            if (next !== '\n') { word += next; mask += 'q' }
+          } else { word += char; mask += 'q' }
           continue
         }
         if (char === '\\' && i + 1 < command.length) {
           const next = command[++i]
-          if (next !== '\n') { word += next; started = true }
+          if (next !== '\n') { word += next; mask += 'q'; started = true }
         } else if (char === '\x60' && command.indexOf('\x60', i + 1) > i) {
           // Command substitution: scan the body as its own command; the substitution
           // stays inside the enclosing word, so the rm being parsed keeps its state,
@@ -806,13 +876,29 @@ const handlers = {
           redirect = char === '<' || char === '>'
           if (!redirectionAmpersand && (char === '\n' || ';|&()'.includes(char)) && finishCommand()) return true
         } else {
-          word += char; started = true
+          word += char; mask += 'u'; started = true
         }
       }
       return finishWord() || finishCommand()
     }
+
+    // A fork bomb's definition as bash reads it, whatever the spacing or the name: f(){ f|f& }, function f { f|f& },
+    // function f(){ f|f& }. Defining one is the danger: the call may come anywhere later.
+    function hasForkBomb(command) {
+      const s = command.replace(/\s+/g, '')
+      for (let brace = s.indexOf('{'); brace >= 0; brace = s.indexOf('{', brace + 1)) {
+        const end = s.startsWith('()', brace - 2) ? brace - 2 : brace
+        let start = end
+        while (start > 0 && end - start < 72 && /[a-z0-9_:.-]/.test(s[start - 1])) start--
+        const run = s.slice(start, end)
+        for (const name of run.startsWith('function') && run.length > 8 ? [run, run.slice(8)] : [run]) {
+          if (name && s.startsWith(name + '|' + name + '&}', brace + 1)) return true
+        }
+      }
+      return false
+    }
     for (const d of dangerous) {
-      if (d === 'rm -rf /' ? hasRootDelete(cmd) : cmd.includes(d)) {
+      if (d === 'rm -rf /' ? hasRootDelete(cmd) : d === ':(){:|:&};:' ? hasForkBomb(cmd) : cmd.includes(d)) {
         console.error(`[BLOCKED] Dangerous command detected: ${d}`);
         // Claude Code PreToolUse: exit 2 blocks execution; exit 1 is non-blocking.
         process.exit(2);

package/.claude/helpers/intelligence.cjs

@@ -739,27 +739,69 @@ function appendRecall(detailed, meta) {
  * getContext(prompt) — Called from route. Budget: <15ms.
  * Matches prompt to ranked entries, returns top-5 formatted context.
  */
+/**
+ * Inflection variants of a prompt term (plural, -ed, -ing, -ion and their
+ * stems), so "migrations" finds an entry that says "migration" and "deploying"
+ * finds "deploy". Exact term matching alone lost what the old trigram overlap
+ * caught (#4136). The stem keeps at least 4 characters so short words stay exact.
+ */
+function termVariants(word) {
+  const out = new Set([word]);
+  for (const suffix of ['s', 'es', 'ed', 'ing', 'ion', 'ions']) out.add(word + suffix);
+  for (const suffix of ['ions', 'ion', 'ing', 'ed', 'es', 's']) {
+    if (word.length - suffix.length >= 4 && word.endsWith(suffix)) {
+      const stem = word.slice(0, -suffix.length);
+      out.add(stem); out.add(stem + 'e'); out.add(stem + 's');
+    }
+  }
+  return [...out];
+}
+
 function getContextDetailed(prompt) {
   if (!prompt) return null;
 
   const ranked = readJSON(RANKED_PATH);
   if (!ranked || !ranked.entries || ranked.entries.length === 0) return null;
 
-  const promptWords = tokenize(prompt);
+  const promptWords = [...new Set(tokenize(prompt))];
   if (promptWords.length === 0) return null;
-  const promptTrigrams = trigrams(promptWords);
 
-  const ALPHA = 0.6; // content match weight
-  const MIN_THRESHOLD = 0.05;
+  // Query coverage is independent of entry length: a short diagnostic prompt
+  // must still find its exact terms inside a long memory section (#4136).
+  // IDF downweights generic terms shared by many entries. Terms absent from
+  // every entry still count against coverage, so two incidental words cannot
+  // hide the rest of an unrelated prompt.
+  const candidates = ranked.entries.map(entry => ({ entry, words: new Set(entry.words || []) }));
+  const variants = promptWords.map(termVariants);
+  const hasTerm = (words, i) => variants[i].some(v => words.has(v));
+  const weights = promptWords.map((word, i) => {
+    const frequency = candidates.reduce((count, candidate) => count + Number(hasTerm(candidate.words, i)), 0);
+    return Math.log1p((candidates.length - frequency + 0.5) / (frequency + 0.5));
+  });
+  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  if (totalWeight === 0) return null;
+
+  const MIN_COVERAGE = 0.15;
   const TOP_K = 5;
 
   // Score each entry
   const scored = [];
-  for (const entry of ranked.entries) {
-    const entryTrigrams = trigrams(entry.words || []);
-    const contentMatch = jaccardSimilarity(promptTrigrams, entryTrigrams);
-    const score = ALPHA * contentMatch + (1 - ALPHA) * (entry.pageRank || 0);
-    if (score >= MIN_THRESHOLD) {
+  for (const { entry, words } of candidates) {
+    let matchedWeight = 0;
+    let matchedTerms = 0;
+    for (let i = 0; i < promptWords.length; i++) {
+      if (weights[i] > 0 && hasTerm(words, i)) {
+        matchedWeight += weights[i];
+        matchedTerms++;
+      }
+    }
+    // A single common word in a long prompt is not evidence of relevance;
+    // PageRank can order relevant entries but cannot make one relevant.
+    if (matchedTerms < Math.min(2, promptWords.length)) continue;
+    const coverage = matchedWeight / totalWeight;
+    if (coverage >= MIN_COVERAGE) {
+      const pageRank = Math.max(0, Math.min(1, Number(entry.pageRank) || 0));
+      const score = 0.9 * coverage + 0.1 * pageRank;
       scored.push({ ...entry, score });
     }
   }

package/.claude/skills/verification-quality/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: "Verification & Quality Assurance"
 description: |
-  Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs and codebase reliability.
+  Check code quality and change risk with ruflo's shipped analysis commands (analyze diff, analyze complexity, analyze code), and run or extend ruflo's own CI regression guards. Use when assessing a change's risk, finding complexity hot spots, or adding a regression guard to ruflo. The truth-scoring and auto-rollback commands described later in this file are design notes, not shipped CLI commands.
 ---
 
 # Verification & Quality Assurance Skill
@@ -62,31 +62,34 @@ node plugins/ruflo-core/scripts/witness/history.mjs --history verification/macos
 
 ## Prerequisites
 
-- Ruflo installed (`npx ruflo@alpha`)
+- Ruflo installed (`npx ruflo@latest`)
 - Git repository (for rollback features)
 - Node.js 18+ (for dashboard features)
 - `@noble/ed25519` (for the witness verifier — a single runtime dep, `npm i @noble/ed25519`)
 
 ## Quick Start
 
-```bash
-# View current truth scores
-npx ruflo@alpha truth
+These commands ship in the current CLI:
 
-# Run verification check
-npx ruflo@alpha verify check
+```bash
+# Change risk since HEAD~1 (without --risk it also shows classification and reviewers)
+npx ruflo@latest analyze diff HEAD~1 --risk
 
-# Verify specific file with custom threshold
-npx ruflo@alpha verify check --file src/app.js --threshold 0.98
+# Complexity hot spots in a directory
+npx ruflo@latest analyze complexity src/ --threshold 15
 
-# Rollback last failed verification
-npx ruflo@alpha verify rollback --last-good
+# Size, functions and TODOs per file
+npx ruflo@latest analyze code -p ./src
 ```
 
+There is no truth-scoring, `verify check` or `verify rollback` command (`ruflo verify` only checks an installed ruflo package against its signed witness manifest). To verify agent output, run the project's own tests, linters and type checks, and roll back with git (`git restore <file>`, `git revert <commit>`). Inside the ruflo repo, run the guards in [Run the guards locally](#run-the-guards-locally).
+
 ---
 
 ## Complete Guide
 
+> **Design notes, not shipped.** Everything below describes a planned truth-scoring, verification and rollback surface. `ruflo truth`, `ruflo verify check` and `ruflo verify rollback` are not commands in the current CLI, so do not run the examples below; use the commands in [Quick Start](#quick-start) instead.
+
 ### Truth Scoring System
 
 #### View Truth Metrics

package/README.md

@@ -51,7 +51,7 @@ MCP exposes Ruflo tools to your client. The console and mods above are Claude Co
 
 <img src="docs/assets/readme/icons/terminal.svg" width="28" height="28" alt=""> **Prefer a plain terminal? Optional.** The console also runs on its own, with no Claude Code: `npx ruflo tui` (add `--plain` to print one frame for scripts). It shows Overview, Cost, Swarm, Events and Missions, plus an optional AI page. [Terminal UI guide](docs/USERGUIDE.md#terminal-ui-optional)
 
-<p align="center"><img src="docs/assets/ruflo-tui-compact.svg" width="640" alt="Looping recording of the optional ruflo terminal UI cycling through Overview, Cost, Swarm, Events and Missions in a sample project"></p>
+<p align="center"><img src="docs/assets/ruflo-tui-compact.svg" width="640" alt="Looping recording of the optional ruflo terminal UI with its pictures: Overview in the Classic BBS look, the Orbital look with its moving globe, and the Swarm graph, in a sample project"></p>
 
 [Compare install paths](#quick-start) · [Open the console](#console-walkthrough) · [User guide](docs/USERGUIDE.md)
 

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-12T17:29:00.623Z",
-  "gitSha": "4f1b3e96",
+  "generatedAt": "2026-10-14T16:22:09.483Z",
+  "gitSha": "1882006a",
   "catalog": {
     "agents": 176,
     "tools": 423,

package/dist/src/autopilot-state.d.ts

@@ -80,6 +80,8 @@ export declare function discoverTasks(sources: string[]): TaskInfo[];
 export declare function isTerminal(status: string): boolean;
 export declare function getProgress(tasks: TaskInfo[]): TaskProgress;
 export declare function calculateReward(iterations: number, durationMs: number): number;
+/** Why the last tryLoadLearning() returned null (null when it succeeded or was never called). */
+export declare function getLearningLoadError(): string | null;
 export declare function tryLoadLearning(): Promise<{
     initialize: () => Promise<boolean>;
     [key: string]: unknown;

package/dist/src/autopilot-state.js

@@ -9,7 +9,9 @@
  */
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, mkdirSync, readdirSync } from 'node:fs';
-import { resolve, join } from 'node:path';
+import { resolve, join, dirname } from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { homedir } from 'node:os';
 import { writeFileAtomic } from './fs-secure.js';
 // ── Constants ─────────────────────────────────────────────────
@@ -288,17 +290,43 @@ export function calculateReward(iterations, durationMs) {
     return Math.round((iterFactor + timeFactor) * 100) / 100;
 }
 // ── Learning Integration ──────────────────────────────────────
+let lastLearningLoadError = null;
+/** Why the last tryLoadLearning() returned null (null when it succeeded or was never called). */
+export function getLearningLoadError() {
+    return lastLearningLoadError;
+}
+/**
+ * agentic-flow's `exports` map does not expose dist/coordination/*, so a bare
+ * specifier import throws ERR_PACKAGE_PATH_NOT_EXPORTED (#4146). Resolve the
+ * package root through its exported entry point and import the file by URL.
+ */
+function resolveAutopilotLearningUrl() {
+    const req = createRequire(import.meta.url);
+    let dir = dirname(req.resolve('agentic-flow'));
+    for (let i = 0; i < 6; i++) {
+        if (existsSync(join(dir, 'package.json')) && existsSync(join(dir, 'dist', 'coordination', 'autopilot-learning.js'))) {
+            return pathToFileURL(join(dir, 'dist', 'coordination', 'autopilot-learning.js')).href;
+        }
+        dir = dirname(dir);
+    }
+    throw new Error('agentic-flow does not ship dist/coordination/autopilot-learning.js');
+}
 export async function tryLoadLearning() {
+    lastLearningLoadError = null;
     try {
-        const modPath = 'agentic-flow/dist/coordination/autopilot-learning.js';
-        const mod = await import(/* webpackIgnore: true */ modPath).catch(() => null);
-        if (mod?.AutopilotLearning) {
-            const instance = new mod.AutopilotLearning();
-            if (await instance.initialize())
-                return instance;
+        const mod = await import(/* webpackIgnore: true */ resolveAutopilotLearningUrl());
+        if (!mod?.AutopilotLearning) {
+            lastLearningLoadError = 'agentic-flow autopilot-learning module has no AutopilotLearning export';
+            return null;
         }
+        const instance = new mod.AutopilotLearning();
+        if (await instance.initialize())
+            return instance;
+        lastLearningLoadError = 'AutopilotLearning.initialize() returned false (AgentDB not initialized)';
+    }
+    catch (e) {
+        lastLearningLoadError = `Could not load agentic-flow autopilot learning: ${e instanceof Error ? e.message : String(e)}`;
     }
-    catch { /* not available */ }
     return null;
 }
 //# sourceMappingURL=autopilot-state.js.map

package/dist/src/command-resolution.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Resolve which (sub)command an invocation targets.
+ *
+ * The parser reports the matched command path (for example
+ * ['hooks', 'transfer', 'store', 'search']) and the remaining positional arguments.
+ * Resolution walks the whole path through each command's `subcommands`, so a command
+ * can sit at any depth. #4157: it used to stop two levels below the top-level command,
+ * so `hooks transfer store search` ran the `store` help instead of `search`.
+ */
+import type { Command } from './types.js';
+export declare function resolveTargetCommand(command: Command, commandPath: string[], positional: string[]): {
+    target: Command;
+    args: string[];
+};
+//# sourceMappingURL=command-resolution.d.ts.map

package/dist/src/command-resolution.js

@@ -0,0 +1,25 @@
+const matches = (sc, name) => sc.name === name || !!sc.aliases?.includes(name);
+export function resolveTargetCommand(command, commandPath, positional) {
+    let target = command;
+    if (commandPath.length > 1 && command.subcommands) {
+        // The parser already removed the path from `positional`.
+        for (const name of commandPath.slice(1)) {
+            const next = target.subcommands?.find((sc) => matches(sc, name));
+            if (!next)
+                break;
+            target = next;
+        }
+        return { target, args: positional };
+    }
+    // Positional form: the path only named the top-level command.
+    let args = positional;
+    while (args.length > 0 && target.subcommands) {
+        const next = target.subcommands.find((sc) => matches(sc, args[0]));
+        if (!next)
+            break;
+        target = next;
+        args = args.slice(1);
+    }
+    return { target, args };
+}
+//# sourceMappingURL=command-resolution.js.map

package/dist/src/commands/agent.js

@@ -736,15 +736,16 @@ const healthCommand = {
             output.writeln(output.bold('Agent Health'));
             output.writeln();
             // Overall summary with null checks
-            const overall = result.overall ?? { healthy: 0, degraded: 0, unhealthy: 0, avgCpu: 0, avgMemory: 0 };
-            const avgCpu = overall.avgCpu ?? 0;
-            const avgMemory = overall.avgMemory ?? 0;
+            const overall = result.overall ?? { healthy: 0, degraded: 0, unhealthy: 0, unknown: 0 };
+            const avgCpu = overall.avgCpu ?? overall.cpu;
+            const avgMemory = overall.avgMemory ?? overall.memory;
             output.printBox([
                 `Healthy: ${output.success(String(overall.healthy ?? 0))}`,
                 `Degraded: ${output.warning(String(overall.degraded ?? 0))}`,
                 `Unhealthy: ${output.error(String(overall.unhealthy ?? 0))}`,
-                `Avg CPU: ${avgCpu.toFixed(1)}%`,
-                `Avg Memory: ${(avgMemory * 100).toFixed(1)}%`
+                `Unknown: ${String(overall.unknown ?? 0)}`,
+                `Avg CPU: ${typeof avgCpu === 'number' ? `${avgCpu.toFixed(1)}%` : 'n/a'}`,
+                `Avg Memory: ${typeof avgMemory === 'number' ? `${(avgMemory * 100).toFixed(1)}%` : 'n/a'}`
             ].join('  |  '), 'Overall Status');
             const healthAgents = result.agents ?? [];
             output.writeln();
@@ -753,14 +754,14 @@ const healthCommand = {
                     { key: 'id', header: 'Agent ID', width: 18 },
                     { key: 'type', header: 'Type', width: 12 },
                     { key: 'health', header: 'Health', width: 10, format: formatHealthStatus },
-                    { key: 'cpu', header: 'CPU %', width: 8, align: 'right', format: (v) => `${Number(v ?? 0).toFixed(1)}%` },
+                    { key: 'cpu', header: 'CPU %', width: 8, align: 'right', format: (v) => typeof v === 'number' ? `${v.toFixed(1)}%` : 'n/a' },
                     { key: 'memory', header: 'Memory', width: 10, align: 'right', format: (v) => {
                             const mem = v;
-                            if (!mem)
-                                return '0%';
+                            if (!mem || !mem.limit)
+                                return 'n/a';
                             return `${(mem.used / mem.limit * 100).toFixed(0)}%`;
                         } },
-                    { key: 'tasks', header: 'Tasks', width: 12, align: 'right', format: (v) => {
+                    { key: 'tasks', header: 'Calls', width: 12, align: 'right', format: (v) => {
                             const t = v;
                             if (!t)
                                 return '0/0';
@@ -775,15 +776,14 @@ const healthCommand = {
                 for (const agent of healthAgents) {
                     output.writeln();
                     output.writeln(output.highlight(agent.id));
-                    const uptime = agent.uptime ?? 0;
-                    const latency = agent.latency ?? { avg: 0, p99: 0 };
-                    const tasks = agent.tasks ?? { completed: 0, failed: 0, queued: 0 };
-                    const errors = agent.errors ?? { count: 0 };
+                    const latency = agent.latency;
+                    const tasks = agent.tasks;
+                    const errors = agent.errors;
                     output.printList([
-                        `Uptime: ${(uptime / 1000 / 60).toFixed(1)} min`,
-                        `Latency: avg ${(latency.avg ?? 0).toFixed(1)}ms, p99 ${(latency.p99 ?? 0).toFixed(1)}ms`,
-                        `Tasks: ${tasks.completed ?? 0} completed, ${tasks.failed ?? 0} failed, ${tasks.queued ?? 0} queued`,
-                        `Errors: ${errors.count ?? 0}${errors.lastError ? ` (${errors.lastError})` : ''}`
+                        `Registry age: ${typeof agent.registryAgeMs === 'number' ? `${(agent.registryAgeMs / 1000 / 60).toFixed(1)} min` : 'n/a'}`,
+                        `Latency: p50 ${typeof latency?.p50 === 'number' ? `${latency.p50.toFixed(1)}ms` : 'n/a'}, p95 ${typeof latency?.p95 === 'number' ? `${latency.p95.toFixed(1)}ms` : 'n/a'}`,
+                        `Observed provider calls (last 20): ${tasks?.completed ?? 0} API-success, ${tasks?.failed ?? 0} error`,
+                        `Errors: ${errors?.count ?? 0}${errors?.lastError ? ` (${errors.lastError})` : ''}`
                     ]);
                 }
             }