@phnx-labs/agents-cli 1.22.6 → 1.22.8

package/dist/lib/profiles.js

@@ -11,6 +11,7 @@ import * as yaml from 'yaml';
 import { getUserAgentsDir } from './state.js';
 import { getKeychainToken, hasKeychainToken, keychainItemName } from './secrets/profiles.js';
 import { getPreset } from './profiles-presets.js';
+import { MODEL_TIERS, isTierToken } from './model-tiers.js';
 const PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-_]{0,48}$/i;
 /** Get the directory where profile YAML files are stored. */
 export function getProfilesDir() {
@@ -198,11 +199,46 @@ export function profileAuthLabel(profile) {
     return provider;
 }
 /**
- * Header label for the harness — the slot `AGENTS[id].name` fills for a native
- * harness, so `agents view` can print custom and native harnesses the same way.
+ * Curated vendor/brand display names, matched case-insensitively per token.
+ * Entries with a space (e.g. 'Moonshot AI') are single-token → multi-word expansions.
+ */
+const VENDOR_TABLE = [
+    ['deepseek', 'DeepSeek'],
+    ['openai', 'OpenAI'],
+    ['anthropic', 'Anthropic'],
+    ['claude', 'Claude'],
+    ['grok', 'Grok'],
+    ['xai', 'xAI'],
+    ['gpt', 'GPT'],
+    ['meta', 'Meta'],
+    ['mistral', 'Mistral'],
+    ['mistralai', 'Mistral'],
+    ['qwen', 'Qwen'],
+    ['gemini', 'Gemini'],
+    ['moonshot', 'Moonshot AI'],
+    ['moonshotai', 'Moonshot AI'],
+    ['kimi', 'Kimi'],
+    ['cohere', 'Cohere'],
+    ['perplexity', 'Perplexity'],
+];
+function tokenToDisplayName(token) {
+    const lower = token.toLowerCase();
+    for (const [key, display] of VENDOR_TABLE) {
+        if (lower === key)
+            return display;
+    }
+    return token.charAt(0).toUpperCase() + token.slice(1);
+}
+/**
+ * Header label for the harness — derived from `profile.name` by splitting on
+ * `[-_]` and mapping each token through the vendor/brand table. Never reads
+ * the stored `label` field; old YAML files with a `label:` key are unaffected.
+ *
+ * Examples: `deepseek-flash` → `'DeepSeek Flash'`, `spark` → `'Spark'`,
+ * `deepseek_chat_v3` → `'DeepSeek Chat V3'`.
  */
 export function profileLabel(profile) {
-    return profile.label || profile.name;
+    return profile.name.split(/[-_]/).map(tokenToDisplayName).join(' ');
 }
 /** Build a stable, machine-readable summary for list and view surfaces. */
 export function profileSummary(profile) {
@@ -299,8 +335,6 @@ export function profileFromHostModel(name, host, model, opts = {}) {
         provider: opts.provider ?? host,
         forkedFrom: host,
     };
-    if (opts.label)
-        profile.label = opts.label;
     if (opts.provider && opts.authEnvVar) {
         profile.auth = { envVar: opts.authEnvVar, keychainItem: keychainItemName(opts.provider) };
         profile.authOptional = false;
@@ -336,14 +370,6 @@ export function forkProfile(source, name, opts = {}) {
         description: opts.description ?? (opts.model ? `Forked from ${source.name}: ${opts.model}` : source.description),
         forkedFrom: source.name,
     };
-    // `label` is the header `agents view` prints, so an inherited one would make
-    // the fork and its source visually identical — the ambiguity a per-harness
-    // block exists to remove. A fork carries a label only when it is given one;
-    // otherwise `profileLabel` falls back to the fork's own name.
-    if (opts.label)
-        forked.label = opts.label;
-    else
-        delete forked.label;
     // A fork that repoints the model or endpoint is no longer that preset — keep
     // the preset link only while the fork still matches what the preset defines.
     if (opts.model || opts.baseUrl)
@@ -359,6 +385,51 @@ export function forkProfile(source, name, opts = {}) {
     }
     return forked;
 }
+/**
+ * Edit an existing profile in-place, applying overrides without changing its
+ * name or lineage. Reuses {@link forkProfile}'s validation and override logic
+ * (model swap, base-URL validation, auth repoint), then restores the original
+ * `forkedFrom` so an edit never self-references the profile.
+ *
+ * Note: this returns the updated `Profile` object but does NOT write it to
+ * disk — callers should follow up with `writeProfile(result)` if persistence
+ * is needed.
+ */
+export function editProfile(source, opts = {}) {
+    const edited = forkProfile(source, source.name, opts);
+    // forkProfile sets forkedFrom = source.name; for an in-place edit that would
+    // be a self-reference. Restore the original lineage instead.
+    edited.forkedFrom = source.forkedFrom;
+    return edited;
+}
+/**
+ * Rename a profile on disk, then rewrite `forkedFrom` in every other profile
+ * that pointed at the old name so lineage display never goes stale.
+ *
+ * Throws if `oldName` does not exist or `newName` already exists. There is no
+ * `--force` / overwrite path — a collision is a hard error directing the user
+ * to remove the target first.
+ */
+export function renameProfile(oldName, newName) {
+    validateProfileName(newName);
+    if (!profileExists(oldName)) {
+        throw new Error(`Profile '${oldName}' not found.`);
+    }
+    if (profileExists(newName)) {
+        throw new Error(`Profile '${newName}' already exists; remove it first.`);
+    }
+    const profile = readProfile(oldName);
+    profile.name = newName;
+    writeProfile(profile);
+    deleteProfile(oldName);
+    // Rewrite forkedFrom in every other profile that referenced the old name.
+    for (const other of listProfiles()) {
+        if (other.name !== newName && other.forkedFrom === oldName) {
+            other.forkedFrom = newName;
+            writeProfile(other);
+        }
+    }
+}
 /**
  * Resolve a profile into the env block that should be injected into the
  * spawned agent process. Reads the token from keychain at exec time so the
@@ -378,17 +449,45 @@ export function resolveProfileEnv(profile) {
     }
     return env;
 }
+/**
+ * Resolve a requested cost tier against a profile's `models:` map. An unset
+ * tier clamps to the next CHEAPER tier that IS set (ultra -> best -> default
+ * -> cheap), mirroring the clamp semantics of `bucketRungs` in
+ * model-tiers.ts. Returns null when the profile declares no `models:` at all,
+ * or none of the tiers at-or-below the request are set.
+ */
+function resolveProfileTierModel(profile, tier) {
+    if (!profile.models)
+        return null;
+    const idx = MODEL_TIERS.indexOf(tier);
+    for (let i = idx; i >= 0; i--) {
+        const rung = MODEL_TIERS[i];
+        const model = profile.models[rung];
+        if (model)
+            return { model, clampedFrom: rung === tier ? undefined : rung };
+    }
+    return null;
+}
 /**
  * Resolve a name into (agent, version, env). Throws if the name is not a
  * profile. Callers are expected to try agent-id resolution first and fall
  * back to this when that fails, so we don't need a "isProfile" probe.
+ *
+ * `requestedModel` is the caller's raw `--model` value. When it is a cost-tier
+ * token (`cheap`/`default`/`best`/`ultra`), it is resolved against the
+ * profile's OWN `models:` map (see `resolveProfileTierModel`) and substituted
+ * into `env` as a concrete model id BEFORE returning — so exec.ts's native
+ * tier-resolution block (which indexes the HOST agent's catalog, e.g. Claude's
+ * own models) never sees a tier token for a profile-based run, and can't
+ * collide the profile's harness identity with its host's catalog.
  */
-export function resolveProfileForRun(name) {
+export function resolveProfileForRun(name, requestedModel) {
     const profile = readProfile(name);
+    const env = resolveProfileEnv(profile);
     const resolved = {
         agent: profile.host.agent,
         version: profile.host.version,
-        env: resolveProfileEnv(profile),
+        env,
         profileName: profile.name,
     };
     if (profile.fallback_model) {
@@ -397,6 +496,25 @@ export function resolveProfileForRun(name) {
             resolved.fallbackModel = { envKey, model: profile.fallback_model };
         }
     }
+    if (isTierToken(requestedModel)) {
+        const tierPick = resolveProfileTierModel(profile, requestedModel);
+        if (tierPick) {
+            const envKey = profileModelEnvKey(profile) ?? modelEnvKeyForHost(profile.host.agent);
+            env[envKey] = tierPick.model;
+            resolved.resolvedModel = tierPick.model;
+            // Mirror the native-harness tier block (lib/exec.ts's resolveTier callers):
+            // a clamp is always announced, never silent, so a user asking for "ultra"
+            // on a harness that only configures "best" knows what it actually got.
+            if (tierPick.clampedFrom) {
+                resolved.tierNote = `no "${requestedModel}" model configured on profile '${profile.name}'; using its "${tierPick.clampedFrom}" tier (${tierPick.model})`;
+            }
+        }
+        // No `models:` opt-in at all, or no rung to clamp to: leave `env` and
+        // `requestedModel` untouched. `agents commands/exec.ts`'s own profile-tier
+        // guard (the "cost tiers don't apply to profile ..." discard) still sees
+        // the raw tier token downstream and handles the message -- this function
+        // doesn't compete with that canonical fallback for the no-opt-in case.
+    }
     return resolved;
 }
 /**

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

@@ -40,3 +40,12 @@ export declare function rankFocusAreas(files: string[], limit?: number): FocusAr
  * the user's last fetch, which is the correct trade for a read-only card.
  */
 export declare function readFocusAreas(root: string, windowDays: number): Promise<FocusArea[]>;
+/** Compact count: 2329 → "2.3k", under 1000 stays exact. */
+export declare function formatFocusCount(n: number): string;
+/**
+ * One scannable focus line: path + count, with a single unit trailer so the
+ * bare integer is never mistaken for commits or minutes.
+ *
+ *   apps/cli/src 2.3k  ·  apps/cli/docs 302  ·  apps/factory/src 245  file-touches (7d)
+ */
+export declare function formatFocusAreas(areas: FocusArea[], windowDays: number): string;

package/dist/lib/project-focus.js

@@ -78,3 +78,26 @@ export async function readFocusAreas(root, windowDays) {
         return [];
     }
 }
+/** Compact count: 2329 → "2.3k", under 1000 stays exact. */
+export function formatFocusCount(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return '0';
+    if (n < 1000)
+        return String(Math.round(n));
+    const k = n / 1000;
+    const s = k >= 10 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, '');
+    return `${s}k`;
+}
+/**
+ * One scannable focus line: path + count, with a single unit trailer so the
+ * bare integer is never mistaken for commits or minutes.
+ *
+ *   apps/cli/src 2.3k  ·  apps/cli/docs 302  ·  apps/factory/src 245  file-touches (7d)
+ */
+export function formatFocusAreas(areas, windowDays) {
+    if (areas.length === 0)
+        return '';
+    const body = areas.map((a) => `${a.path} ${formatFocusCount(a.touches)}`).join('  ·  ');
+    const unit = `file-touches (${windowDays}d)`;
+    return `${body}  ${unit}`;
+}

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

@@ -2,7 +2,7 @@
  * The one worktree-aware cwd -> project fold.
  *
  * Several surfaces bucket work "by project": the `agents sessions` overview,
- * the `agents activity` timeline, and anything else that has a cwd and needs a
+ * the `agents feed` timeline, and anything else that has a cwd and needs a
  * stable repo-level key. They must agree, or the same session shows up under
  * `agents-cli` in one view and `my-branch-slug` in another — so the rule lives
  * here and every caller delegates.

package/dist/lib/project-key.js

@@ -2,7 +2,7 @@
  * The one worktree-aware cwd -> project fold.
  *
  * Several surfaces bucket work "by project": the `agents sessions` overview,
- * the `agents activity` timeline, and anything else that has a cwd and needs a
+ * the `agents feed` timeline, and anything else that has a cwd and needs a
  * stable repo-level key. They must agree, or the same session shows up under
  * `agents-cli` in one view and `my-branch-slug` in another — so the rule lives
  * here and every caller delegates.

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

@@ -73,3 +73,21 @@ export declare function formatWorkspaceLine(s: RepoWorkspaceStatus): string;
  * `fleet` row label.
  */
 export declare function formatFleetWorkspaces(statuses: HostWorkspaceStatus[]): string[];
+/** Severity for a workspace/repo warning on the project card. */
+export type WorkspaceWarningSeverity = 'critical' | 'continue';
+export interface WorkspaceWarning {
+    severity: WorkspaceWarningSeverity;
+    text: string;
+    remediation?: string;
+}
+/**
+ * Turn probed workspace rows into card-footer warnings.
+ *
+ * - missing / unreadable git → critical (agents there cannot share a tree)
+ * - behind upstream → critical when ≥10 commits, continue otherwise
+ * - 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.
+ */
+export declare function workspaceWarnings(statuses: HostWorkspaceStatus[]): WorkspaceWarning[];

package/dist/lib/project-probe.js

@@ -158,3 +158,49 @@ export function formatFleetWorkspaces(statuses) {
         return multi ? `${chalk.dim(`${p} · `)}${body}` : body;
     });
 }
