@phnx-labs/agents-cli 1.22.26 → 1.22.28

package/dist/lib/models.d.ts

@@ -43,7 +43,7 @@ export interface ModelCatalog {
     aliases: Record<string, string>;
 }
 /** How the model catalog source was obtained. */
-export type ModelSourceKind = 'bundle' | 'binary' | 'js' | 'cli';
+export type ModelSourceKind = 'bundle' | 'binary' | 'cli';
 /** Describes the location and extraction strategy for a model catalog source. */
 export interface ModelSource {
     path: string;
@@ -69,13 +69,49 @@ export declare function locateModelSource(agent: AgentId, version: string): Mode
  *   - constants: {OPUS_ID:"...",OPUS_NAME:"...",SONNET_ID:"...",...}
  */
 /**
- * Drop a bare `claude-<family>-<major>` (e.g. `claude-opus-4`) when a more specific
- * sibling (`claude-opus-4-8`) is present. The bare form is only ever an internal
- * `.includes("claude-opus-4")` prefix-check string in the binary, not a submittable
- * id (issue #1892); a bare id with no sibling (e.g. `claude-sonnet-5`) is a real
- * current model and is kept.
+ * Drop a catalog id that is a proper dash-boundary prefix of a more-specific
+ * sibling also present in the list (e.g. `claude-opus-4` when `claude-opus-4-8`
+ * is present, or `claude-opus-4-1` when `claude-opus-4-1-20250805` is present).
+ *
+ * Two sources produce these prefix forms in the native binary:
+ *  - standalone `.includes("claude-opus-4")` prefix-check strings (#1892)
+ *  - per-cloud metadata field values such as `foundry:"claude-opus-4-1"` next
+ *    to a real firstParty id `claude-opus-4-1-20250805` (#2233)
+ *
+ * A genuine bare current id with no longer sibling (e.g. `claude-sonnet-5`) is
+ * kept. The dash boundary (`startsWith(id + '-')`) avoids collapsing
+ * `claude-opus-4-1` into `claude-opus-4-10`.
  */
 export declare function dropBareLegacyIds(ids: string[]): string[];
+/**
+ * Scan raw binary/bundle text for canonical Claude model ids, then drop bare
+ * legacy / cloud-metadata prefixes (#1892, #2233). Two independent guards keep
+ * non-model strings out of the catalog:
+ *
+ *  - **Word-boundary anchors on the id regex.** The id must not be glued to a
+ *    surrounding identifier character, and must not be the truncated prefix of a
+ *    longer *version* token. `(?<![A-Za-z0-9_])` rejects a glued prefix;
+ *    `(?![A-Za-z0-9])` rejects a glued alnum suffix; `(?!\.\d)` rejects a
+ *    dotted-version continuation — so the bare-major prefix of the binary's own
+ *    "Typo in model ID" troubleshooting string `claude-sonnet-4.6` is not
+ *    scraped as `claude-sonnet-4`, while a real id followed by an unrelated `.`
+ *    suffix (`claude-fable-5.md`) still matches. Dash-separated segments only:
+ *    the dotted form never appears in a genuine id.
+ *
+ *    The id body is captured inside a lookahead (`(?=(...))\1`) so the greedy
+ *    `-\d+` run matches **atomically**: without it, a suffix-glued token like
+ *    `claude-opus-4-1x` would fail the trailing anchor on the full match, then
+ *    backtrack a segment and re-emit the bare `claude-opus-4` — the exact 404-able
+ *    id this scan exists to suppress (two packed strings can end up glued with no
+ *    separator in the extracted binary text). The atomic match fails outright
+ *    instead of degrading to the bare form.
+ *  - **`dropBareLegacyIds`.** A fully delimited string the anchors cannot tell
+ *    apart from a real id — whether a bare major (`.includes("claude-opus-4")`)
+ *    or a bare-minor per-cloud field value (`foundry:"claude-opus-4-1"`) — is
+ *    dropped when a more-specific sibling is also present; a genuinely bare
+ *    current id with no sibling (`claude-sonnet-5`) is kept.
+ */
+export declare function scanClaudeCatalogIds(text: string): string[];
 /**
  * Parse `grok models` stdout into a catalog. Exported for unit tests.
  *

package/dist/lib/models.js

@@ -112,51 +112,8 @@ export function locateModelSource(agent, version) {
         }
         return null;
     }
-    if (agent === 'gemini') {
-        // <=0.41 shipped a clean ES module at @google/gemini-cli-core/dist/src/config/models.js.
-        // 0.42+ inlines the same constants into a minified chunk under @google/gemini-cli/bundle/.
-        const modelsJs = path.join(versionDir, 'node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'config', 'models.js');
-        if (fs.existsSync(modelsJs))
-            return { path: modelsJs, kind: 'js' };
-        const bundleDir = path.join(versionDir, 'node_modules', '@google', 'gemini-cli', 'bundle');
-        if (fs.existsSync(bundleDir)) {
-            try {
-                const entries = fs.readdirSync(bundleDir);
-                // The model constants live in a single chunk; pick the first .js file
-                // whose contents contain VALID_GEMINI_MODELS. Skip subdirectories.
-                for (const name of entries) {
-                    if (!name.endsWith('.js'))
-                        continue;
-                    const full = path.join(bundleDir, name);
-                    let stat;
-                    try {
-                        stat = fs.statSync(full);
-                    }
-                    catch {
-                        continue;
-                    }
-                    if (!stat.isFile())
-                        continue;
-                    // Most chunks just re-export the constants; only the defining chunk
-                    // actually has `var VALID_GEMINI_MODELS = ... new Set(`. Match that
-                    // shape so we pick the chunk that the extractor can parse.
-                    let body;
-                    try {
-                        body = fs.readFileSync(full, 'utf-8');
-                    }
-                    catch {
-                        continue;
-                    }
-                    if (/var\s+VALID_GEMINI_MODELS\s*=[^\n]*new\s+Set/.test(body) &&
-                        /var\s+DEFAULT_GEMINI_MODEL\s*=/.test(body)) {
-                        return { path: full, kind: 'js' };
-                    }
-                }
-            }
-            catch { /* unreadable bundle dir */ }
-        }
-        return null;
-    }
+    // gemini is hard-deprecated (no launch path left to validate a model
+    // against), so its bundle is deliberately not parsed for a catalog here.
     if (agent === 'opencode') {
         // The `opencode` shim under node_modules/.bin dispatches to a platform-
         // specific native binary. We don't parse the 100MB binary; we let the CLI
@@ -333,17 +290,60 @@ function extractStrings(filePath, minLen = 6) {
  *   - constants: {OPUS_ID:"...",OPUS_NAME:"...",SONNET_ID:"...",...}
  */
 /**
- * Drop a bare `claude-<family>-<major>` (e.g. `claude-opus-4`) when a more specific
- * sibling (`claude-opus-4-8`) is present. The bare form is only ever an internal
- * `.includes("claude-opus-4")` prefix-check string in the binary, not a submittable
- * id (issue #1892); a bare id with no sibling (e.g. `claude-sonnet-5`) is a real
- * current model and is kept.
+ * Drop a catalog id that is a proper dash-boundary prefix of a more-specific
+ * sibling also present in the list (e.g. `claude-opus-4` when `claude-opus-4-8`
+ * is present, or `claude-opus-4-1` when `claude-opus-4-1-20250805` is present).
+ *
+ * Two sources produce these prefix forms in the native binary:
+ *  - standalone `.includes("claude-opus-4")` prefix-check strings (#1892)
+ *  - per-cloud metadata field values such as `foundry:"claude-opus-4-1"` next
+ *    to a real firstParty id `claude-opus-4-1-20250805` (#2233)
+ *
+ * A genuine bare current id with no longer sibling (e.g. `claude-sonnet-5`) is
+ * kept. The dash boundary (`startsWith(id + '-')`) avoids collapsing
+ * `claude-opus-4-1` into `claude-opus-4-10`.
  */
 export function dropBareLegacyIds(ids) {
-    return ids.filter((id) => {
-        const bareMajor = /^claude-[a-z]+-\d+$/.test(id);
-        return !(bareMajor && ids.some((o) => o !== id && o.startsWith(`${id}-`)));
-    });
+    return ids.filter((id) => !ids.some((other) => other !== id && other.startsWith(`${id}-`)));
+}
+/**
+ * Scan raw binary/bundle text for canonical Claude model ids, then drop bare
+ * legacy / cloud-metadata prefixes (#1892, #2233). Two independent guards keep
+ * non-model strings out of the catalog:
+ *
+ *  - **Word-boundary anchors on the id regex.** The id must not be glued to a
+ *    surrounding identifier character, and must not be the truncated prefix of a
+ *    longer *version* token. `(?<![A-Za-z0-9_])` rejects a glued prefix;
+ *    `(?![A-Za-z0-9])` rejects a glued alnum suffix; `(?!\.\d)` rejects a
+ *    dotted-version continuation — so the bare-major prefix of the binary's own
+ *    "Typo in model ID" troubleshooting string `claude-sonnet-4.6` is not
+ *    scraped as `claude-sonnet-4`, while a real id followed by an unrelated `.`
+ *    suffix (`claude-fable-5.md`) still matches. Dash-separated segments only:
+ *    the dotted form never appears in a genuine id.
+ *
+ *    The id body is captured inside a lookahead (`(?=(...))\1`) so the greedy
+ *    `-\d+` run matches **atomically**: without it, a suffix-glued token like
+ *    `claude-opus-4-1x` would fail the trailing anchor on the full match, then
+ *    backtrack a segment and re-emit the bare `claude-opus-4` — the exact 404-able
+ *    id this scan exists to suppress (two packed strings can end up glued with no
+ *    separator in the extracted binary text). The atomic match fails outright
+ *    instead of degrading to the bare form.
+ *  - **`dropBareLegacyIds`.** A fully delimited string the anchors cannot tell
+ *    apart from a real id — whether a bare major (`.includes("claude-opus-4")`)
+ *    or a bare-minor per-cloud field value (`foundry:"claude-opus-4-1"`) — is
+ *    dropped when a more-specific sibling is also present; a genuinely bare
+ *    current id with no sibling (`claude-sonnet-5`) is kept.
+ */
+export function scanClaudeCatalogIds(text) {
+    const idRe = /(?<![A-Za-z0-9_])(?=(claude-(?:opus|sonnet|haiku|fable|mythos)-\d+(?:-\d+)*(?:-(?:fast|v\d+))?))\1(?![A-Za-z0-9])(?!\.\d)/g;
+    const scanned = new Set();
+    let sm;
+    while ((sm = idRe.exec(text)) !== null) {
+        scanned.add(sm[0]);
+        if (sm.index === idRe.lastIndex)
+            idRe.lastIndex++;
+    }
+    return dropBareLegacyIds([...scanned]);
 }
 function extractClaudeCatalog(text) {
     const aliases = {};
@@ -406,16 +406,7 @@ function extractClaudeCatalog(text) {
     // catalog while a newer one still gets a real catalog (incl. fable/mythos and
     // the opus-5/sonnet-5 line) rather than an empty or single-model one.
     if (models.length < 2) {
-        const scanned = new Set();
-        // Dash-separated segments only. Real ids are `claude-sonnet-4-6`; the dotted
-        // form `claude-sonnet-4.6` appears only inside the binary's own "Typo in
-        // model ID" troubleshooting text, so a `.`-permitting pattern would scrape a
-        // non-model string as if it were real.
-        const idRe = /claude-(?:opus|sonnet|haiku|fable|mythos)-\d+(?:-\d+)*(?:-(?:fast|v\d+))?/g;
-        let sm;
-        while ((sm = idRe.exec(text)) !== null)
-            scanned.add(sm[0]);
-        const filtered = dropBareLegacyIds([...scanned]);
+        const filtered = scanClaudeCatalogIds(text);
         if (filtered.length >= 2)
             models = build(filtered);
     }
@@ -460,85 +451,6 @@ function extractCodexCatalog(text) {
     }
     return { models, aliases: {} };
 }
-/**
- * Extract Gemini's model catalog from `@google/gemini-cli-core/.../config/models.js`.
- *
- * The module exports a set of named constants (e.g. `DEFAULT_GEMINI_MODEL`,
- * `PREVIEW_GEMINI_FLASH_MODEL`) plus a `VALID_GEMINI_MODELS` Set and a handful
- * of `GEMINI_MODEL_ALIAS_*` strings. We parse it with regex (a JS-module import
- * would pollute the runtime and ES-module interop is awkward from a CJS build).
- */
-function extractGeminiCatalog(text) {
-    // Old (<=0.41) layout used `export const FOO = 'bar';` in models.js.
-    // New (0.42+) bundle inlines the same constants as `var FOO = "bar";`.
-    const constRe = /(?:export\s+const|var)\s+([A-Z0-9_]+)\s*=\s*['"]([^'"]+)['"]/g;
-    const constants = new Map();
-    let m;
-    while ((m = constRe.exec(text)) !== null) {
-        constants.set(m[1], m[2]);
-    }
-    // The set of ids the CLI accepts as "valid model names". Names (not values)
-    // are listed inside `new Set([...])`, so we expand them via the constants map.
-    const validIds = new Set();
-    const setBlock = text.match(/VALID_GEMINI_MODELS\s*=\s*(?:\/\*[^*]*\*\/\s*)?new\s+Set\(\[([\s\S]*?)\]\)/);
-    if (setBlock) {
-        const nameRe = /([A-Z0-9_]+)/g;
-        let nm;
-        while ((nm = nameRe.exec(setBlock[1])) !== null) {
-            const id = constants.get(nm[1]);
-            if (id)
-                validIds.add(id);
-        }
-    }
-    // Fall back to any gemini-shaped id we saw in the constants map -- useful
-    // when the Set shape changes across gemini versions.
-    if (validIds.size === 0) {
-        for (const [name, value] of constants) {
-            if (/^(DEFAULT_|PREVIEW_)/.test(name) && /^gemini-/.test(value)) {
-                validIds.add(value);
-            }
-        }
-    }
-    // Aliases are exported as `GEMINI_MODEL_ALIAS_FLASH = 'flash'` etc. The alias
-    // is the *value*; the target model is resolved at runtime by `resolveModel()`.
-    // We replicate that logic here so callers get a concrete id per alias.
-    const defaultId = constants.get('DEFAULT_GEMINI_MODEL');
-    const previewPro = constants.get('PREVIEW_GEMINI_MODEL');
-    const previewFlash = constants.get('PREVIEW_GEMINI_FLASH_MODEL');
-    const flashLite = constants.get('DEFAULT_GEMINI_FLASH_LITE_MODEL');
-    const aliases = {};
-    if (previewPro) {
-        aliases.auto = previewPro;
-        aliases.pro = previewPro;
-    }
-    if (previewFlash)
-        aliases.flash = previewFlash;
-    if (flashLite)
-        aliases['flash-lite'] = flashLite;
-    const aliasReverse = {};
-    for (const [alias, id] of Object.entries(aliases)) {
-        (aliasReverse[id] ||= []).push(alias);
-    }
-    const defaults = new Set();
-    if (defaultId)
-        defaults.add(defaultId);
-    if (previewPro)
-        defaults.add(previewPro); // auto/pro alias resolves here
-    const displayNameFor = (id) => {
-        // Gemini has a `getDisplayString` for some aliases but the canonical id
-        // is human-readable enough ("gemini-3-pro-preview") -- no separate map.
-        return undefined;
-    };
-    const models = Array.from(validIds)
-        .sort()
-        .map((id) => ({
-        id,
-        displayName: displayNameFor(id),
-        alias: aliasReverse[id]?.[0],
-        isDefault: defaults.has(id),
-    }));
-    return { models, aliases };
-}
 /**
  * Extract OpenCode's catalog by invoking `opencode models --verbose`. The
  * output is a sequence of `<provider>/<id>\n{json}` blocks -- we parse every
@@ -1042,16 +954,6 @@ export function getModelCatalog(agent, version) {
                 : agent === 'codex' ? extractCodexCatalog(text)
                     : { models: [], aliases: {} });
     }
-    else if (src.kind === 'js') {
-        try {
-            const text = fs.readFileSync(src.path, 'utf-8');
-            if (agent === 'gemini')
-                ({ models, aliases } = extractGeminiCatalog(text));
-        }
-        catch {
-            /* unreadable */
-        }
-    }
     else if (src.kind === 'cli') {
         if (agent === 'opencode')
             ({ models, aliases } = extractOpenCodeCatalog(src.path));

package/dist/lib/perf/db.js

@@ -244,7 +244,7 @@ export function aggregateSamples(opts = {}) {
         const key = `${r.kind}\0${r.label}`;
         let b = map.get(key);
         if (!b) {
-            b = { kind: r.kind, label: r.label, durations: [], hits: 0, stale: 0, misses: 0, errors: 0, timeouts: 0 };
+            b = { kind: r.kind, label: r.label, durations: [], hits: 0, stale: 0, misses: 0, errors: 0, blocks: 0, timeouts: 0 };
             map.set(key, b);
         }
         b.durations.push(Number(r.duration_ms));
@@ -254,10 +254,19 @@ export function aggregateSamples(opts = {}) {
             b.stale++;
         else if (r.cache === 'miss' || r.cache === 'none')
             b.misses++;
+        // Exit classes (Claude/Codex PreToolUse convention):
+        //   0 → allowed
+        //   2 → intentional deny/block (not a crash)
+        //   1 / other nonzero → real error
+        // Timeouts are recorded via status, not exit_code, so they don't double-count.
         if (r.status === 'timeout')
             b.timeouts++;
-        else if (typeof r.exit_code === 'number' && r.exit_code !== 0)
-            b.errors++;
+        else if (typeof r.exit_code === 'number') {
+            if (r.exit_code === 2)
+                b.blocks++;
+            else if (r.exit_code !== 0)
+                b.errors++;
+        }
     }
     const out = [];
     for (const b of map.values()) {
@@ -286,6 +295,10 @@ export function aggregateSamples(opts = {}) {
             row.errorCount = b.errors;
             row.errorRate = Math.round((b.errors / n) * 1000) / 1000;
         }
+        if (b.blocks > 0) {
+            row.blockCount = b.blocks;
+            row.blockRate = Math.round((b.blocks / n) * 1000) / 1000;
+        }
         if (b.timeouts > 0)
             row.timeoutRate = Math.round((b.timeouts / n) * 1000) / 1000;
         if (opts.project)

package/dist/lib/perf/types.d.ts

@@ -35,8 +35,19 @@ export interface PerfAggregateRow {
     cacheStalePct?: number;
     cacheMissPct?: number;
     errorCount?: number;
-    /** Fraction (0-1) of samples with a nonzero exit code. */
+    /**
+     * Fraction (0-1) of samples with a real crash exit (exit 1 / other nonzero
+     * except the intentional PreToolUse deny code 2). Exit 2 is blockRate.
+     */
     errorRate?: number;
+    /**
+     * Count of intentional deny/block exits (Claude/Codex PreToolUse exit 2).
+     * Not an error — deny-by-design guards (ask-user-question-guard, git-guard,
+     * plan-html-reminder) exit 2 when they block.
+     */
+    blockCount?: number;
+    /** Fraction (0-1) of samples with exit code 2 (intentional deny/block). */
+    blockRate?: number;
     /** Fraction (0-1) of samples with status:'timeout'. */
     timeoutRate?: number;
     /** Project key (see project-key.ts) the row is scoped to — set only when

package/dist/lib/pricing/cost.d.ts

@@ -14,6 +14,15 @@ export interface TokenUsage {
  * convention for models that don't publish a separate cache price).
  */
 export declare function costOfUsage(u: TokenUsage): number;
+/**
+ * USD cost of one usage record priced as if caching were OFF: cache-read and
+ * cache-write tokens are billed at the model's full INPUT rate rather than their
+ * discounted cache rates. This is the "what would this have cost with no prompt
+ * caching?" scenario that `agents output --pricing no-cache` models. Output and
+ * uncached input are unchanged — only the cache tokens are repriced. Returns 0
+ * for a missing/unpriced model, exactly like {@link costOfUsage}.
+ */
+export declare function costOfUsageNoCache(u: TokenUsage): number;
 /** Sum the USD cost of every usage record in a session. */
 export declare function costOfSession(usages: TokenUsage[]): number;
 /**

package/dist/lib/pricing/cost.js

@@ -31,6 +31,30 @@ export function costOfUsage(u) {
         cacheRead * cacheReadRate +
         cacheWrite * cacheWriteRate);
 }
+/**
+ * USD cost of one usage record priced as if caching were OFF: cache-read and
+ * cache-write tokens are billed at the model's full INPUT rate rather than their
+ * discounted cache rates. This is the "what would this have cost with no prompt
+ * caching?" scenario that `agents output --pricing no-cache` models. Output and
+ * uncached input are unchanged — only the cache tokens are repriced. Returns 0
+ * for a missing/unpriced model, exactly like {@link costOfUsage}.
+ */
+export function costOfUsageNoCache(u) {
+    if (!u.model)
+        return 0;
+    const pricing = getModelPricing(u.model);
+    if (!pricing)
+        return 0;
+    const input = u.inputTokens ?? 0;
+    const output = u.outputTokens ?? 0;
+    const cacheRead = u.cacheReadTokens ?? 0;
+    const cacheWrite = u.cacheCreationTokens ?? 0;
+    // Cache tokens repriced at the input rate — no caching discount applied.
+    return (input * pricing.inputPerToken +
+        output * pricing.outputPerToken +
+        cacheRead * pricing.inputPerToken +
+        cacheWrite * pricing.inputPerToken);
+}
 /** Sum the USD cost of every usage record in a session. */
 export function costOfSession(usages) {
     let total = 0;

package/dist/lib/pricing/index.d.ts

@@ -5,4 +5,4 @@
  * enforcement) imports against — keep it stable.
  */
 export { type ModelPricing, PRICING_VERSION, getModelPricing, listPricedModels, } from './table.js';
-export { type TokenUsage, costOfUsage, costOfSession, formatUsd, estimateCost, actualCost, isModelPriced, } from './cost.js';
+export { type TokenUsage, costOfUsage, costOfUsageNoCache, costOfSession, formatUsd, estimateCost, actualCost, isModelPriced, } from './cost.js';

package/dist/lib/pricing/index.js

@@ -5,4 +5,4 @@
  * enforcement) imports against — keep it stable.
  */
 export { PRICING_VERSION, getModelPricing, listPricedModels, } from './table.js';
-export { costOfUsage, costOfSession, formatUsd, estimateCost, actualCost, isModelPriced, } from './cost.js';
+export { costOfUsage, costOfUsageNoCache, costOfSession, formatUsd, estimateCost, actualCost, isModelPriced, } from './cost.js';

package/dist/lib/project-probe.d.ts

@@ -73,6 +73,16 @@ export declare function formatWorkspaceLine(s: RepoWorkspaceStatus): string;
  * `fleet` row label.
  */
 export declare function formatFleetWorkspaces(statuses: HostWorkspaceStatus[]): string[];
+/**
+ * One-line fleet health summary — `6/13 clean · 4 behind · 4 dirty · 1 missing`.
+ * Sits ABOVE the per-host {@link formatFleetWorkspaces} table so the card is
+ * scannable without reading every host cell; the table keeps the per-host branch
+ * and drift detail. Zero buckets are omitted. `behind` colours red when any host
+ * is ≥10 behind (matching the footer's critical threshold), else yellow; a host
+ * that is both behind and dirty counts in both. Each host×path row is one unit,
+ * the same unit the table renders. Pure — chalk styling only.
+ */
+export declare function formatFleetSummary(statuses: HostWorkspaceStatus[]): string;
 /** Severity for a workspace/repo warning on the project card. */
 export type WorkspaceWarningSeverity = 'critical' | 'continue';
 export interface WorkspaceWarning {
@@ -81,13 +91,22 @@ export interface WorkspaceWarning {
     remediation?: string;
 }
 /**
- * Turn probed workspace rows into card-footer warnings.
+ * Turn probed workspace rows into card-footer warnings, GROUPED by root cause so
+ * a fleet where eight hosts drift is a few lines, not sixteen (each with its own
+ * repeated remediation).
  *
  * - missing / unreadable git → critical (agents there cannot share a tree)
- * - behind upstream → critical when ≥10 commits, continue otherwise
+ * - behind upstream → critical when ANY host is ≥10 commits behind, else continue
  * - dirty tree → continue (local work is fine; just note it)
  * - ahead-only is not a warning (that is progress waiting to push)
  *
- * Pure. Caller decides whether the rows came from `--fleet` or a local probe.
+ * Within one probed path, all behind hosts collapse to one warning listing each
+ * host with its count (`4 hosts behind origin/main — mac-mini ↓172, …`) plus one
+ * shared remediation; a lone host keeps its full sentence. Missing and dirty
+ * collapse the same way. `error` stays per-host (each message is distinct).
+ * Grouping is per path so two different repos never merge into one count. Unlike
+ * doctor's `emitGroup`, the list names EVERY host, not the first two — each
+ * host's drift count differs and is individually actionable. Pure — chalk only.
+ * Caller decides whether the rows came from `--fleet` or a local probe.
  */
 export declare function workspaceWarnings(statuses: HostWorkspaceStatus[]): WorkspaceWarning[];

package/dist/lib/project-probe.js

@@ -159,46 +159,134 @@ export function formatFleetWorkspaces(statuses) {
     });
 }
 /**
- * Turn probed workspace rows into card-footer warnings.
+ * One-line fleet health summary — `6/13 clean · 4 behind · 4 dirty · 1 missing`.
+ * Sits ABOVE the per-host {@link formatFleetWorkspaces} table so the card is
+ * scannable without reading every host cell; the table keeps the per-host branch
+ * and drift detail. Zero buckets are omitted. `behind` colours red when any host
+ * is ≥10 behind (matching the footer's critical threshold), else yellow; a host
+ * that is both behind and dirty counts in both. Each host×path row is one unit,
+ * the same unit the table renders. Pure — chalk styling only.
+ */
+export function formatFleetSummary(statuses) {
+    const total = statuses.length;
+    let clean = 0;
+    let behind = 0;
+    let dirty = 0;
+    let missing = 0;
+    let hardBehind = false;
+    for (const s of statuses) {
+        if (!s.present) {
+            missing++;
+            continue;
+        }
+        if (s.error)
+            continue; // unreadable — neither clean nor a drift bucket (surfaced in the footer)
+        const isBehind = s.behind !== undefined && s.behind > 0;
+        const isDirty = s.dirty !== undefined && s.dirty > 0;
+        if (isBehind) {
+            behind++;
+            if (s.behind >= 10)
+                hardBehind = true;
+        }
+        if (isDirty)
+            dirty++;
+        if (!isBehind && !isDirty)
+            clean++;
+    }
+    const parts = [chalk.green(`${clean}/${total} clean`)];
+    if (behind)
+        parts.push((hardBehind ? chalk.red : chalk.yellow)(`${behind} behind`));
+    if (dirty)
+        parts.push(chalk.yellow(`${dirty} dirty`));
+    if (missing)
+        parts.push(chalk.red(`${missing} missing`));
+    return parts.join(chalk.dim(' · '));
+}
+/**
+ * Turn probed workspace rows into card-footer warnings, GROUPED by root cause so
+ * a fleet where eight hosts drift is a few lines, not sixteen (each with its own
+ * repeated remediation).
  *
  * - missing / unreadable git → critical (agents there cannot share a tree)
- * - behind upstream → critical when ≥10 commits, continue otherwise
+ * - behind upstream → critical when ANY host is ≥10 commits behind, else continue
  * - dirty tree → continue (local work is fine; just note it)
  * - ahead-only is not a warning (that is progress waiting to push)
  *
- * Pure. Caller decides whether the rows came from `--fleet` or a local probe.
+ * Within one probed path, all behind hosts collapse to one warning listing each
+ * host with its count (`4 hosts behind origin/main — mac-mini ↓172, …`) plus one
+ * shared remediation; a lone host keeps its full sentence. Missing and dirty
+ * collapse the same way. `error` stays per-host (each message is distinct).
+ * Grouping is per path so two different repos never merge into one count. Unlike
+ * doctor's `emitGroup`, the list names EVERY host, not the first two — each
+ * host's drift count differs and is individually actionable. Pure — chalk only.
+ * Caller decides whether the rows came from `--fleet` or a local probe.
  */
 export function workspaceWarnings(statuses) {
     const out = [];
-    for (const s of [...statuses].sort((a, b) => a.host.localeCompare(b.host) || a.path.localeCompare(b.path))) {
-        const where = s.host ? `${s.host}` : 'local';
-        const pathBit = s.path ? ` (${s.path})` : '';
-        if (!s.present) {
+    const where = (s) => (s.host ? s.host : 'local');
+    const paths = [...new Set(statuses.map((s) => s.path))].sort((a, b) => a.localeCompare(b));
+    for (const path of paths) {
+        const pathBit = path ? ` (${path})` : '';
+        const rows = statuses.filter((s) => s.path === path);
+        const present = rows.filter((s) => s.present && !s.error);
+        // Missing checkout — grouped critical, a lone host keeps its full sentence.
+        const missing = rows.filter((s) => !s.present).sort((a, b) => where(a).localeCompare(where(b)));
+        if (missing.length === 1) {
             out.push({
                 severity: 'critical',
-                text: `${where}: checkout missing${pathBit}`,
+                text: `${where(missing[0])}: checkout missing${pathBit}`,
                 remediation: 'clone or sync the project root on that host before landing agents there',
             });
-            continue;
         }
-        if (s.error) {
+        else if (missing.length > 1) {
             out.push({
                 severity: 'critical',
-                text: `${where}: ${s.error}${pathBit}`,
+                text: `${missing.length} hosts missing checkout${pathBit} — ${missing.map(where).join(', ')}`,
+                remediation: 'clone or sync the project root on those hosts before landing agents there',
             });
-            continue;
         }
-        if (s.behind !== undefined && s.behind > 0) {
+        // Unreadable git — one per host, since each error message is distinct.
+        for (const s of rows.filter((s) => s.present && s.error).sort((a, b) => where(a).localeCompare(where(b)))) {
+            out.push({ severity: 'critical', text: `${where(s)}: ${s.error}${pathBit}` });
+        }
+        // Behind upstream — grouped, worst count first, one shared remediation.
+        const behind = present
+            .filter((s) => s.behind !== undefined && s.behind > 0)
+            .sort((a, b) => (b.behind ?? 0) - (a.behind ?? 0) || where(a).localeCompare(where(b)));
+        if (behind.length === 1) {
+            const s = behind[0];
             out.push({
-                severity: s.behind >= 10 ? 'critical' : 'continue',
-                text: `${where} is ${s.behind} commit${s.behind === 1 ? '' : 's'} behind ${s.upstream ?? 'upstream'}${pathBit}`,
+                severity: (s.behind ?? 0) >= 10 ? 'critical' : 'continue',
+                text: `${where(s)} is ${s.behind} commit${s.behind === 1 ? '' : 's'} behind ${s.upstream ?? 'upstream'}${pathBit}`,
                 remediation: 'pull (or rebase) before agents on this host open PRs against a stale base',
             });
         }
-        if (s.dirty !== undefined && s.dirty > 0) {
+        else if (behind.length > 1) {
+            const upstreams = new Set(behind.map((s) => s.upstream ?? 'upstream'));
+            const upstream = upstreams.size === 1 ? [...upstreams][0] : 'upstream';
+            const list = behind.map((s) => `${where(s)} ↓${s.behind}`).join(', ');
+            out.push({
+                severity: behind.some((s) => (s.behind ?? 0) >= 10) ? 'critical' : 'continue',
+                text: `${behind.length} hosts behind ${upstream}${pathBit} — ${list}`,
+                remediation: 'pull (or rebase) before agents on these hosts open PRs against a stale base',
+            });
+        }
+        // Dirty tree — grouped, most changes first, no remediation (local work is fine).
+        const dirty = present
+            .filter((s) => s.dirty !== undefined && s.dirty > 0)
+            .sort((a, b) => (b.dirty ?? 0) - (a.dirty ?? 0) || where(a).localeCompare(where(b)));
+        if (dirty.length === 1) {
+            const s = dirty[0];
+            out.push({
+                severity: 'continue',
+                text: `${where(s)} has ${s.dirty} uncommitted change${s.dirty === 1 ? '' : 's'}${pathBit}`,
+            });
+        }
+        else if (dirty.length > 1) {
+            const list = dirty.map((s) => `${where(s)} ${s.dirty}`).join(', ');
             out.push({
                 severity: 'continue',
-                text: `${where} has ${s.dirty} uncommitted change${s.dirty === 1 ? '' : 's'}${pathBit}`,
+                text: `${dirty.length} hosts with uncommitted changes${pathBit} — ${list}`,
             });
         }
     }

package/dist/lib/project-status.d.ts

@@ -87,6 +87,15 @@ export interface LiveDeadSplit {
  * crashed sessions is itself a thing to go fix.
  */
 export declare function liveDeadSplit(byStatus: Partial<Record<ActiveStatus, number>>): LiveDeadSplit;
+/**
+ * The `dead` row body: `41 crashed` when every dead session shares one status,
+ * else `12 finished or lost (8 crashed, 4 closed)`. The generic "finished or
+ * lost" only earns its keep when the statuses actually differ — with a single
+ * status it just hides which one behind a parenthetical that repeats the count.
+ * Pure — chalk styling only; the caller adds the `dead` label. Assumes
+ * `split.dead > 0` (the caller gates on it).
+ */
+export declare function formatDeadSummary(split: LiveDeadSplit): string;
 /** Sort members for the card: running first, then idle, then the rest; agent name asc within a state. */
 export declare function sortProjectMembers(members: ProjectMember[]): ProjectMember[];
 /** Cap for the members line before it collapses to `+N more`. */