@phnx-labs/agents-cli 1.20.12 → 1.20.14

package/dist/commands/inspect.js

@@ -23,7 +23,10 @@ import { readMeta, getUserAgentsDir, getSystemAgentsDir, getProjectAgentsDir, ge
 import { getVersionHomePath } from '../lib/versions.js';
 import { getShimsDir, getVersionedAliasPath } from '../lib/shims.js';
 import { getAgentResources, listResources, } from '../lib/resources.js';
-import { discoverPlugins, discoverPluginsInDir } from '../lib/plugins.js';
+import { listHookEntriesFromDir } from '../lib/hooks.js';
+import { listMcpServerConfigs, discoverMcpConfigsFromRepo } from '../lib/mcp.js';
+import { discoverPlugins, discoverPluginsInDir, pluginResourceGroups } from '../lib/plugins.js';
+import { PLUGIN_GROUP_COLORS } from './plugins.js';
 import { countSessionsInScope } from '../lib/session/discover.js';
 import { damerauLevenshtein } from '../lib/fuzzy.js';
 /** Resource kinds the inspect command can drill into. */
@@ -37,6 +40,29 @@ const DRILLABLE_KINDS = [
     'workflows',
     'subagents',
 ];
+/**
+ * Summary-view partition. SIMPLE kinds render as a one-line count + name preview;
+ * RICH kinds (hooks/plugins/mcp) get their own expanded section showing each
+ * item's key detail (events/predicates, bundle contents, transport/url). Together
+ * they cover every DrillableKind.
+ */
+const SIMPLE_KINDS = ['commands', 'skills', 'rules', 'subagents', 'workflows'];
+const RICH_KINDS = ['hooks', 'plugins', 'mcp'];
+/**
+ * Singular aliases for the plural drill-down flags. `--plugin code` reads as
+ * "show the one plugin named code" — a required-value flag that always lands in
+ * detail mode, the natural counterpart to `--plugins` (list). `mcp` has no
+ * distinct singular, so it is intentionally absent.
+ */
+const SINGULAR_DRILL_ALIASES = {
+    command: 'commands',
+    skill: 'skills',
+    hook: 'hooks',
+    rule: 'rules',
+    plugin: 'plugins',
+    workflow: 'workflows',
+    subagent: 'subagents',
+};
 const CAPABILITY_NAMES = [
     'hooks', 'mcp', 'skills', 'commands', 'subagents', 'plugins', 'workflows', 'rules', 'allowlist',
 ];
@@ -50,6 +76,9 @@ export function registerInspectCommand(program) {
     for (const kind of DRILLABLE_KINDS) {
         cmd.option(`--${kind} [query]`, `list ${kind}; pass a name (fuzzy) to show detail`);
     }
+    for (const singular of Object.keys(SINGULAR_DRILL_ALIASES)) {
+        cmd.option(`--${singular} <query>`, `show detail for one ${singular} by name (fuzzy)`);
+    }
     cmd.action(async (target, options) => {
         await inspectAction(target, options);
     });
@@ -121,15 +150,21 @@ function pickDrillKind(options) {
     for (const kind of DRILLABLE_KINDS) {
         const value = options[kind];
         if (value !== undefined)
-            active.push({ kind, query: value });
+            active.push({ flag: `--${kind}`, kind, query: value });
+    }
+    // Singular aliases (`--plugin code`) always carry a name → detail mode.
+    for (const [singular, plural] of Object.entries(SINGULAR_DRILL_ALIASES)) {
+        const value = options[singular];
+        if (typeof value === 'string')
+            active.push({ flag: `--${singular}`, kind: plural, query: value });
     }
     if (active.length === 0)
         return null;
     if (active.length > 1) {
-        console.error(chalk.red(`Pick at most one drill-down flag. Got: ${active.map(a => '--' + a.kind).join(', ')}`));
+        console.error(chalk.red(`Pick at most one drill-down flag. Got: ${active.map(a => a.flag).join(', ')}`));
         process.exit(1);
     }
-    return active[0];
+    return { kind: active[0].kind, query: active[0].query };
 }
 /** Files at a DotAgents root that mark it as one, beyond the per-kind dirs. */
 const REPO_MARKER_FILES = ['agents.yaml', 'hooks.yaml'];
@@ -330,6 +365,9 @@ function renderRepoSummary(repo, options) {
     const manifest = repoManifestSummary(repo.root);
     const kindData = {};
     let totalBytes = 0, totalFiles = 0;
+    let repoHookByScript = new Map();
+    let repoHookItemList = [];
+    let repoMcpConfigs = new Map();
     if (!options.brief) {
         for (const kind of DRILLABLE_KINDS) {
             const items = collectRepoKind(repo, kind);
@@ -338,6 +376,9 @@ function renderRepoSummary(repo, options) {
             totalBytes += size.bytes;
             totalFiles += size.files;
         }
+        repoHookByScript = hookManifestByScript(hookManifestFromFile(path.join(repo.root, 'agents.yaml')));
+        repoHookItemList = repoHookItems(repo);
+        repoMcpConfigs = new Map(discoverMcpConfigsFromRepo(repo.root).map(s => [s.name, s.config]));
     }
     if (options.json) {
         console.log(JSON.stringify({
@@ -347,12 +388,34 @@ function renderRepoSummary(repo, options) {
             manifests,
             manifest,
             size: options.brief ? null : { bytes: totalBytes, files: totalFiles },
-            resources: options.brief ? null : Object.fromEntries(DRILLABLE_KINDS.map(kind => [kind, {
-                    count: kindData[kind].items.length,
-                    bytes: kindData[kind].size.bytes,
-                    files: kindData[kind].size.files,
-                    names: kindData[kind].items.map(i => i.name),
-                }])),
+            resources: options.brief ? null : Object.fromEntries(DRILLABLE_KINDS.map(kind => {
+                const size = kindData[kind].size;
+                // Hooks use the grouped reader (clean names) instead of the raw readdir.
+                const items = kind === 'hooks' ? repoHookItemList : kindData[kind].items;
+                const base = {
+                    count: items.length,
+                    bytes: size.bytes,
+                    files: size.files,
+                    names: items.map(i => i.name),
+                };
+                if (kind === 'hooks')
+                    return [kind, { ...base, items: items.map(i => {
+                                const h = repoHookByScript.get(i.name);
+                                return { name: i.name, events: h?.events ?? [], matcher: h?.matcher, matches: h?.matches, cache: h?.cache };
+                            }) }];
+                if (kind === 'mcp')
+                    return [kind, { ...base, items: items.map(i => {
+                                const c = repoMcpConfigs.get(i.name);
+                                return { name: i.name, transport: c?.transport, url: c?.url, command: c?.command, args: c?.args };
+                            }) }];
+                if (kind === 'plugins')
+                    return [kind, { ...base, items: items.map(i => ({
+                                name: i.name,
+                                version: i.extra?.find(([k]) => k === 'version')?.[1],
+                                groups: Object.fromEntries((i.groups ?? []).map(g => [g.label, g.items.length])),
+                            })) }];
+                return [kind, base];
+            })),
         }, null, 2));
         return;
     }
@@ -391,13 +454,16 @@ function renderRepoSummary(repo, options) {
     if (!options.brief) {
         console.log(`  ${'size'.padEnd(10)} ${formatBytes(totalBytes)} ${chalk.gray('·')} ${totalFiles} files`);
         console.log('\n' + chalk.bold('Resources'));
-        for (const kind of DRILLABLE_KINDS) {
+        for (const kind of SIMPLE_KINDS) {
             const { items, size } = kindData[kind];
             const count = String(items.length).padStart(4);
             const sz = items.length > 0 ? formatBytes(size.bytes).padStart(8) : ''.padEnd(8);
             const preview = items.length > 0 ? chalk.gray(truncate(previewNames(items, 4), 60)) : '';
             console.log(`  ${kind.padEnd(10)} ${count}  ${sz}  ${preview}`.trimEnd());
         }
+        printExpandedSection('Hooks', hookRows(repoHookItemList, repoHookByScript));
+        printExpandedSection('Plugins', pluginRows(kindData.plugins.items));
+        printExpandedSection('MCP', mcpRows(kindData.mcp.items, repoMcpConfigs));
     }
     console.log('');
     console.log(chalk.gray(`Drill in:   agents inspect ${repo.label} --skills <query>`));
@@ -455,7 +521,9 @@ async function renderSummary(agent, version, versionHome, options) {
     const shimPath = path.join(getShimsDir(), AGENTS[agent].cliCommand);
     const aliasPath = getVersionedAliasPath(agent, version);
     const capabilities = collectCapabilities(agent, version);
-    const counts = options.brief ? null : collectCounts(agent, versionHome);
+    const itemsByKind = options.brief ? null : collectItemsByKind(agent, versionHome);
+    const hookByScript = options.brief ? null : hookManifestByScript(loadCentralHookManifest());
+    const mcpConfigs = options.brief ? null : new Map(listMcpServerConfigs().map(s => [s.name, s.config]));
     const sessions = options.brief ? null : {
         total: safeCountSessions(agent),
     };
@@ -471,7 +539,7 @@ async function renderSummary(agent, version, versionHome, options) {
             strategy,
             installedShim: cliState?.installed === true ? cliState.path : null,
             capabilities,
-            resources: counts,
+            resources: itemsByKind ? summaryResourcesJson(itemsByKind, hookByScript, mcpConfigs) : null,
             sessions,
         };
         console.log(JSON.stringify(json, null, 2));
@@ -496,15 +564,14 @@ async function renderSummary(agent, version, versionHome, options) {
         const reason = res.ok ? '' : chalk.gray(`(${res.reason}${res.need ? ' ' + res.need : ''})`);
         console.log(`  ${cap.padEnd(10)} ${mark} ${reason}`);
     }
-    if (counts) {
+    if (itemsByKind) {
         console.log('\n' + chalk.bold('Resources'));
-        for (const kind of DRILLABLE_KINDS) {
-            const c = counts[kind];
-            if (!c)
-                continue;
-            const breakdown = formatScopeBreakdown(c.bySource);
-            console.log(`  ${kind.padEnd(10)} ${String(c.total).padStart(4)}   ${chalk.gray(breakdown)}`);
+        for (const kind of SIMPLE_KINDS) {
+            printSimpleResourceRow(kind, itemsByKind[kind]);
         }
+        printExpandedSection('Hooks', hookRows(itemsByKind.hooks, hookByScript));
+        printExpandedSection('Plugins', pluginRows(itemsByKind.plugins));
+        printExpandedSection('MCP', mcpRows(itemsByKind.mcp, mcpConfigs));
     }
     if (sessions) {
         console.log('\n' + chalk.bold('Sessions'));
@@ -526,7 +593,7 @@ function renderItemList(header, jsonHead, kind, items, options) {
             ...jsonHead,
             kind,
             count: items.length,
-            items: items.map(i => ({ name: i.name, source: i.source, path: i.path, description: i.description })),
+            items: items.map(i => ({ name: i.name, source: i.source, path: i.path, description: i.description, ...(i.groups ? { groups: i.groups } : {}) })),
         }, null, 2));
         return;
     }
@@ -542,9 +609,23 @@ function renderItemList(header, jsonHead, kind, items, options) {
         if (item.description) {
             console.log(`             ${chalk.gray(truncate(item.description, 90))}`);
         }
+        if (item.groups)
+            printGroupRows(item.groups);
     }
     console.log('');
 }
+/** Print a plugin's resource breakdown as aligned `label  items` rows under a list entry. */
+function printGroupRows(groups) {
+    if (groups.length === 0)
+        return;
+    const width = Math.max(...groups.map(g => g.label.length));
+    for (const g of groups) {
+        const colorFn = PLUGIN_GROUP_COLORS[g.label] ?? chalk.white;
+        const label = chalk.gray(g.label.padEnd(width));
+        const value = g.items.map((s) => colorFn(s)).join(chalk.gray(', '));
+        console.log(`             ${label}  ${value}`);
+    }
+}
 // ─── Detail mode (fuzzy) ─────────────────────────────────────────────────────
 async function renderDetail(agent, version, versionHome, kind, query, options) {
     const items = collectKind(agent, versionHome, kind);
@@ -610,14 +691,52 @@ function collectCapabilities(agent, version) {
     }
     return out;
 }
-function collectCounts(agent, versionHome) {
+function collectItemsByKind(agent, versionHome) {
+    const out = {};
+    for (const kind of DRILLABLE_KINDS)
+        out[kind] = collectKind(agent, versionHome, kind);
+    return out;
+}
+/** A simple-kind count row: `kind  N   user:30 system:12   name, name …(+K)`. */
+function printSimpleResourceRow(kind, items) {
+    const count = String(items.length).padStart(4);
+    const breakdown = chalk.gray(scopeBreakdownPlain(countBySource(items.map(i => i.source))).padEnd(18));
+    const preview = items.length > 0 ? chalk.gray(truncate(previewNames(items, 3), 48)) : '';
+    console.log(`  ${kind.padEnd(10)} ${count}   ${breakdown}  ${preview}`.trimEnd());
+}
+/**
+ * Build the `resources` JSON: every kind keeps `total` + `bySource` (back-compat),
+ * simple kinds add `names`, and the rich kinds add structured `items` (hook
+ * events/predicates, mcp transport/url/command, plugin version + group counts).
+ */
+function summaryResourcesJson(itemsByKind, hookByScript, mcpConfigs) {
     const out = {};
     for (const kind of DRILLABLE_KINDS) {
-        const items = collectKind(agent, versionHome, kind);
-        const bySource = {};
-        for (const item of items)
-            bySource[item.source] = (bySource[item.source] || 0) + 1;
-        out[kind] = { total: items.length, bySource };
+        const items = itemsByKind[kind];
+        const base = { total: items.length, bySource: countBySource(items.map(i => i.source)) };
+        if (kind === 'hooks') {
+            out[kind] = { ...base, items: items.map(i => {
+                    const h = hookByScript.get(i.name);
+                    return { name: i.name, source: i.source, events: h?.events ?? [], matcher: h?.matcher, matches: h?.matches, cache: h?.cache };
+                }) };
+        }
+        else if (kind === 'mcp') {
+            out[kind] = { ...base, items: items.map(i => {
+                    const c = mcpConfigs.get(i.name);
+                    return { name: i.name, source: i.source, transport: c?.transport, url: c?.url, command: c?.command, args: c?.args };
+                }) };
+        }
+        else if (kind === 'plugins') {
+            out[kind] = { ...base, items: items.map(i => ({
+                    name: i.name,
+                    source: i.source,
+                    version: i.extra?.find(([k]) => k === 'version')?.[1],
+                    groups: Object.fromEntries((i.groups ?? []).map(g => [g.label, g.items.length])),
+                })) };
+        }
+        else {
+            out[kind] = { ...base, names: items.map(i => i.name) };
+        }
     }
     return out;
 }
@@ -653,17 +772,6 @@ function pluginItems() {
  */
 function pluginToItem(plugin, source) {
     const extra = [];
-    const list = (names) => names.length <= 8 ? names.join(', ') : `${names.slice(0, 8).join(', ')}, +${names.length - 8} more`;
-    if (plugin.skills.length)
-        extra.push(['skills', `${plugin.skills.length}  (${list(plugin.skills)})`]);
-    if (plugin.commands.length)
-        extra.push(['commands', `${plugin.commands.length}  (${list(plugin.commands)})`]);
-    if (plugin.agentDefs.length)
-        extra.push(['subagents', `${plugin.agentDefs.length}  (${list(plugin.agentDefs)})`]);
-    if (plugin.hooks.length)
-        extra.push(['hooks', String(plugin.hooks.length)]);
-    if (plugin.mcpServers.length)
-        extra.push(['mcp', list(plugin.mcpServers)]);
     if (plugin.manifest.version)
         extra.push(['version', plugin.manifest.version]);
     return {
@@ -673,6 +781,7 @@ function pluginToItem(plugin, source) {
         linkTarget: linkTarget(plugin.root),
         description: plugin.manifest.description ?? '',
         extra,
+        groups: pluginResourceGroups(plugin),
     };
 }
 function entriesFromAgentResources(agent, versionHome, kind) {
@@ -742,12 +851,192 @@ function buildDetailRows(item, kind) {
                 rows.push(['tools', fm.tools.join(', ')]);
         }
     }
-    // Plugin bundles carry their nested resources as pre-built rows.
-    if (kind === 'plugins' && item.extra) {
-        rows.push(...item.extra);
+    // Plugin bundles surface their nested resources (skills, commands, …) plus
+    // scalar rows (version).
+    if (kind === 'plugins') {
+        if (item.groups)
+            for (const g of item.groups)
+                rows.push([g.label, g.items.join(', ')]);
+        if (item.extra)
+            rows.push(...item.extra);
     }
     return rows;
 }
+/** `system` → `sys`; everything else unchanged. Keeps the tag column narrow. */
+function abbrevSource(s) {
+    return s === 'system' ? 'sys' : s;
+}
+/**
+ * Compact one-liner for a hook from its manifest entry: the firing events (with
+ * the matcher/tool-name in parens), then a `·`-separated predicate summary, then
+ * an optional cache tail. Plain text — the caller applies color.
+ */
+export function summarizeHook(hook) {
+    const events = (hook.events ?? []).join('/') || '(no event)';
+    let matcher = hook.matcher;
+    if (!matcher && hook.matches?.tool_name) {
+        const tn = hook.matches.tool_name;
+        matcher = Array.isArray(tn) ? tn.join('|') : tn;
+    }
+    const head = matcher ? `${events}(${matcher})` : events;
+    const parts = [head];
+    const preds = summarizeMatches(hook.matches);
+    if (preds)
+        parts.push(preds);
+    let line = parts.join(' · ');
+    const ttl = hookCacheTtl(hook.cache);
+    if (ttl)
+        line += ` (${ttl} cache)`;
+    return line;
+}
+/** `·`-separated predicate summary from a hook's `matches:` block (tool_name omitted — shown in the matcher parens). */
+function summarizeMatches(m) {
+    if (!m)
+        return '';
+    const bits = [];
+    if (m.git_dirty)
+        bits.push('git_dirty');
+    if (m.prompt_contains)
+        bits.push(`prompt~"${truncate(m.prompt_contains, 24)}"`);
+    if (m.prompt_matches)
+        bits.push(`prompt=/${truncate(m.prompt_matches, 24)}/`);
+    if (m.tool_args_match)
+        bits.push(`args=/${truncate(m.tool_args_match, 20)}/`);
+    if (m.cwd_includes) {
+        const c = Array.isArray(m.cwd_includes) ? m.cwd_includes.join('|') : m.cwd_includes;
+        bits.push(`cwd~${truncate(c, 24)}`);
+    }
+    if (m.project_has)
+        bits.push(`has ${m.project_has}`);
+    return bits.join(' · ');
+}
+/** Normalize a hook cache shorthand/object to a display ttl ("5m", "1h"); null when uncached. */
+function hookCacheTtl(cache) {
+    if (cache === undefined || cache === null)
+        return null;
+    if (typeof cache === 'string')
+        return cache.replace(/-bg$/, '');
+    return String(cache.ttl);
+}
+/** Compact one-liner for an MCP server: padded transport + the url (http) or command line (stdio). */
+export function summarizeMcp(cfg) {
+    const target = cfg.transport === 'http'
+        ? (cfg.url ?? '')
+        : [cfg.command, ...(cfg.args ?? [])].filter(Boolean).join(' ');
+    return `${cfg.transport.padEnd(5)}  ${truncate(target, 60)}`.trimEnd();
+}
+/** Print `Title (N)` then up to `max` aligned `[source] name  detail` rows with a `…(+K)` tail. */
+function printExpandedSection(title, rows, max = 6) {
+    console.log('\n' + chalk.bold(title) + chalk.gray(` (${rows.length})`));
+    if (rows.length === 0) {
+        console.log(chalk.gray('  (none)'));
+        return;
+    }
+    const shown = rows.slice(0, max);
+    const nameW = Math.max(...shown.map(r => r.name.length));
+    for (const r of shown) {
+        const tag = chalk.gray(`[${abbrevSource(r.source)}]`.padEnd(8));
+        const padded = r.name.padEnd(nameW);
+        const name = r.linkTarget ? termLink(chalk.cyan(padded), r.linkTarget) : chalk.cyan(padded);
+        const detail = r.detail ? '  ' + chalk.gray(r.detail) : '';
+        console.log(`  ${tag} ${name}${detail}`);
+    }
+    if (rows.length > max)
+        console.log(chalk.gray(`  …(+${rows.length - max})`));
+}
+/** Tally a source list into `{user: n, system: m}`. */
+function countBySource(sources) {
+    const out = {};
+    for (const s of sources)
+        out[s] = (out[s] || 0) + 1;
+    return out;
+}
+/** Unbracketed scope breakdown for the simple count rows: `user:30 system:12`. */
+function scopeBreakdownPlain(bySource) {
+    return Object.entries(bySource).map(([k, v]) => `${k}:${v}`).join(' ');
+}
+/**
+ * Index a hook manifest by script basename (no extension). Installed hooks are
+ * named after their script file (`04-capture-…`), while the manifest is keyed by
+ * logical name (`capture-…`) with the filename in `script:` — so we join on the
+ * script basename, not the manifest key.
+ */
+export function hookManifestByScript(manifest) {
+    const out = new Map();
+    for (const hook of Object.values(manifest)) {
+        if (hook && typeof hook.script === 'string') {
+            out.set(path.basename(hook.script).replace(/\.[^.]+$/, ''), hook);
+        }
+    }
+    return out;
+}
+/** Build hook rows by enriching the installed hook items with manifest events/predicates. */
+function hookRows(items, byScript) {
+    return items.map(item => {
+        const hook = byScript.get(item.name);
+        return {
+            source: item.source,
+            name: item.name,
+            linkTarget: item.linkTarget,
+            // Hooks are shell scripts with no human description — show events/predicates
+            // from the manifest, or nothing rather than a meaningless shebang line.
+            detail: hook ? summarizeHook(hook) : '',
+        };
+    });
+}
+/** Build plugin rows: `vVERSION  skills:6 commands:5 …` from the bundle's groups. */
+function pluginRows(items) {
+    return items.map(item => {
+        const version = item.extra?.find(([k]) => k === 'version')?.[1];
+        const counts = (item.groups ?? []).map(g => `${g.label}:${g.items.length}`).join(' ');
+        const detail = [version ? `v${version}` : '', counts].filter(Boolean).join('  ');
+        return { source: item.source, name: item.name, detail, linkTarget: item.linkTarget };
+    });
+}
+/** Build MCP rows by joining the installed mcp items with their full configs (transport/url/command). */
+function mcpRows(items, configs) {
+    return items.map(item => {
+        const cfg = configs.get(item.name);
+        return { source: item.source, name: item.name, detail: cfg ? summarizeMcp(cfg) : item.description };
+    });
+}
+/** Read a repo/agents.yaml `hooks:` section into a name→ManifestHook map (best-effort). */
+function hookManifestFromFile(agentsYamlPath) {
+    try {
+        const meta = yaml.parse(fs.readFileSync(agentsYamlPath, 'utf-8'));
+        return meta?.hooks ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Merge the system + user `agents.yaml` hook manifests (user wins on key
+ * collision). Built directly from the two layer files rather than via
+ * `parseHookManifest()` so inspecting never emits the shadow/override warnings
+ * that the registrar path prints.
+ */
+function loadCentralHookManifest() {
+    return {
+        ...hookManifestFromFile(path.join(getSystemAgentsDir(), 'agents.yaml')),
+        ...hookManifestFromFile(path.join(getUserAgentsDir(), 'agents.yaml')),
+    };
+}
+/**
+ * Hook items for a repo's Hooks section. Uses the grouped hook reader (script +
+ * data file collapsed into one entry, non-hook files like promptcuts.yaml or
+ * README.md filtered out) rather than a naive readdir, so names are clean and
+ * join cleanly against the manifest by script basename.
+ */
+function repoHookItems(repo) {
+    return listHookEntriesFromDir(path.join(repo.root, 'hooks')).map(h => ({
+        name: h.name,
+        source: repo.label,
+        path: h.scriptPath,
+        linkTarget: h.scriptPath,
+        description: '',
+    }));
+}
 function findMatches(items, query) {
     const q = query.toLowerCase();
     const out = [];
@@ -945,9 +1234,3 @@ function truncate(s, n) {
         return s;
     return s.slice(0, n - 1) + '…';
 }
-function formatScopeBreakdown(bySource) {
-    const entries = Object.entries(bySource);
-    if (entries.length === 0)
-        return '';
-    return '[' + entries.map(([k, v]) => `${k}:${v}`).join(' ') + ']';
-}

package/dist/commands/mcp.js

@@ -92,9 +92,9 @@ function parseMcpAgentTargets(value) {
             }
             continue;
         }
-        const resolvedVersion = versionToken === 'latest'
-            ? installedVersions[installedVersions.length - 1]
-            : versionToken;
+        const resolvedVersion = versionToken === 'latest' ? installedVersions[installedVersions.length - 1]
+            : versionToken === 'oldest' ? installedVersions[0]
+                : versionToken;
         if (!installedVersions.includes(resolvedVersion)) {
             throw new VersionNotInstalledError(agentId, resolvedVersion, installedVersions);
         }

package/dist/commands/plugins.d.ts

@@ -22,4 +22,6 @@ interface MarketplaceRow {
  * default Claude version's settings.json#enabledPlugins keyed on @<marketplace>.
  */
 export declare function collectMarketplaceRows(): MarketplaceRow[];
+/** Per-category color for a plugin resource breakdown (shared with `agents inspect`). */
+export declare const PLUGIN_GROUP_COLORS: Record<string, (s: string) => string>;
 export {};