+/**
+ * Turn probed workspace rows into card-footer warnings.
+ *
+ * - missing / unreadable git → critical (agents there cannot share a tree)
+ * - behind upstream → critical when ≥10 commits, continue otherwise
+ * - 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.
+ */
+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) {
+            out.push({
+                severity: 'critical',
+                text: `${where}: checkout missing${pathBit}`,
+                remediation: 'clone or sync the project root on that host before landing agents there',
+            });
+            continue;
+        }
+        if (s.error) {
+            out.push({
+                severity: 'critical',
+                text: `${where}: ${s.error}${pathBit}`,
+            });
+            continue;
+        }
+        if (s.behind !== undefined && 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}`,
+                remediation: 'pull (or rebase) before agents on this host open PRs against a stale base',
+            });
+        }
+        if (s.dirty !== undefined && s.dirty > 0) {
+            out.push({
+                severity: 'continue',
+                text: `${where} has ${s.dirty} uncommitted change${s.dirty === 1 ? '' : 's'}${pathBit}`,
+            });
+        }
+    }
+    return out;
+}

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

@@ -53,6 +53,13 @@ export interface ProjectSessionRollup {
  * containing only projects with at least one matched session — callers merge
  * with the full definition list to show zero-agent projects.
  */
+/**
+ * Ensure every session carries a host for the card roster. Local
+ * `getActiveSessions()` omits `machine`; remotes already set it. Pure.
+ */
+export declare function withDefaultMachine<T extends {
+    machine?: string;
+}>(sessions: T[], defaultHost: string): T[];
 export declare function rollupSessionsByProject(defs: ProjectDef[], sessions: ActiveSession[]): Map<string, ProjectSessionRollup>;
 /**
  * True when a session's status means it is over. Exported so the card can keep
@@ -84,6 +91,19 @@ export declare function liveDeadSplit(byStatus: Partial<Record<ActiveStatus, num
 export declare function sortProjectMembers(members: ProjectMember[]): ProjectMember[];
 /** Cap for the members line before it collapses to `+N more`. */
 export declare const MEMBERS_LINE_LIMIT = 6;
+/** Cap for host groups on the multi-line agents roster. */
+export declare const MEMBERS_HOST_LIMIT = 8;
+/**
+ * Collapse members into distinct state cells (`agent · status · ticket[@host]`),
+ * counting duplicates as `×N`. Pure.
+ */
+export declare function collapseMemberCells(members: ProjectMember[], opts?: {
+    includeHostOnCell?: boolean;
+}): Array<{
+    cell: string;
+    n: number;
+    members: number;
+}>;
 /**
  * The `agents` line under `live`: one cell per DISTINCT member state —
  * `claude · running · RUSH-2107 @zion` — with identical cells collapsed to a
@@ -91,8 +111,44 @@ export declare const MEMBERS_LINE_LIMIT = 6;
  * truncated duplicates), capped at {@link MEMBERS_LINE_LIMIT} cells with a
  * `+N more` tail counting members, not cells. Pure (chalk styling only); the
  * caller adds the label.
+ *
+ * Prefer {@link formatProjectMembersByHost} on the card: a flat line hides which
+ * machine is running the work when the same harness×status spans hosts.
  */
 export declare function formatProjectMembers(members: ProjectMember[], limit?: number): string;
+/**
+ * Host-grouped agents roster. One content line per host:
+ * `@zion  claude · running ×9  ·  claude · idle ×4`
+ *
+ * When no member carries a host (local-only rollup with no machine stamp), falls
+ * back to a single flat line via {@link formatProjectMembers}. Pure.
+ */
+export declare function formatProjectMembersByHost(members: ProjectMember[], opts?: {
+    cellLimit?: number;
+    hostLimit?: number;
+}): string[];
+/** A card-level warning collected for the footer. */
+export type ProjectWarningSeverity = 'critical' | 'continue';
+export interface ProjectWarning {
+    severity: ProjectWarningSeverity;
+    /** One human line. */
+    text: string;
+    /** Optional fix or next step. */
+    remediation?: string;
+}
+/**
+ * Severity markers for the warnings footer. User-facing by design: critical
+ * stops you (wrong repo, missing checkout, large drift); continue is a soft
+ * nudge (dirty tree, schedule not measurable).
+ */
+export declare function warningEmoji(severity: ProjectWarningSeverity): string;
+/** Stable sort: critical first, then continue; stable within a tier. */
+export declare function sortProjectWarnings(warnings: ProjectWarning[]): ProjectWarning[];
+/**
+ * Format one or more warning lines for the card footer. Pure (chalk only).
+ * Returns empty when there is nothing to say.
+ */
+export declare function formatProjectWarnings(warnings: ProjectWarning[]): string[];
 /** Harvested signals not on the session list: repo-global merged PRs + releases, local artifacts, in a time window. */
 export interface ProjectRemoteSignals {
     windowDays: number;

package/dist/lib/project-status.js

@@ -41,6 +41,13 @@ function blank(name) {
  * containing only projects with at least one matched session — callers merge
  * with the full definition list to show zero-agent projects.
  */
+/**
+ * Ensure every session carries a host for the card roster. Local
+ * `getActiveSessions()` omits `machine`; remotes already set it. Pure.
+ */
+export function withDefaultMachine(sessions, defaultHost) {
+    return sessions.map((s) => (s.machine ? s : { ...s, machine: defaultHost }));
+}
 export function rollupSessionsByProject(defs, sessions) {
     const map = new Map();
     const prSeen = new Map();
@@ -148,25 +155,20 @@ export function sortProjectMembers(members) {
 }
 /** Cap for the members line before it collapses to `+N more`. */
 export const MEMBERS_LINE_LIMIT = 6;
+/** Cap for host groups on the multi-line agents roster. */
+export const MEMBERS_HOST_LIMIT = 8;
 /**
- * The `agents` line under `live`: one cell per DISTINCT member state —
- * `claude · running · RUSH-2107 @zion` — with identical cells collapsed to a
- * `×N` count (35 same-harness sessions in one state are one fact, not six
- * truncated duplicates), capped at {@link MEMBERS_LINE_LIMIT} cells with a
- * `+N more` tail counting members, not cells. Pure (chalk styling only); the
- * caller adds the label.
+ * Collapse members into distinct state cells (`agent · status · ticket[@host]`),
+ * counting duplicates as `×N`. Pure.
  */
-export function formatProjectMembers(members, limit = MEMBERS_LINE_LIMIT) {
-    if (members.length === 0)
-        return '';
-    // Collapse identical cells — 35 same-harness sessions in the same state are
-    // one fact (`claude · running ×16`), not six truncated duplicates.
+export function collapseMemberCells(members, opts = {}) {
+    const includeHost = opts.includeHostOnCell !== false;
     const counts = new Map();
     for (const m of sortProjectMembers(members)) {
         const parts = [m.agent, m.status];
         if (m.ticket)
             parts.push(m.ticket);
-        const cell = parts.join(' · ') + (m.host ? ` @${m.host}` : '');
+        const cell = parts.join(' · ') + (includeHost && m.host ? ` @${m.host}` : '');
         const key = cell.toLowerCase();
         const entry = counts.get(key);
         if (entry)
@@ -174,12 +176,117 @@ export function formatProjectMembers(members, limit = MEMBERS_LINE_LIMIT) {
         else
             counts.set(key, { cell, n: 1 });
     }
-    const entries = [...counts.values()];
-    const shown = entries.slice(0, Math.max(1, limit));
-    const shownMembers = shown.reduce((acc, e) => acc + e.n, 0);
-    const more = members.length - shownMembers;
-    const cells = shown.map(({ cell, n }) => (n > 1 ? `${cell} ×${n}` : cell));
-    return cells.join(chalk.dim('  ·  ')) + (more > 0 ? chalk.dim(`  ·  +${more} more`) : '');
+    return [...counts.values()].map(({ cell, n }) => ({ cell, n, members: n }));
+}
+function formatCollapsedCells(cells, memberTotal, limit) {
+    if (cells.length === 0)
+        return '';
+    const shown = cells.slice(0, Math.max(1, limit));
+    const shownMembers = shown.reduce((acc, e) => acc + e.members, 0);
+    const more = memberTotal - shownMembers;
+    const parts = shown.map(({ cell, n }) => (n > 1 ? `${cell} ×${n}` : cell));
+    return parts.join(chalk.dim('  ·  ')) + (more > 0 ? chalk.dim(`  ·  +${more} more`) : '');
+}
+/**
+ * The `agents` line under `live`: one cell per DISTINCT member state —
+ * `claude · running · RUSH-2107 @zion` — with identical cells collapsed to a
+ * `×N` count (35 same-harness sessions in one state are one fact, not six
+ * truncated duplicates), capped at {@link MEMBERS_LINE_LIMIT} cells with a
+ * `+N more` tail counting members, not cells. Pure (chalk styling only); the
+ * caller adds the label.
+ *
+ * Prefer {@link formatProjectMembersByHost} on the card: a flat line hides which
+ * machine is running the work when the same harness×status spans hosts.
+ */
+export function formatProjectMembers(members, limit = MEMBERS_LINE_LIMIT) {
+    if (members.length === 0)
+        return '';
+    return formatCollapsedCells(collapseMemberCells(members, { includeHostOnCell: true }), members.length, limit);
+}
+/**
+ * Host-grouped agents roster. One content line per host:
+ * `@zion  claude · running ×9  ·  claude · idle ×4`
+ *
+ * When no member carries a host (local-only rollup with no machine stamp), falls
+ * back to a single flat line via {@link formatProjectMembers}. Pure.
+ */
+export function formatProjectMembersByHost(members, opts = {}) {
+    if (members.length === 0)
+        return [];
+    const cellLimit = opts.cellLimit ?? MEMBERS_LINE_LIMIT;
+    const hostLimit = opts.hostLimit ?? MEMBERS_HOST_LIMIT;
+    const byHost = new Map();
+    let anyHost = false;
+    for (const m of members) {
+        if (m.host)
+            anyHost = true;
+        const key = m.host ?? '';
+        const list = byHost.get(key);
+        if (list)
+            list.push(m);
+        else
+            byHost.set(key, [m]);
+    }
+    // Local-only (no host stamps at all) — keep the compact one-liner.
+    if (!anyHost) {
+        const line = formatProjectMembers(members, cellLimit);
+        return line ? [line] : [];
+    }
+    // Hosts with the most members first, then name; unstamped ("") last.
+    const hosts = [...byHost.entries()].sort((a, b) => {
+        if (a[0] === '' && b[0] !== '')
+            return 1;
+        if (b[0] === '' && a[0] !== '')
+            return -1;
+        if (b[1].length !== a[1].length)
+            return b[1].length - a[1].length;
+        return a[0].localeCompare(b[0]);
+    });
+    const shownHosts = hosts.slice(0, Math.max(1, hostLimit));
+    const hiddenMembers = hosts.slice(hostLimit).reduce((acc, [, ms]) => acc + ms.length, 0);
+    const hostWidth = Math.max(...shownHosts.map(([h]) => (h ? `@${h}` : '@local').length), 1);
+    const lines = shownHosts.map(([host, ms]) => {
+        const label = (host ? `@${host}` : '@local').padEnd(hostWidth);
+        // Host is the row key — do not repeat @host on every cell.
+        const cells = collapseMemberCells(ms, { includeHostOnCell: false });
+        const body = formatCollapsedCells(cells, ms.length, cellLimit);
+        return `${chalk.cyan(label)}  ${body}`;
+    });
+    if (hiddenMembers > 0) {
+        const restHosts = hosts.length - shownHosts.length;
+        lines.push(chalk.dim(`+${hiddenMembers} more on ${restHosts} host${restHosts === 1 ? '' : 's'}`));
+    }
+    return lines;
+}
+/**
+ * Severity markers for the warnings footer. User-facing by design: critical
+ * stops you (wrong repo, missing checkout, large drift); continue is a soft
+ * nudge (dirty tree, schedule not measurable).
+ */
+export function warningEmoji(severity) {
+    return severity === 'critical' ? '🔴' : '⚠️';
+}
+/** Stable sort: critical first, then continue; stable within a tier. */
+export function sortProjectWarnings(warnings) {
+    const rank = { critical: 0, continue: 1 };
+    return [...warnings].sort((a, b) => rank[a.severity] - rank[b.severity] || a.text.localeCompare(b.text));
+}
+/**
+ * Format one or more warning lines for the card footer. Pure (chalk only).
+ * Returns empty when there is nothing to say.
+ */
+export function formatProjectWarnings(warnings) {
+    if (warnings.length === 0)
+        return [];
+    const lines = [];
+    for (const w of sortProjectWarnings(warnings)) {
+        const mark = warningEmoji(w.severity);
+        const color = w.severity === 'critical' ? chalk.red : chalk.yellow;
+        lines.push(`  ${mark}  ${color(w.text)}`);
+        if (w.remediation)
+            lines.push(`      ${chalk.dim(w.remediation)}`);
+    }
+    return lines;
 }
 /**
  * Harvest the signals that don't live on the active-session list: recently

package/dist/lib/resources/mcp.js

@@ -124,6 +124,9 @@ export function getMcpConfigPath(agent, versionHome) {
             return path.join(versionHome, '.grok', 'mcp.json');
         case 'hermes':
             return path.join(versionHome, '.hermes', 'config.yaml');
+        case 'pi':
+            // omp reads user-scope MCP from ~/.omp/agent/.mcp.json (Claude schema).
+            return path.join(versionHome, '.omp', 'agent', '.mcp.json');
         default:
             return null;
     }

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

@@ -5,7 +5,7 @@
  * - Union: All resources from all layers are combined
  * - Override on name conflict: Higher layer wins (project > user > system)
  */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi';
 export type Layer = 'system' | 'user' | 'project';
 export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow' | 'memory';
 /** A resolved resource with its origin layer. */

package/dist/lib/rotate.d.ts

@@ -8,6 +8,7 @@ import type { AgentId, RunStrategy } from './types.js';
 import type { FallbackEntry } from './exec.js';
 import { type AccountInfo, type CredentialPresence } from './agents.js';
 import { type UsageSnapshot } from './usage.js';
+import { type AuthVerdict } from './auth-health.js';
 export interface RotateCandidate {
     agent: AgentId;
     version: string;
@@ -35,6 +36,18 @@ export interface RotateCandidate {
     usageMinutesToLimit: number | null;
     plan: string | null;
     signedIn: boolean;
+    /**
+     * Live auth-health verdict for this (agent, version) from the daemon's probe
+     * cache (`auth-health.ts`), or null when no probe row exists (cold cache, or a
+     * harness with no live-probe endpoint). `signedIn` only means "a credential
+     * file is present and its email decodes" — it cannot tell a good token from a
+     * revoked-but-unexpired one, so a server-rejected account reads
+     * `signedIn: true` but `authVerdict: 'revoked'`. Eligibility excludes a
+     * revoked account so rotation never launches into a doomed auth (see
+     * {@link readinessFromCandidate}). Fail-open: any non-revoked or null verdict
+     * does not gate — a stale/absent probe never blocks a launch.
+     */
+    authVerdict: AuthVerdict | null;
     lastActive: Date | null;
 }
 export interface RotateResult {
@@ -108,15 +121,17 @@ export declare const USAGE_DECISION_MAX_AGE_MS: number;
 export declare function isUsageVerified(candidate: RotateCandidate, nowMs?: number): boolean;
 /**
  * Whether a specific account can serve a run right now, and — when it can't —
- * why. `signed_out` covers a missing usable credential; `rate_limited` and
- * `out_of_credits` name the throttle. Used to pre-warn on a version-pinned
- * teammate whose account rotation won't route around (a pin IS the target).
+ * why. `signed_out` covers a missing usable credential; `revoked` is a token the
+ * server has actually rejected (401/403, from the live auth-health probe);
+ * `rate_limited` and `out_of_credits` name the throttle. Used to pre-warn on a
+ * version-pinned teammate whose account rotation won't route around (a pin IS
+ * the target).
  */
 export type AccountReadiness = {
     ready: true;
 } | {
     ready: false;
-    reason: 'rate_limited' | 'out_of_credits' | 'signed_out';
+    reason: 'rate_limited' | 'out_of_credits' | 'signed_out' | 'revoked';
     email: string | null;
 };
 /**