@phnx-labs/agents-cli 1.20.12 → 1.20.14

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## Unreleased
 
+**`agents inspect` summary: expanded detail for hooks, plugins, and MCP**
+
+- The bare `agents inspect <agent>` / `agents inspect <repo>` summary no longer collapses everything to a count table. Simple kinds (commands, skills, rules, subagents, workflows) keep a count line but now preview a few names; the rich kinds get their own expanded sections: **hooks** show their events + `matches:` predicates + cache (`PreToolUse(Bash) · git_dirty · prompt~"deploy" (5m cache)`), **plugins** show version + bundle contents (`v2.1.0  skills:6 commands:5 hooks:2 mcp:1`), and **MCP** show transport + url/command. Drill-down flags (`--hooks`, `--plugins`, `--mcp`) and `--brief` are unchanged; `--json` gains the structured detail additively (existing keys retained).
+- Hook detail joins installed hooks to the manifest by **script basename** (installed hooks are named after their script file while the manifest keys on the logical name), and the repo Hooks section uses the grouped hook reader so a script + its data file collapse to one clean entry.
+
+**Plugin hooks were misreported — fixed**
+
+- `discoverPluginHooks` read the **top-level** keys of a plugin's `hooks/hooks.json`, so the official `{ description, hooks: { SessionStart: [...] } }` format surfaced as `description, hooks` instead of the real events. It now reads the `hooks` wrapper when present (falling back to top-level keys for the flat format), so `agents inspect --plugin <name>` and the plugin row show the actual lifecycle events (e.g. `SessionStart, PreToolUse, …`).
+
+**`agents doctor` / `agents prune`: precise orphan-hooks detection**
+
+- Orphan-hook detection now flags hook scripts present in a version home that **no `agents.yaml`/`hooks.yaml` entry registers** — i.e. scripts that sync to disk but are never wired to a lifecycle event, so they never fire. This replaces the source-diff heuristic, which compared only against the user hooks dir and so **false-flagged valid system-sourced, registered hooks** (e.g. `03-linear-inject`, `04-capture`) as orphans — meaning `agents prune cleanup` could have deleted live hooks. Doctor's Orphans section and `prune cleanup hooks` now share this single manifest-based definition. `parseHookManifest` gained a silent (`{ warn: false }`) option so the diagnostic doesn't emit shadow/override warnings.
+
+**Regression coverage: resource sync from extras repos**
+
+- Added end-to-end regression tests (`src/lib/__tests__/extras-sync.test.ts`) locking in two behaviors for repos registered via `agents repo add` (`~/.agents-<alias>/`): a top-level `commands/<name>.md` is written into the agent's version home on `agents sync`, and plugins under `plugins/<name>/` are synthesized into a registered `agents-<alias>` marketplace on launch. Both already work in `main`; the tests exercise the real sync path (no mocking, isolated `$HOME`) so the extras-repo behavior can't silently regress (#313, #314).
+
+**Windows: `agents` is discoverable right after `npm i -g`**
+
+- On a global Windows install, postinstall now prepends npm's global-bin dir (where `agents.cmd`/`agents.ps1` live) to the **User PATH** via the .NET environment API. Node's installer normally adds it, but winget / portable / nvm-windows setups often don't — and then `npm i -g @phnx-labs/agents-cli` succeeds yet `agents` is "not recognized". The shims dir (claude/codex/…) is still left to `agents setup`, which the user can now run because `agents` resolves.
+- Postinstall also detects a `Restricted`/`AllSigned` PowerShell execution policy (which blocks the generated `.ps1` launchers, so even an on-PATH `agents` fails in PowerShell) and prints the one-line fix (`Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`). The policy is a security setting, so it is never changed silently — only surfaced.
+- Refactor: the Windows User-PATH prepend logic moved from `shims.ts` into a new `src/lib/platform/winpath.ts` leaf module (`prependToWindowsUserPath`, `getEffectiveExecutionPolicy`, `blocksLocalScripts`, `npmGlobalBinFromEntry`); `addShimsToWindowsUserPath` now delegates to it. Pure helpers are unit-tested.
+
+**Factory AI Droid (first-class support)**
+
+- Add `droid` as a first-class supported agent (AgentId + full registry entry for Factory AI's `droid` CLI, config in `~/.factory/`). Installs via the official script (`curl -fsSL https://app.factory.ai/cli | sh`); the binary is resolved through the standard install-script path and isolated per version via the `~/.factory` config symlink (Droid has no `*_HOME` override).
+- Resource sync wired for the four resource types Droid supports natively: **MCP** (`~/.factory/mcp.json`), **rules** (native `AGENTS.md`), **subagents** (custom droids flattened to `~/.factory/droids/*.md`, with the unsupported `color` frontmatter key stripped), and **commands** (`~/.factory/commands/`). Skills/plugins/workflows have no Droid equivalent and are disabled; hooks/permissions are deferred.
+- `agents run droid` and `agents teams add … droid` work end-to-end: headless `droid exec` with mode mapping (plan → read-only, edit → `--auto low`, auto → `--auto high`, skip → `--skip-permissions-unsafe`), `-o stream-json` output, `-m` model selection, and `-r` reasoning effort. Routine/daemon jobs (`buildJobCommand`) support Droid too.
+- Known limitation: `agents teams` renders Droid events through the generic normalizer pending a verified `droid exec -o stream-json` event schema; structured tool/file categorization will follow. Session reading and Factory cloud dispatch remain follow-ups.
+
 **`agents upgrade` now refreshes the macOS Keychain helper**
 
 - Upgrading runs `npm install -g … --ignore-scripts`, so the postinstall that installs the signed Keychain helper never fired — a user upgrading away from a broken build (e.g. the entitlement-less 1.20.4 helper that failed `SecItemAdd` with `errSecMissingEntitlement -34018`) kept the broken helper until the lazy staleness check in `getKeychainHelperPath()` happened to repair it on their next secret operation. `installResolvedPackage` now force-refreshes the helper (`ensureKeychainHelperInstalled({ forceReinstall: true })`) on darwin after the install, so both the explicit `agents upgrade` and the auto-update prompt land the fixed helper immediately. Best-effort and non-fatal: an upgrade never fails because the helper could not be reinstalled, and `agents helper install --force` remains the manual path.

package/README.md

@@ -29,6 +29,8 @@
   <a href="https://github.com/NousResearch/hermes-agent" title="Hermes Agent"><img src="assets/harnesses/hermes.png" height="32" alt="Hermes Agent" /></a>
   &nbsp;&nbsp;&nbsp;&nbsp;
   <a href="https://x.ai" title="Grok Build (xAI)"><strong>Grok</strong></a>
+  &nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="https://factory.ai" title="Factory AI Droid"><strong>Droid</strong></a>
 </p>
 
 https://agents-cli.sh/demo.mp4
@@ -86,6 +88,7 @@ Think `requirements.txt` for CLI coding agents, on steroids. A shim reads `agent
 ```bash
 agents add claude@2.0.65     # Install a specific version
 agents add codex@latest       # Install latest
+agents add codex@oldest       # Install the oldest published version
 agents view                   # See everything installed
 ```
 

package/dist/commands/computer-actions.d.ts

@@ -35,6 +35,9 @@ export declare function buildRaiseParams(opts: {
     windowId?: number;
     title?: string;
 }): Record<string, unknown>;
+export declare const CHAR_DELAY_MIN_MS = 1;
+export declare const CHAR_DELAY_MAX_MS = 250;
+export declare function clampCharDelay(ms: number | undefined): number | undefined;
 export declare function buildWaitParams(opts: {
     duration?: number;
     id?: string;

package/dist/commands/computer-actions.js

@@ -70,6 +70,18 @@ export function buildRaiseParams(opts) {
         params.title = opts.title;
     return params;
 }
+// Inter-character typing delay for type-text. Default 4ms matches the daemon's
+// historical fixed rate; lossy keyboard relays (Parallels/VM guests) drop chars
+// at that rate, so callers can raise it. Clamp to [1, 250]ms CLI-side (the
+// daemon clamps too — defense in depth). Returns undefined when unset so the
+// daemon applies its own default. Pure + tested.
+export const CHAR_DELAY_MIN_MS = 1;
+export const CHAR_DELAY_MAX_MS = 250;
+export function clampCharDelay(ms) {
+    if (ms === undefined || !Number.isFinite(ms))
+        return undefined;
+    return Math.min(CHAR_DELAY_MAX_MS, Math.max(CHAR_DELAY_MIN_MS, Math.trunc(ms)));
+}
 // Build the wait RPC params. Pure + tested. Three modes, mirroring the
 // daemon's Wait.run: --duration (unconditional sleep), --id + --until
 // (cached-element poll), or --role/--label/--identifier (live locator poll).
@@ -276,6 +288,7 @@ export function registerActionCommands(program) {
         .option('--commit', 'Press Return after typing')
         .option('--raise', 'Bring the target app to the front first')
         .option('--require-frontmost', 'Fail (not warn) if the target is not the frontmost app')
+        .option('--char-delay <ms>', 'Inter-character delay in ms (default 4; raise for lossy keyboard relays like VM guests, e.g. 25). Clamped to [1, 250].', (v) => parseInt(v, 10))
         .option('--json', 'Emit JSON')).action(async (opts) => {
         await withClient(async (client) => {
             const pid = await resolveTargetPid(client, opts);
@@ -285,6 +298,9 @@ export function registerActionCommands(program) {
                 params.commit = true;
             if (opts.requireFrontmost)
                 params.require_frontmost = true;
+            const charDelay = clampCharDelay(opts.charDelay);
+            if (charDelay !== undefined)
+                params.char_delay_ms = charDelay;
             const res = unwrap(await client.call('type_text', params));
             warnIfNotFrontmost(res);
             emit(res, Boolean(opts.json), () => `typed ${res.chars ?? opts.text.length} char(s)`);

package/dist/commands/doctor.js

@@ -5,9 +5,10 @@ import { getGlobalDefault, getVersionHomePath, isVersionInstalled, listInstalled
 import { loadManifest, isStale } from '../lib/staleness/index.js';
 import { diffVersionCommands, iterCommandsCapableVersions } from '../lib/commands.js';
 import { diffVersionSkills, iterSkillsCapableVersions } from '../lib/skills.js';
-import { diffVersionHooks, iterHooksCapableVersions } from '../lib/hooks.js';
+import { iterHooksCapableVersions, listUnmanagedHooksInVersionHome } from '../lib/hooks.js';
 import { diffVersionResources, DOCTOR_ALL_KINDS, } from '../lib/doctor-diff.js';
 import { unifiedDiff, colorizeUnifiedDiff } from '../lib/diff-text.js';
+import { listCliStatus } from '../lib/cli-resources.js';
 import { setHelpSections } from '../lib/help.js';
 import * as fs from 'fs';
 const AGENT_NAMES = Object.fromEntries(ALL_AGENT_IDS.map((id) => [id, AGENTS[id].name]));
@@ -53,16 +54,20 @@ function countOrphans() {
         if (diff.orphans.length > 0)
             ensure(agent, version).skills = diff.orphans.length;
     }
+    // Orphan hooks are scripts in the version home that no agents.yaml/hooks.yaml
+    // entry registers — so the registrar never wires them to an event and they
+    // never fire. (Distinct from the source-diff `diffVersionHooks().orphans`,
+    // which false-flags valid system-sourced registered hooks.)
     for (const { agent, version } of iterHooksCapableVersions()) {
         if (version !== getGlobalDefault(agent))
             continue;
-        const diff = diffVersionHooks(agent, version);
-        if (diff.orphans.length > 0)
-            ensure(agent, version).hooks = diff.orphans.length;
+        const dead = listUnmanagedHooksInVersionHome(agent, version);
+        if (dead.length > 0)
+            ensure(agent, version).hooks = dead.length;
     }
     return Array.from(byKey.values()).filter((r) => r.commands + r.skills + r.hooks > 0);
 }
-function renderOverviewText(clis, syncRows, orphanRows) {
+function renderOverviewText(clis, syncRows, orphanRows, hostClis) {
     console.log(chalk.bold('Agent CLIs'));
     if (Object.keys(clis).length === 0) {
         console.log(chalk.gray('  (no agents reported)'));
@@ -116,6 +121,31 @@ function renderOverviewText(clis, syncRows, orphanRows) {
         }
         console.log(chalk.gray('  Run `agents prune cleanup` to remove.'));
     }
+    console.log();
+    // Host CLIs are host-global (declared in any DotAgents repo's cli/, installed
+    // to PATH — not synced into version homes), so they live in the overview, not
+    // the per-version resource diff. Source tag shows which repo layer declared
+    // each, including user-level and extra repos.
+    console.log(chalk.bold('Host CLIs'));
+    if (hostClis.statuses.length === 0) {
+        console.log(chalk.gray('  (none declared — add one with `agents cli add <name>`)'));
+    }
+    else {
+        const nameWidth = Math.max(...hostClis.statuses.map((s) => s.manifest.name.length));
+        for (const { manifest, installed } of hostClis.statuses) {
+            const label = manifest.name.padEnd(nameWidth);
+            const src = chalk.gray(`[${manifest.source}]`);
+            if (installed) {
+                console.log(`  ${chalk.green('ready')}  ${label}  ${src}  ${chalk.gray(manifest.description || '')}`);
+            }
+            else {
+                console.log(`  ${chalk.red('miss ')}  ${label}  ${src}  ${chalk.gray(`not installed — run \`agents cli install ${manifest.name}\``)}`);
+            }
+        }
+    }
+    for (const err of hostClis.errors) {
+        console.log(`  ${chalk.red('err  ')}  ${chalk.gray(err.file)}: ${chalk.gray(err.reason)}`);
+    }
 }
 function parseTargetArg(arg) {
     const at = arg.indexOf('@');
@@ -346,11 +376,25 @@ export function registerDoctorCommand(program) {
             const clis = checkAllClis();
             const syncRows = checkSyncStatus(cwd);
             const orphanRows = countOrphans();
+            const hostClis = listCliStatus(cwd);
             if (opts.json) {
-                console.log(JSON.stringify({ clis, sync: syncRows, orphans: orphanRows }, null, 2));
+                console.log(JSON.stringify({
+                    clis,
+                    sync: syncRows,
+                    orphans: orphanRows,
+                    hostClis: {
+                        statuses: hostClis.statuses.map((s) => ({
+                            name: s.manifest.name,
+                            source: s.manifest.source,
+                            description: s.manifest.description ?? null,
+                            installed: s.installed,
+                        })),
+                        errors: hostClis.errors,
+                    },
+                }, null, 2));
                 return;
             }
-            renderOverviewText(clis, syncRows, orphanRows);
+            renderOverviewText(clis, syncRows, orphanRows, hostClis);
             return;
         }
         const parsed = parseTargetArg(target);

package/dist/commands/exec.js

@@ -36,8 +36,8 @@ export function registerRunCommand(program) {
         .option('--add-dir <dir>', 'Grant access to an additional directory outside the project (Claude only, repeatable)', (val, prev) => [...prev, val], [])
         .option('--json', 'Stream events as JSON lines (for parsing by other tools)')
         .option('--quiet', 'Suppress preamble (rotation banner, "Running:" line). Useful when piping JSON events to a parser.', false)
-        .option('--headless', 'Non-interactive mode (auto-enabled when prompt provided)', false)
-        .option('-i, --interactive', 'Force interactive mode even when a prompt is provided')
+        .option('--headless', 'Force headless mode. Auto-enabled when a prompt is provided; pass explicitly to stay headless with no prompt (reads the prompt from stdin).', false)
+        .option('-i, --interactive', 'Force interactive mode even when a prompt is provided. Mutually exclusive with --headless.')
         .option('--session-id <id>', 'Resume a previous conversation (Claude only)')
         .option('--verbose', 'Show detailed execution logs')
         .option('--timeout <duration>', 'Kill the agent after this duration (e.g., 30m, 1h, 2h30m)')
@@ -85,7 +85,7 @@ export function registerRunCommand(program) {
     `,
     });
     runCmd.action(async (agentSpec, prompt, options) => {
-        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, defaultModeFor }, { ALL_AGENT_IDS }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, RUN_STRATEGIES }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef }, { resolveRunDefaults },] = await Promise.all([
+        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, defaultModeFor, headlessPlanStallCommand }, { ALL_AGENT_IDS }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, RUN_STRATEGIES }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef }, { resolveRunDefaults },] = await Promise.all([
             import('../lib/exec.js'),
             import('../lib/agents.js'),
             import('../lib/profiles.js'),
@@ -306,6 +306,23 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
         }
+        // Fail fast on the headless-plan stall footgun: a slash command run
+        // headless under the implicit default 'plan' mode hangs forever at
+        // ExitPlanMode (no TTY to approve the plan). Tell the user how to fix it
+        // instead of leaving them staring at a frozen process. Explicit
+        // `--mode plan` is respected for genuine read-only command runs.
+        const stallCmd = headlessPlanStallCommand({
+            prompt,
+            interactive: options.interactive,
+            mode,
+            modeIsDefault,
+        });
+        if (stallCmd) {
+            console.error(chalk.red(`Refusing to run ${stallCmd} headless in read-only 'plan' mode — it would hang at ExitPlanMode (no TTY to approve the plan).`));
+            console.error(chalk.yellow(`Re-run with an explicit mode: --mode auto (recommended — auto-approves safe ops, blocks risky ones), --mode edit, or --mode full.`));
+            console.error(chalk.gray(`Pass --mode plan explicitly if you really want a read-only run.`));
+            process.exit(1);
+        }
         const effort = options.effort;
         if (!['low', 'medium', 'high', 'xhigh', 'max', 'auto'].includes(effort)) {
             console.error(chalk.red(`Invalid effort: ${effort}. Use 'low', 'medium', 'high', 'xhigh', 'max', or 'auto'`));
@@ -363,12 +380,16 @@ export function registerRunCommand(program) {
             model,
             addDirs: options.addDir,
             json: options.json,
-            headless: options.headless ?? true,
+            headless: options.headless,
             sessionId: options.sessionId,
             verbose: options.verbose,
             timeout: options.timeout,
             env,
         };
+        if (options.interactive && options.headless) {
+            console.error(chalk.red('--interactive and --headless are mutually exclusive. Pass one, or neither (mode is inferred from prompt presence).'));
+            process.exit(1);
+        }
         if (options.interactive) {
             if (options.fallback) {
                 console.error(chalk.red('--interactive is not compatible with --fallback. Fallback only works for headless prompt runs.'));

package/dist/commands/import.js

@@ -44,6 +44,11 @@ async function runImport(agentArg, opts) {
     // installer dropped it. We adopt by symlinking that PATH binary directly
     // into the version's `node_modules/.bin/`. No package.json walk.
     const isInstallScriptAgent = !agent.npmPackage;
+    // Whether to adopt the binary by a direct symlink (installScript style) vs.
+    // the npm package.json walk. Starts equal to isInstallScriptAgent, but an
+    // npm-capable agent that turns out to be installed as a standalone binary
+    // (see the resolvePackageDirFromBinary fallback below) flips this to true.
+    let useDirectBinaryImport = isInstallScriptAgent;
     let globalPath = null;
     let installScriptBinary = null;
     if (opts.fromPath) {
@@ -84,9 +89,15 @@ async function runImport(agentArg, opts) {
         else {
             globalPath = resolvePackageDirFromBinary(binary);
             if (!globalPath) {
-                console.error(chalk.red(`Could not resolve npm package for binary: ${binary}`));
-                console.error(chalk.gray('Pass --from-path <dir> with the package directory explicitly.'));
-                process.exit(1);
+                // npmPackage is declared, but the binary on PATH doesn't live inside an
+                // npm package layout — e.g. Kimi installed via its curl install.sh,
+                // which drops a standalone bundled binary at ~/.kimi-code/bin/kimi
+                // rather than into node_modules/<pkg>/. The binary is valid and
+                // self-contained, so adopt it the same way as an installScript agent:
+                // a direct symlink. Key the decision on the on-disk layout, not on
+                // whether an npmPackage label happens to exist.
+                installScriptBinary = binary;
+                useDirectBinaryImport = true;
             }
         }
     }
@@ -112,7 +123,7 @@ async function runImport(agentArg, opts) {
     }
     let version = opts.version;
     if (!version) {
-        if (!isInstallScriptAgent && globalPath) {
+        if (!useDirectBinaryImport && globalPath) {
             try {
                 const pkg = JSON.parse(fs.readFileSync(path.join(globalPath, 'package.json'), 'utf8'));
                 version = typeof pkg.version === 'string' ? pkg.version : undefined;
@@ -142,7 +153,7 @@ async function runImport(agentArg, opts) {
         process.exit(1);
     }
     const versionDir = getVersionDir(agentId, version);
-    const fromLabel = isInstallScriptAgent ? installScriptBinary : globalPath;
+    const fromLabel = useDirectBinaryImport ? installScriptBinary : globalPath;
     console.log(chalk.bold(`\nImport ${agentLabel(agentId)} v${version}`));
     console.log(`  from: ${chalk.gray(fromLabel)}`);
     console.log(`  into: ${chalk.gray(versionDir)}`);
@@ -197,7 +208,7 @@ async function runImport(agentArg, opts) {
         }
     }
     const binSpinner = ora(`Registering ${agentLabel(agentId)} v${version} binary...`).start();
-    const binResult = isInstallScriptAgent
+    const binResult = useDirectBinaryImport
         ? importInstallScriptBinary({ agentId, npmPackage: agent.npmPackage, cliCommand: agent.cliCommand }, version, installScriptBinary, versionDir)
         : importAgentBinary({ agentId, npmPackage: agent.npmPackage, cliCommand: agent.cliCommand }, version, globalPath, versionDir);
     if (binResult.success) {

package/dist/commands/inspect.d.ts

@@ -12,6 +12,9 @@
  * AGENT.md / the file itself) so users can click straight to the source.
  */
 import { Command } from 'commander';
+import type { ManifestHook } from '../lib/types.js';
+import { type McpYamlConfig } from '../lib/mcp.js';
+import { type PluginResourceGroup } from '../lib/plugins.js';
 /** Resource kinds the inspect command can drill into. */
 declare const DRILLABLE_KINDS: readonly ["commands", "skills", "hooks", "mcp", "rules", "plugins", "workflows", "subagents"];
 type DrillableKind = typeof DRILLABLE_KINDS[number];
@@ -24,8 +27,10 @@ interface ResourceItem {
     linkTarget: string;
     /** One-line description (frontmatter `description:` or first non-frontmatter line). */
     description: string;
-    /** Extra detail rows surfaced in detail mode (e.g. a plugin's bundled skills/commands). */
+    /** Scalar detail rows surfaced in detail mode (e.g. a plugin's version). */
     extra?: Array<[string, string]>;
+    /** For plugins: the resource categories (skills, commands, …) the bundle packages. */
+    groups?: PluginResourceGroup[];
 }
 interface InspectOptions {
     brief?: boolean;
@@ -38,6 +43,13 @@ interface InspectOptions {
     plugins?: boolean | string;
     workflows?: boolean | string;
     subagents?: boolean | string;
+    command?: string;
+    skill?: string;
+    hook?: string;
+    rule?: string;
+    plugin?: string;
+    workflow?: string;
+    subagent?: string;
 }
 export declare function registerInspectCommand(program: Command): void;
 export declare function inspectAction(target: string, options: InspectOptions): Promise<void>;
@@ -91,4 +103,19 @@ export interface RepoGitInfo {
     behind: number | null;
 }
 export declare function repoGitInfo(root: string): RepoGitInfo | null;
+/**
+ * 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 declare function summarizeHook(hook: ManifestHook): string;
+/** Compact one-liner for an MCP server: padded transport + the url (http) or command line (stdio). */
+export declare function summarizeMcp(cfg: McpYamlConfig): string;
+/**
+ * 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 declare function hookManifestByScript(manifest: Record<string, ManifestHook>): Map<string, ManifestHook>;
 export {};