@phnx-labs/agents-cli 1.22.22 → 1.22.24

package/dist/lib/refresh.js

@@ -29,7 +29,7 @@ import { isPromptCancelled } from '../commands/utils.js';
  * hook reads from a fixed path so it survives version upgrades. If the root
  * file doesn't exist yet but an agent-scoped one does, hoist the first one found.
  */
-function migratePromptcutsToRoot(agentsDir) {
+function migratePromptcutsToRoot(agentsDir, quiet = false) {
     const rootPath = path.join(agentsDir, 'promptcuts.yaml');
     if (fs.existsSync(rootPath))
         return;
@@ -39,7 +39,8 @@ function migratePromptcutsToRoot(agentsDir) {
         if (fs.existsSync(legacyPath)) {
             try {
                 fs.renameSync(legacyPath, rootPath);
-                console.log(chalk.gray(`Moved ${dir}/promptcuts.yaml → promptcuts.yaml (repo root)`));
+                if (!quiet)
+                    console.log(chalk.gray(`Moved ${dir}/promptcuts.yaml → promptcuts.yaml (repo root)`));
                 return;
             }
             catch {
@@ -56,16 +57,19 @@ function migratePromptcutsToRoot(agentsDir) {
  * Idempotent — safe to run repeatedly. No network operations.
  */
 export async function refresh(options = {}) {
-    const { agentFilter, skipPrompts = false, skipClis = false } = options;
+    const { agentFilter, skipPrompts = false, skipClis = false, quiet = false } = options;
     const agentsDir = getUserAgentsDir();
-    migratePromptcutsToRoot(agentsDir);
+    // Gate every human progress line so --json / fleet fan-out can parse stdout.
+    const log = (...args) => { if (!quiet)
+        console.log(...args); };
+    migratePromptcutsToRoot(agentsDir, quiet);
     const manifest = readManifest(agentsDir);
     if (!manifest) {
-        console.log(chalk.gray(`No ${MANIFEST_FILENAME} found`));
+        log(chalk.gray(`No ${MANIFEST_FILENAME} found`));
     }
     // 1. Install/upgrade CLI versions from agents.yaml
     if (!skipClis && manifest?.agents) {
-        console.log(chalk.bold('\nCLI Versions:\n'));
+        log(chalk.bold('\nCLI Versions:\n'));
         const cliAgents = Object.keys(manifest.agents);
         for (const agentId of cliAgents) {
             if (agentFilter && agentId !== agentFilter)
@@ -94,7 +98,7 @@ export async function refresh(options = {}) {
     }
     // 2. Register MCP servers
     if (manifest?.mcp && Object.keys(manifest.mcp).length > 0) {
-        console.log(chalk.bold('\nMCP Servers:\n'));
+        log(chalk.bold('\nMCP Servers:\n'));
         for (const [name, config] of Object.entries(manifest.mcp)) {
             if (!config.command || config.transport === 'http')
                 continue;
@@ -109,7 +113,7 @@ export async function refresh(options = {}) {
                     const label = result.version
                         ? `${agentLabel(result.agentId)}@${result.version}`
                         : agentLabel(result.agentId);
-                    console.log(`  ${chalk.green('+')} ${name} -> ${label}`);
+                    log(`  ${chalk.green('+')} ${name} -> ${label}`);
                 }
             }
         }
@@ -147,13 +151,13 @@ export async function refresh(options = {}) {
                 forceFullSync = true;
             }
             else if (!hasAnySynced) {
-                console.log(chalk.yellow(`\n${agentLabel(agentId)}@${defaultVer} has no synced resources.`));
+                log(chalk.yellow(`\n${agentLabel(agentId)}@${defaultVer} has no synced resources.`));
                 const userSelection = await promptResourceSelection(agentId);
                 if (userSelection)
                     selection = userSelection;
             }
             else if (hasNewResources(newResources, agentId, defaultVer)) {
-                console.log(chalk.cyan(`\n${agentLabel(agentId)}@${defaultVer}:`));
+                log(chalk.cyan(`\n${agentLabel(agentId)}@${defaultVer}:`));
                 const userSelection = await promptNewResourceSelection(agentId, newResources, defaultVer);
                 if (userSelection)
                     selection = userSelection;
@@ -184,13 +188,13 @@ export async function refresh(options = {}) {
                     const verNote = versionsToSync.length > 1
                         ? chalk.gray(` (${versionsToSync.length} versions)`)
                         : '';
-                    console.log(chalk.green(`  Synced: ${[...kinds].join(', ')}`) + verNote);
+                    log(chalk.green(`  Synced: ${[...kinds].join(', ')}`) + verNote);
                 }
             }
         }
         catch (err) {
             if (isPromptCancelled(err)) {
-                console.log(chalk.gray('Skipped resource selection'));
+                log(chalk.gray('Skipped resource selection'));
             }
             else {
                 throw err;
@@ -215,24 +219,24 @@ export async function refresh(options = {}) {
                 const result = registerHooksToSettings(agentId, home, hookManifest);
                 hookRegistered += result.registered.length;
                 for (const error of result.errors) {
-                    console.log(chalk.yellow(`  Hook warning: ${error}`));
+                    log(chalk.yellow(`  Hook warning: ${error}`));
                 }
             }
         }
         if (hookRegistered > 0) {
-            console.log(chalk.green(`\nRegistered ${hookRegistered} hook lifecycle event(s)`));
+            log(chalk.green(`\nRegistered ${hookRegistered} hook lifecycle event(s)`));
         }
     }
     // 5. Auto-add shims to PATH
     if (!isShimsInPath()) {
         const pathResult = addShimsToPath();
         if (pathResult.success && !pathResult.alreadyPresent) {
-            console.log(chalk.green(`\nAdded shims to ${pathResult.location}`));
-            console.log(chalk.gray(pathResult.reloadHint));
+            log(chalk.green(`\nAdded shims to ${pathResult.location}`));
+            log(chalk.gray(pathResult.reloadHint));
         }
         else if (!pathResult.success) {
-            console.log(chalk.yellow('\nCould not auto-add shims to PATH:'));
-            console.log(chalk.gray(getPathSetupInstructions()));
+            log(chalk.yellow('\nCould not auto-add shims to PATH:'));
+            log(chalk.gray(getPathSetupInstructions()));
         }
     }
     // 6. Prompt for missing default versions
@@ -273,63 +277,63 @@ export async function refresh(options = {}) {
             setGlobalDefault(agentId, version);
             const symlinkResult = await switchConfigSymlink(agentId, version);
             if (!symlinkResult.success) {
-                console.log(chalk.yellow(`Warning: ${symlinkResult.error}`));
+                log(chalk.yellow(`Warning: ${symlinkResult.error}`));
             }
             else if (symlinkResult.backupPath) {
-                console.log(chalk.gray(`Backed up existing config to: ${symlinkResult.backupPath}`));
+                log(chalk.gray(`Backed up existing config to: ${symlinkResult.backupPath}`));
             }
             switchHomeFileSymlinks(agentId, version);
-            console.log(chalk.green(`Set ${agentLabel(agent.id)}@${version} as default`));
+            log(chalk.green(`Set ${agentLabel(agent.id)}@${version} as default`));
         }
     }
     // 7. Install declared host-CLIs
     try {
         const { statuses, errors } = listCliStatus(process.cwd());
         for (const err of errors) {
-            console.log(chalk.yellow(`  CLI manifest parse error: ${err.file}: ${err.reason}`));
+            log(chalk.yellow(`  CLI manifest parse error: ${err.file}: ${err.reason}`));
         }
         const missing = statuses.filter((s) => !s.installed);
         if (missing.length > 0) {
-            console.log(chalk.bold('\nDeclared CLIs missing from this host:'));
+            log(chalk.bold('\nDeclared CLIs missing from this host:'));
             for (const s of missing) {
                 const method = selectInstallMethod(s.manifest);
                 const action = method ? describeMethod(method) : chalk.red('no compatible install method');
-                console.log(`  ${chalk.cyan(s.manifest.name.padEnd(20))} ${chalk.gray(action)}`);
+                log(`  ${chalk.cyan(s.manifest.name.padEnd(20))} ${chalk.gray(action)}`);
             }
-            console.log('');
+            log('');
             if (!skipPrompts) {
                 const proceed = await confirm({ message: `Install ${missing.length} missing CLI(s) now?`, default: true });
                 if (proceed) {
                     for (const s of missing) {
-                        console.log(chalk.bold(`\n→ ${s.manifest.name}`));
+                        log(chalk.bold(`\n→ ${s.manifest.name}`));
                         const result = installCli(s.manifest);
                         if (result.error) {
-                            console.log(chalk.red(`  ${result.error}`));
+                            log(chalk.red(`  ${result.error}`));
                             continue;
                         }
                         if (result.installed) {
-                            console.log(chalk.green(`  installed`));
+                            log(chalk.green(`  installed`));
                             if (s.manifest.postInstall) {
-                                console.log(chalk.gray(s.manifest.postInstall.trim().split('\n').map((l) => '  ' + l).join('\n')));
+                                log(chalk.gray(s.manifest.postInstall.trim().split('\n').map((l) => '  ' + l).join('\n')));
                             }
                         }
                         else {
-                            console.log(chalk.yellow(`  install ran but \`${describeCheck(s.manifest.check)}\` still fails`));
+                            log(chalk.yellow(`  install ran but \`${describeCheck(s.manifest.check)}\` still fails`));
                         }
                     }
                 }
                 else {
-                    console.log(chalk.gray(`Skipped. Run 'agents cli install' later.`));
+                    log(chalk.gray(`Skipped. Run 'agents cli install' later.`));
                 }
             }
             else {
-                console.log(chalk.gray(`Run 'agents cli install' to install them.`));
+                log(chalk.gray(`Run 'agents cli install' to install them.`));
             }
         }
     }
     catch (err) {
         if (!isPromptCancelled(err)) {
-            console.log(chalk.yellow(`CLI install skipped: ${err.message}`));
+            log(chalk.yellow(`CLI install skipped: ${err.message}`));
         }
     }
 }

package/dist/lib/remote-agents-json.d.ts

@@ -12,6 +12,34 @@ export interface RemoteAgentsJsonOptions<T> {
     quiet?: boolean;
     /** Per-peer deadline. Long-running maintenance commands override 12 seconds. */
     timeoutMs?: number;
+    /**
+     * Opt-in early-exit for a globally-unique lookup (a full session UUID). When a
+     * peer returns an item that satisfies {@link isDefinitive}, the fan-out
+     * resolves immediately and SIGTERMs every still-outstanding peer instead of
+     * waiting for the slowest one to hit {@link REMOTE_TIMEOUT_MS}.
+     *
+     * OMITTED BY DEFAULT — tool-search, program-count, and the default session
+     * listing keep the all-settle behavior (ambiguity, or a label/prefix conflict,
+     * is only known once every peer has answered). Only the full-UUID resolve path
+     * opts in, since only a UUID guarantees the first hit is the only hit.
+     */
+    earlyExit?: {
+        isDefinitive: (item: T, machine: string) => boolean;
+    };
+}
+/**
+ * The SSH boundary as a swappable dependency so the fan-out logic is testable
+ * without a live tailnet. Production wires this to the real {@link sshCapture}.
+ */
+export type SshCaptureFn = (target: string, remoteCmd: string, opts: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+}) => Promise<{
+    code: number | null;
+    stdout: string;
+}>;
+export interface GatherRemoteAgentsJsonDeps {
+    capture?: SshCaptureFn;
 }
 export interface RemoteAgentsJsonParseResult<T> {
     items: T[];
@@ -35,4 +63,4 @@ export declare function parseRemoteAgentsJsonPayload<T>(stdout: string, machine:
 /** Build the command one peer runs, with a guard that prevents recursive fan-out. */
 export declare function remoteAgentsJsonCommand(args: string[], noFanoutEnv: string, os?: string): string;
 /** Query explicit hosts, or every registered online peer when hosts is omitted. */
-export declare function gatherRemoteAgentsJson<T>(options: RemoteAgentsJsonOptions<T>): Promise<RemoteAgentsJsonResult<T>>;
+export declare function gatherRemoteAgentsJson<T>(options: RemoteAgentsJsonOptions<T>, deps?: GatherRemoteAgentsJsonDeps): Promise<RemoteAgentsJsonResult<T>>;

package/dist/lib/remote-agents-json.js

@@ -7,6 +7,7 @@
  * healthy results from the rest of the fleet.
  */
 import { spawn } from 'child_process';
+import { setMaxListeners } from 'node:events';
 import chalk from 'chalk';
 import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote } from './ssh-exec.js';
 import { sshTargetFor } from './devices/connect.js';
@@ -32,9 +33,13 @@ export function remoteAgentsJsonCommand(args, noFanoutEnv, os) {
     const inner = `${noFanoutEnv}=1 agents ${args.map(shellQuote).join(' ')}`;
     return `bash -lc ${shellQuote(inner)}`;
 }
-function sshCapture(target, remoteCmd, timeoutMs) {
+const sshCapture = (target, remoteCmd, { timeoutMs, signal }) => {
     assertValidSshTarget(target);
     return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve({ code: null, stdout: '' });
+            return;
+        }
         const args = [...SSH_OPTS, ...controlOpts(), target, remoteCmd];
         const child = spawn('ssh', args, { stdio: ['ignore', 'pipe', 'ignore'] });
         let stdout = '';
@@ -44,19 +49,25 @@ function sshCapture(target, remoteCmd, timeoutMs) {
                 return;
             settled = true;
             clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
             resolve({ code, stdout });
         };
         const timer = setTimeout(() => {
             child.kill('SIGKILL');
             done(null);
         }, timeoutMs);
+        // A definitive hit on a fast peer cancels the rest: SIGTERM the child so an
+        // unreachable peer is not left running to its full timeout.
+        const onAbort = () => { child.kill('SIGTERM'); done(null); };
+        signal?.addEventListener('abort', onAbort, { once: true });
         child.stdout.on('data', (data) => { stdout += data.toString(); });
         child.on('error', () => done(null));
         child.on('close', (code) => done(code));
     });
-}
+};
 /** Query explicit hosts, or every registered online peer when hosts is omitted. */
-export async function gatherRemoteAgentsJson(options) {
+export async function gatherRemoteAgentsJson(options, deps = {}) {
+    const capture = deps.capture ?? sshCapture;
     const self = machineId();
     const targets = [];
     if (options.hosts && options.hosts.length > 0) {
@@ -100,24 +111,50 @@ export async function gatherRemoteAgentsJson(options) {
     }
     const skipped = [];
     const parseFailed = [];
+    // The controller exists ONLY for early-exit: the first definitive hit aborts
+    // every still-outstanding peer. When earlyExit is not requested there is no
+    // controller and no per-peer abort listener, so the default path is a plain
+    // all-settle Promise.all, byte-identical to before (tool-search, program-count).
+    const controller = options.earlyExit ? new AbortController() : undefined;
+    // A fleet can hold more peers than Node's default 10-listener cap; each peer's
+    // capture adds one abort listener, so lift the cap to avoid a spurious warning.
+    if (controller)
+        setMaxListeners(targets.length + 1, controller.signal);
+    let earlyResolved = false;
     const results = await Promise.all(targets.map(async (target) => {
         const command = remoteAgentsJsonCommand(options.args, options.noFanoutEnv, target.os);
-        const result = await sshCapture(target.target, command, options.timeoutMs ?? REMOTE_TIMEOUT_MS);
+        const result = await capture(target.target, command, {
+            timeoutMs: options.timeoutMs ?? REMOTE_TIMEOUT_MS,
+            signal: controller?.signal,
+        });
+        // A peer we deliberately cancelled is neither a hit nor a failure — it never
+        // got to answer, so it must not pollute skipped/parseFailed (which drive the
+        // "unreachable" listing and the fail-closed partial-resolution gate).
+        const cancelled = controller?.signal.aborted ?? false;
         if (result.code !== 0) {
-            skipped.push(target.name);
-            if (!options.quiet) {
-                process.stderr.write(chalk.gray(`  ${target.name}: unreachable or no agents CLI — skipped\n`));
+            if (!cancelled) {
+                skipped.push(target.name);
+                if (!options.quiet) {
+                    process.stderr.write(chalk.gray(`  ${target.name}: unreachable or no agents CLI — skipped\n`));
+                }
             }
             return [];
         }
         const parsed = parseRemoteAgentsJsonPayload(result.stdout, target.machine, options.parse);
         if (parsed.parseFailed) {
-            parseFailed.push(target.name);
-            if (!options.quiet) {
-                process.stderr.write(chalk.gray(`  ${target.name}: unreachable or no agents CLI — skipped\n`));
+            if (!cancelled) {
+                parseFailed.push(target.name);
+                if (!options.quiet) {
+                    process.stderr.write(chalk.gray(`  ${target.name}: unreachable or no agents CLI — skipped\n`));
+                }
             }
             return [];
         }
+        if (controller && options.earlyExit && !earlyResolved
+            && parsed.items.some((item) => options.earlyExit.isDefinitive(item, target.machine))) {
+            earlyResolved = true;
+            controller.abort(); // SIGTERM the remaining peers; they settle fast below.
+        }
         return parsed.items;
     }));
     return { items: results.flat(), deviceCount: targets.length, skipped, parseFailed, discoveryFailed: false };

package/dist/lib/resource-inventory.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Resource inventory — the single chokepoint for "what does this agent@version
+ * have" (RUSH-2238, parent RUSH-2236; spec: openspec/specs/resource-inventory).
+ *
+ * One API answers four orthogonal questions per (agent, version, kind):
+ *
+ *   capable   — the agent+version feature flags allow the kind at all
+ *   declared  — resources the DotAgents layers (project/user/system/extra)
+ *               declare for sync
+ *   onDisk    — resources actually installed in the version home filesystem
+ *               (the installed-resource truth — NOT agents.yaml tracking data)
+ *   wired     — resources the harness native config references so they fire
+ *   unmanaged — onDisk − declared (orphans no layer declares anymore)
+ *
+ * Callers (inspect, doctor, view, sync) MUST come here rather than
+ * re-implementing path joins or config parsing per command. Wiring parsing
+ * currently covers the settings.json family (claude, droid,
+ * muse), Grok hooks.json, and Kimi config.toml via checkVersionHookWiring.
+ */
+import type { AgentId } from './types.js';
+import { type HookWiringReport } from './hooks.js';
+/** Resource kinds the inventory can report. Only 'hooks' is implemented so far
+ *  (RUSH-2238); the remaining kinds land with their follow-up tickets. */
+export type InventoryKind = 'hooks' | 'skills' | 'commands' | 'plugins' | 'mcp';
+/** A reference to one resource in one state (declared / onDisk / wired). */
+export interface ResourceRef {
+    /** Stable install name (script basename without extension for hooks). */
+    name: string;
+    /** Declared/onDisk: absolute file path. Wired: the command string the native
+     *  config references. */
+    path: string;
+    /** Origin: a layer name for declared ('project' | 'user' | 'system' | extra
+     *  repo alias), 'user'/'project' scope or 'version-home' for onDisk,
+     *  'native-config' for wired. */
+    source: string;
+    /** Optional context — e.g. the lifecycle events a wired hook fires on. */
+    detail?: string;
+}
+export interface ResourceInventory {
+    agent: AgentId;
+    version: string;
+    kind: InventoryKind;
+    /** Agent+version feature flags allow this kind (version-aware gate). */
+    capable: boolean;
+    /** Declared in the DotAgents layers. */
+    declared: ResourceRef[];
+    /** Installed on disk in the version home. */
+    onDisk: ResourceRef[];
+    /** Referenced by the harness native config (empty when wiringSupported is
+     *  false — the format parser for that harness is not implemented yet). */
+    wired: ResourceRef[];
+    /** onDisk − declared: installed orphans no layer declares. */
+    unmanaged: ResourceRef[];
+    /** Whether this harness's native wiring was read successfully. When false,
+     *  `wired: []` means "unknown" (unsupported family OR unparseable config),
+     *  NOT "nothing wired". Format-supported but corrupt configs set this false. */
+    wiringSupported: boolean;
+    /** Native-format diagnostic retained for doctor; derived in this same pass. */
+    wiring?: HookWiringReport;
+}
+/**
+ * The single inventory API. Harness-scoped (claude/codex/grok/kimi/droid) —
+ * never a model or profile. Throws for kinds without an implementation rather
+ * than returning a half-empty report that looks like truth.
+ */
+export declare function getResourceInventory(agent: AgentId, version: string, kind: InventoryKind, opts?: {
+    cwd?: string;
+}): ResourceInventory;
+/**
+ * On-disk hook listing for an explicit home (version home or effective home)
+ * plus the project overlay — the one listing `getAgentResources` routes
+ * through, so inspect/doctor/view share a single hooks source. Paths resolve
+ * through the absolute-hooksDir-safe join (RUSH-2237), so grok/kimi version
+ * homes list their real hooks.
+ */
+export declare function listOnDiskHooks(agent: AgentId, opts?: {
+    home?: string;
+    cwd?: string;
+}): ResourceRef[];

package/dist/lib/resource-inventory.js

@@ -0,0 +1,122 @@
+/**
+ * Resource inventory — the single chokepoint for "what does this agent@version
+ * have" (RUSH-2238, parent RUSH-2236; spec: openspec/specs/resource-inventory).
+ *
+ * One API answers four orthogonal questions per (agent, version, kind):
+ *
+ *   capable   — the agent+version feature flags allow the kind at all
+ *   declared  — resources the DotAgents layers (project/user/system/extra)
+ *               declare for sync
+ *   onDisk    — resources actually installed in the version home filesystem
+ *               (the installed-resource truth — NOT agents.yaml tracking data)
+ *   wired     — resources the harness native config references so they fire
+ *   unmanaged — onDisk − declared (orphans no layer declares anymore)
+ *
+ * Callers (inspect, doctor, view, sync) MUST come here rather than
+ * re-implementing path joins or config parsing per command. Wiring parsing
+ * currently covers the settings.json family (claude, droid,
+ * muse), Grok hooks.json, and Kimi config.toml via checkVersionHookWiring.
+ */
+import { AGENTS } from './agents.js';
+import { supports } from './capabilities.js';
+import { listResources } from './resources.js';
+import { checkVersionHookWiring, listHooksInVersionHome, listInstalledHooksWithScope, } from './hooks.js';
+const IMPLEMENTED_KINDS = ['hooks'];
+/**
+ * The single inventory API. Harness-scoped (claude/codex/grok/kimi/droid) —
+ * never a model or profile. Throws for kinds without an implementation rather
+ * than returning a half-empty report that looks like truth.
+ */
+export function getResourceInventory(agent, version, kind, opts = {}) {
+    if (!IMPLEMENTED_KINDS.includes(kind)) {
+        // Fail loud at the boundary: the kind is part of the API shape but its
+        // inventory lands with a RUSH-2236 follow-up — a silent empty report would
+        // read as "nothing installed".
+        throw new Error(`getResourceInventory: kind '${kind}' is not implemented yet (implemented: ${IMPLEMENTED_KINDS.join(', ')}; tracked under RUSH-2236)`);
+    }
+    return hooksInventory(agent, version, opts.cwd);
+}
+/**
+ * On-disk hook listing for an explicit home (version home or effective home)
+ * plus the project overlay — the one listing `getAgentResources` routes
+ * through, so inspect/doctor/view share a single hooks source. Paths resolve
+ * through the absolute-hooksDir-safe join (RUSH-2237), so grok/kimi version
+ * homes list their real hooks.
+ */
+export function listOnDiskHooks(agent, opts = {}) {
+    return listInstalledHooksWithScope(agent, opts.cwd ?? process.cwd(), { home: opts.home }).map((h) => ({
+        name: h.name,
+        path: h.path,
+        source: h.scope,
+        detail: h.dataFile,
+    }));
+}
+function hooksInventory(agent, version, cwd) {
+    const capable = supports(agent, 'hooks', version).ok;
+    // Declared: the layered DotAgents repos are the declaration surface. Hook
+    // script names carry their extension here ('git-guard.sh'); normalize to the
+    // extension-less install name so declared/onDisk sets compare.
+    const declared = listResources('hooks', cwd).map((r) => ({
+        name: r.name.replace(/\.[^./]+$/, ''),
+        path: r.path,
+        source: r.source,
+    }));
+    // onDisk / wired need the version home; both are empty for an agent whose
+    // hooks capability is gated off (unknown agents included — AGENTS lookup
+    // would otherwise throw).
+    let onDisk = [];
+    let wired = [];
+    let wiringSupported = false;
+    let wiring;
+    if (capable && AGENTS[agent]?.supportsHooks) {
+        onDisk = listHooksInVersionHome(agent, version).map((e) => ({
+            name: e.name,
+            path: e.scriptPath,
+            source: 'version-home',
+            detail: e.dataFile,
+        }));
+        const report = checkVersionHookWiring(agent, version);
+        wiring = report;
+        // supported=true means the harness format is known; settingsUnparseable means
+        // we could not trust the file. Only report wired counts when the parse succeeded —
+        // otherwise inspect/doctor would render "wired 0" for corrupt configs (PR #2140 review).
+        wiringSupported = report.supported && !report.settingsUnparseable;
+        if (wiringSupported) {
+            // One ref per hook, events folded into detail — a hook wired under
+            // PreToolUse AND Stop is one inventory entry, not two.
+            const eventsByName = new Map();
+            const commandByName = new Map();
+            for (const issue of report.wired) {
+                let events = eventsByName.get(issue.name);
+                if (!events) {
+                    events = new Set();
+                    eventsByName.set(issue.name, events);
+                    commandByName.set(issue.name, issue.command);
+                }
+                events.add(issue.event);
+            }
+            wired = [...eventsByName.entries()]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([name, events]) => ({
+                name,
+                path: commandByName.get(name),
+                source: 'native-config',
+                detail: [...events].sort().join('/'),
+            }));
+        }
+    }
+    const declaredNames = new Set(declared.map((r) => r.name));
+    const unmanaged = onDisk.filter((r) => !declaredNames.has(r.name));
+    return {
+        agent,
+        version,
+        kind: 'hooks',
+        capable,
+        declared,
+        onDisk,
+        wired,
+        unmanaged,
+        wiringSupported,
+        wiring,
+    };
+}

package/dist/lib/resources/mcp.js

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

package/dist/lib/resources/permissions.js

@@ -81,6 +81,9 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.hermes', 'config.yaml');
         case 'goose':
             return path.join(versionHome, '.config', 'goose', 'permission.yaml');
+        case 'muse':
+            // Muse approval defaults live in settings.json; no separate permissions file.
+            return path.join(versionHome, '.config', 'muse', 'settings.json');
         default:
             return null;
     }

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

@@ -5,7 +5,8 @@
  * - 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' | 'pi';
+import type { AgentId } from '../types.js';
+export type { AgentId };
 /** Resource origin. Precedence (highest first): project > user > plugin > system. */
 export type Layer = 'system' | 'user' | 'project' | 'plugin';
 export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow' | 'memory';

package/dist/lib/resources.js

@@ -7,7 +7,7 @@ import * as path from 'path';
 import { AGENTS, listInstalledMcpsWithScope } from './agents.js';
 import { listInstalledCommandsWithScope } from './commands.js';
 import { listInstalledSkillsWithScope } from './skills.js';
-import { listInstalledHooksWithScope } from './hooks.js';
+import { listOnDiskHooks } from './resource-inventory.js';
 import { listInstalledInstructionsWithScope } from './rules/rules.js';
 import { getEffectiveHome } from './versions.js';
 import { listMcpServerConfigs } from './mcp.js';
@@ -352,11 +352,14 @@ export function getAgentResources(agentId, options = {}) {
             });
         }
     }
-    // Hooks
+    // Hooks — routed through the resource-inventory chokepoint (RUSH-2238) so
+    // inspect/doctor/view share one listing and one (absolute-hooksDir-safe)
+    // path resolution.
     const hooks = [];
-    for (const hook of listInstalledHooksWithScope(agentId, cwd, { home })) {
-        if (shouldInclude(hook.scope)) {
-            hooks.push({ name: hook.name, path: hook.path, scope: hook.scope });
+    for (const ref of listOnDiskHooks(agentId, { cwd, home })) {
+        const hookScope = ref.source;
+        if (shouldInclude(hookScope)) {
+            hooks.push({ name: ref.name, path: ref.path, scope: hookScope });
         }
     }
     // Workflows

package/dist/lib/run-defaults.d.ts

@@ -21,6 +21,7 @@ export interface ResolvedRunDefaults extends RunDefaults {
     sources: {
         mode?: string;
         model?: string;
+        effort?: string;
     };
 }
 export interface RunDefaultEntry {
@@ -30,6 +31,7 @@ export interface RunDefaultEntry {
 type RunDefaultsInput = {
     mode?: unknown;
     model?: unknown;
+    effort?: unknown;
 };
 export declare function normalizeRunDefaultMode(input: string): Mode;
 export declare function parseRunDefaultSelector(input: string): ParsedRunDefaultSelector;