@phnx-labs/agents-cli 1.14.3 → 1.14.4

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/browser.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerBrowserSubcommands } from './commands/browser.js';
+const program = new Command();
+program.name('browser').description('Browser automation via CDP');
+registerBrowserSubcommands(program);
+program.parse();

package/dist/commands/browser.d.ts

@@ -1,2 +1,3 @@
 import { Command } from 'commander';
 export declare function registerBrowserCommand(program: Command): void;
+export declare function registerBrowserSubcommands(program: Command): void;

package/dist/commands/browser.js

@@ -8,6 +8,10 @@ export function registerBrowserCommand(program) {
     registerProfilesCommands(browser);
     registerTaskCommands(browser);
 }
+export function registerBrowserSubcommands(program) {
+    registerProfilesCommands(program);
+    registerTaskCommands(program);
+}
 function registerProfilesCommands(browser) {
     const profiles = browser
         .command('profiles')

package/dist/commands/teams.js

@@ -679,12 +679,14 @@ Name teammates with --name alice to refer to them as 'alice' instead of a UUID.
         .description('Start a new team. No teammates yet; add them with `teams add`.')
         .option('-d, --description <text>', 'One-line summary of what this team is working on')
         .option('--enable-worktrees', 'Each teammate works in its own git worktree (requires --worktree on add)')
+        .option('--use-worktree <path>', 'All teammates share this existing worktree path (mutually exclusive with --enable-worktrees)')
         .option('--json', 'Output machine-readable JSON')
         .action(async (team, opts) => {
         try {
             const meta = await createTeam(team, {
                 description: opts.description,
                 enableWorktrees: opts.enableWorktrees,
+                useWorktree: opts.useWorktree,
             });
             if (isJsonMode(opts)) {
                 console.log(JSON.stringify({ team, ...meta }, null, 2));
@@ -694,7 +696,9 @@ Name teammates with --name alice to refer to them as 'alice' instead of a UUID.
             if (meta.description)
                 console.log(chalk.gray(`  ${meta.description}`));
             if (meta.enable_worktrees)
-                console.log(chalk.gray(`  worktrees: enabled`));
+                console.log(chalk.gray(`  worktrees: per-teammate`));
+            if (meta.use_worktree)
+                console.log(chalk.gray(`  worktree: ${meta.use_worktree}`));
             console.log();
             console.log(chalk.gray('Add your first teammate:'));
             if (meta.enable_worktrees) {
@@ -776,12 +780,30 @@ Name teammates with --name alice to refer to them as 'alice' instead of a UUID.
         }
         // Auto-create the team if it doesn't exist yet (friendlier UX than erroring).
         await ensureTeam(team);
-        // Check if team has worktrees enabled
+        // Check if team has worktrees enabled or a shared worktree
         const teamMeta = await getTeam(team);
         const worktreesEnabled = teamMeta?.enable_worktrees ?? false;
+        const sharedWorktree = teamMeta?.use_worktree ?? null;
         let worktreeName = null;
         let worktreePath = null;
-        if (worktreesEnabled) {
+        if (sharedWorktree) {
+            // Team uses a shared worktree for all teammates
+            const fsp = await import('fs/promises');
+            try {
+                const stat = await fsp.stat(sharedWorktree);
+                if (!stat.isDirectory()) {
+                    die(`Shared worktree path is not a directory: ${sharedWorktree}`);
+                }
+            }
+            catch {
+                die(`Shared worktree path does not exist: ${sharedWorktree}`);
+            }
+            worktreePath = sharedWorktree;
+            if (opts.worktree) {
+                die(`Team '${team}' uses --use-worktree (shared). Don't pass --worktree on add.`);
+            }
+        }
+        else if (worktreesEnabled) {
             if (!opts.worktree) {
                 die(`Team '${team}' has worktrees enabled. Use --worktree <name> to specify a worktree name.`);
             }

package/dist/commands/view.js

@@ -336,7 +336,7 @@ async function showInstalledVersions(filterAgentId) {
             const available = getAvailableResources();
             const synced = getActuallySyncedResources(filterAgentId, defaultVersion);
             const newResources = getNewResources(available, synced);
-            if (hasNewResources(newResources, filterAgentId)) {
+            if (hasNewResources(newResources, filterAgentId, defaultVersion)) {
                 try {
                     const selection = await promptNewResourceSelection(filterAgentId, newResources);
                     if (selection && Object.keys(selection).length > 0) {

package/dist/lib/migrate.js

@@ -152,6 +152,49 @@ function migrateUserVersionsToSystem() {
         console.log(`Skipped ${skippedCount} version dir${skippedCount === 1 ? '' : 's'} already present in ~/.agents-system/versions/ (kept legacy copy at ~/.agents/versions/)`);
     }
 }
+/**
+ * Move ~/. agents/runs/ -> ~/.agents/routines/runs/.
+ * Runs now live inside routines directory for cleaner organization.
+ */
+function migrateRunsIntoRoutines() {
+    const src = path.join(USER_DIR, 'runs');
+    const dest = path.join(USER_DIR, 'routines', 'runs');
+    if (!fs.existsSync(src) || fs.existsSync(dest))
+        return;
+    try {
+        fs.mkdirSync(path.dirname(dest), { recursive: true, mode: 0o700 });
+        fs.renameSync(src, dest);
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Move ~/.agents/trash/ -> ~/.agents/.trash/.
+ * Hide the trash directory.
+ */
+function migrateTrashToHidden() {
+    const src = path.join(USER_DIR, 'trash');
+    const dest = path.join(USER_DIR, '.trash');
+    if (!fs.existsSync(src) || fs.existsSync(dest))
+        return;
+    try {
+        fs.renameSync(src, dest);
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Move ~/.agents/backups/ -> ~/.agents/.backups/.
+ * Hide the backups directory.
+ */
+function migrateBackupsToHidden() {
+    const src = path.join(USER_DIR, 'backups');
+    const dest = path.join(USER_DIR, '.backups');
+    if (!fs.existsSync(src) || fs.existsSync(dest))
+        return;
+    try {
+        fs.renameSync(src, dest);
+    }
+    catch { /* best-effort */ }
+}
 /** Run all idempotent migrations. Safe to call multiple times. */
 export function runMigration() {
     migrateAgentsYaml();
@@ -159,4 +202,7 @@ export function runMigration() {
     migrateSystemConfigJson();
     migratePromptcutsIntoHooks();
     migrateUserVersionsToSystem();
+    migrateRunsIntoRoutines();
+    migrateTrashToHidden();
+    migrateBackupsToHidden();
 }

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

@@ -0,0 +1,46 @@
+/**
+ * Commands resource handler.
+ *
+ * Commands are slash-command definitions stored as .md files (Claude/Codex/Cursor/OpenCode)
+ * or .toml files (Gemini). This handler resolves commands across layers (project > user > system),
+ * handles format conversion during sync, and provides consistent list/resolve/sync behavior.
+ */
+import type { AgentId, ResolvedItem, ResourceHandler, ResourceKind } from './types.js';
+/** Command item metadata. */
+export interface CommandItem {
+    name: string;
+    description: string;
+    content: string;
+    format: 'md' | 'toml';
+}
+/**
+ * Commands resource handler implementing ResourceHandler<CommandItem>.
+ */
+export declare class CommandsHandler implements ResourceHandler<CommandItem> {
+    readonly kind: ResourceKind;
+    /**
+     * List all commands across layers, with higher layer winning on name conflict.
+     * Returns a union of all commands, deduplicated by name.
+     */
+    listAll(agent: AgentId, cwd?: string): ResolvedItem<CommandItem>[];
+    /**
+     * Resolve a single command by name.
+     * Returns the winning layer's version, or null if not found.
+     */
+    resolve(agent: AgentId, name: string, cwd?: string): ResolvedItem<CommandItem> | null;
+    /**
+     * Sync resolved commands to the agent's version home directory.
+     * Copies/transforms commands as needed for the agent's expected format.
+     */
+    sync(agent: AgentId, versionHome: string, cwd?: string): void;
+    /**
+     * Get the file format this resource uses for a given agent.
+     */
+    format(agent: AgentId): 'md' | 'toml';
+    /**
+     * Get the target directory name in the agent's version home.
+     */
+    targetDir(agent: AgentId): string;
+}
+/** Singleton instance of the commands handler. */
+export declare const commandsHandler: CommandsHandler;

package/dist/lib/resources/commands.js

@@ -0,0 +1,208 @@
+/**
+ * Commands resource handler.
+ *
+ * Commands are slash-command definitions stored as .md files (Claude/Codex/Cursor/OpenCode)
+ * or .toml files (Gemini). This handler resolves commands across layers (project > user > system),
+ * handles format conversion during sync, and provides consistent list/resolve/sync behavior.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getProjectAgentsDir, getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos, } from '../state.js';
+import { AGENTS } from '../agents.js';
+import { markdownToToml } from '../convert.js';
+/**
+ * Get the commands directory for a given layer root.
+ */
+function getCommandsDirForRoot(root) {
+    return path.join(root, 'commands');
+}
+/**
+ * Parse a command file and extract metadata.
+ */
+function parseCommandFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const format = filePath.endsWith('.toml') ? 'toml' : 'md';
+        const name = path.basename(filePath).replace(/\.(md|toml)$/, '');
+        let description = '';
+        if (format === 'md') {
+            // Parse YAML frontmatter for description
+            const lines = content.split('\n');
+            if (lines[0] === '---') {
+                const endIndex = lines.slice(1).findIndex((l) => l === '---');
+                if (endIndex > 0) {
+                    const frontmatter = lines.slice(1, endIndex + 1).join('\n');
+                    const descMatch = frontmatter.match(/description:\s*(.+)/i);
+                    if (descMatch)
+                        description = descMatch[1].trim();
+                }
+            }
+        }
+        else {
+            // Parse TOML for description
+            const descMatch = content.match(/description\s*=\s*"([^"]+)"/);
+            if (descMatch)
+                description = descMatch[1];
+        }
+        return { name, description, content, format };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List command files in a directory.
+ */
+function listCommandsInDir(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const commands = [];
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                if (entry.name.endsWith('.md')) {
+                    commands.push({
+                        name: entry.name.replace('.md', ''),
+                        path: path.join(dir, entry.name),
+                        format: 'md',
+                    });
+                }
+                else if (entry.name.endsWith('.toml')) {
+                    commands.push({
+                        name: entry.name.replace('.toml', ''),
+                        path: path.join(dir, entry.name),
+                        format: 'toml',
+                    });
+                }
+            }
+        }
+        return commands;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Commands resource handler implementing ResourceHandler<CommandItem>.
+ */
+export class CommandsHandler {
+    kind = 'command';
+    /**
+     * List all commands across layers, with higher layer winning on name conflict.
+     * Returns a union of all commands, deduplicated by name.
+     */
+    listAll(agent, cwd) {
+        const seen = new Set();
+        const results = [];
+        const projectDir = getProjectAgentsDir(cwd);
+        const extraRepos = getEnabledExtraRepos();
+        // Build layer roots in precedence order: project > user > system > extras
+        const roots = [];
+        if (projectDir) {
+            roots.push({ dir: getCommandsDirForRoot(projectDir), layer: 'project' });
+        }
+        roots.push({ dir: getCommandsDirForRoot(getUserAgentsDir()), layer: 'user' });
+        roots.push({ dir: getCommandsDirForRoot(getSystemAgentsDir()), layer: 'system' });
+        for (const extra of extraRepos) {
+            roots.push({ dir: getCommandsDirForRoot(extra.dir), layer: 'system' });
+        }
+        for (const { dir, layer } of roots) {
+            const commands = listCommandsInDir(dir);
+            for (const cmd of commands) {
+                if (seen.has(cmd.name))
+                    continue;
+                seen.add(cmd.name);
+                const item = parseCommandFile(cmd.path);
+                if (item) {
+                    results.push({
+                        name: cmd.name,
+                        item,
+                        layer,
+                        path: cmd.path,
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Resolve a single command by name.
+     * Returns the winning layer's version, or null if not found.
+     */
+    resolve(agent, name, cwd) {
+        const projectDir = getProjectAgentsDir(cwd);
+        const extraRepos = getEnabledExtraRepos();
+        // Build candidate paths in precedence order
+        const candidates = [];
+        if (projectDir) {
+            candidates.push({ dir: getCommandsDirForRoot(projectDir), layer: 'project' });
+        }
+        candidates.push({ dir: getCommandsDirForRoot(getUserAgentsDir()), layer: 'user' });
+        candidates.push({ dir: getCommandsDirForRoot(getSystemAgentsDir()), layer: 'system' });
+        for (const extra of extraRepos) {
+            candidates.push({ dir: getCommandsDirForRoot(extra.dir), layer: 'system' });
+        }
+        for (const { dir, layer } of candidates) {
+            // Try .md first, then .toml
+            for (const ext of ['.md', '.toml']) {
+                const filePath = path.join(dir, `${name}${ext}`);
+                const item = parseCommandFile(filePath);
+                if (item) {
+                    return { name, item, layer, path: filePath };
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Sync resolved commands to the agent's version home directory.
+     * Copies/transforms commands as needed for the agent's expected format.
+     */
+    sync(agent, versionHome, cwd) {
+        const agentConfig = AGENTS[agent];
+        const targetFormat = this.format(agent);
+        const targetDir = path.join(versionHome, `.${agent}`, this.targetDir(agent));
+        // Ensure target directory exists
+        fs.mkdirSync(targetDir, { recursive: true });
+        // Get all resolved commands
+        const commands = this.listAll(agent, cwd);
+        for (const resolved of commands) {
+            const ext = targetFormat === 'toml' ? '.toml' : '.md';
+            const targetPath = path.join(targetDir, `${resolved.name}${ext}`);
+            // Convert format if needed
+            if (targetFormat === 'toml' && resolved.item.format === 'md') {
+                // Convert markdown to TOML
+                const tomlContent = markdownToToml(resolved.name, resolved.item.content);
+                fs.writeFileSync(targetPath, tomlContent, 'utf-8');
+            }
+            else if (targetFormat === 'md' && resolved.item.format === 'toml') {
+                // For now, copy TOML as-is if target expects md (edge case)
+                // In practice, source commands are always .md
+                fs.copyFileSync(resolved.path, targetPath);
+            }
+            else {
+                // Same format, copy directly
+                fs.copyFileSync(resolved.path, targetPath);
+            }
+        }
+    }
+    /**
+     * Get the file format this resource uses for a given agent.
+     */
+    format(agent) {
+        const agentConfig = AGENTS[agent];
+        return agentConfig.format === 'toml' ? 'toml' : 'md';
+    }
+    /**
+     * Get the target directory name in the agent's version home.
+     */
+    targetDir(agent) {
+        const agentConfig = AGENTS[agent];
+        return agentConfig.commandsSubdir || 'commands';
+    }
+}
+/** Singleton instance of the commands handler. */
+export const commandsHandler = new CommandsHandler();

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

@@ -0,0 +1,12 @@
+/**
+ * HooksHandler - ResourceHandler implementation for hooks.
+ *
+ * Hooks are declared in hooks.yaml at each layer (system, user, project).
+ * Resolution: project > user > system (higher layer wins on name conflict).
+ * Non-conflicting hooks from all layers are unioned together.
+ */
+import type { ResourceHandler } from './types.js';
+import type { ManifestHook } from '../types.js';
+export type HookItem = ManifestHook;
+export declare const HooksHandler: ResourceHandler<HookItem>;
+export default HooksHandler;

package/dist/lib/resources/hooks.js

@@ -0,0 +1,136 @@
+/**
+ * HooksHandler - ResourceHandler implementation for hooks.
+ *
+ * Hooks are declared in hooks.yaml at each layer (system, user, project).
+ * Resolution: project > user > system (higher layer wins on name conflict).
+ * Non-conflicting hooks from all layers are unioned together.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { getSystemAgentsDir, getUserAgentsDir, getProjectAgentsDir, } from '../state.js';
+/**
+ * Get the hooks.yaml path for a given layer directory.
+ */
+function getHooksYamlPath(layerDir) {
+    return path.join(layerDir, 'hooks.yaml');
+}
+/**
+ * Parse hooks.yaml from a directory.
+ * Returns empty object if file doesn't exist or is invalid.
+ */
+function parseHooksYaml(dir) {
+    const manifestPath = getHooksYamlPath(dir);
+    if (!fs.existsSync(manifestPath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(manifestPath, 'utf-8');
+        const parsed = yaml.parse(content);
+        return parsed || {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Get layer directories for hook resolution.
+ */
+function getLayerDirs(cwd) {
+    return {
+        system: getSystemAgentsDir(),
+        user: getUserAgentsDir(),
+        project: cwd ? getProjectAgentsDir(cwd) : null,
+        extra: [],
+    };
+}
+export const HooksHandler = {
+    kind: 'hook',
+    /**
+     * List all hooks across layers, with higher layer winning on name conflict.
+     * Returns a union of all hooks, deduplicated by name.
+     */
+    listAll(agent, cwd) {
+        const layers = getLayerDirs(cwd);
+        const result = new Map();
+        // Process in precedence order: system first (lowest), then user, then project (highest)
+        const layerOrder = [
+            { layer: 'system', dir: layers.system },
+            { layer: 'user', dir: layers.user },
+            { layer: 'project', dir: layers.project },
+        ];
+        for (const { layer, dir } of layerOrder) {
+            if (!dir)
+                continue;
+            const hooks = parseHooksYaml(dir);
+            for (const [name, hook] of Object.entries(hooks)) {
+                // Skip disabled hooks
+                if (hook.enabled === false) {
+                    result.delete(name);
+                    continue;
+                }
+                result.set(name, {
+                    name,
+                    item: hook,
+                    layer,
+                    path: getHooksYamlPath(dir),
+                });
+            }
+        }
+        return Array.from(result.values()).sort((a, b) => a.name.localeCompare(b.name));
+    },
+    /**
+     * Resolve a single hook by name.
+     * Returns the winning layer's version, or null if not found.
+     */
+    resolve(agent, name, cwd) {
+        const layers = getLayerDirs(cwd);
+        // Check in reverse precedence order: project first (highest), then user, then system
+        const layerOrder = [
+            { layer: 'project', dir: layers.project },
+            { layer: 'user', dir: layers.user },
+            { layer: 'system', dir: layers.system },
+        ];
+        for (const { layer, dir } of layerOrder) {
+            if (!dir)
+                continue;
+            const hooks = parseHooksYaml(dir);
+            const hook = hooks[name];
+            if (hook) {
+                // If this layer disables the hook, return null (disabled trumps lower layers)
+                if (hook.enabled === false) {
+                    return null;
+                }
+                return {
+                    name,
+                    item: hook,
+                    layer,
+                    path: getHooksYamlPath(dir),
+                };
+            }
+        }
+        return null;
+    },
+    /**
+     * Sync resolved hooks to the agent's version home directory.
+     * Note: Actual hook registration is handled by registerHooksToSettings in hooks.ts.
+     * This method is a no-op placeholder for the interface contract.
+     */
+    sync(_agent, _versionHome, _cwd) {
+        // Hook syncing is done via registerHooksToSettings in the main hooks.ts module.
+        // This handler only provides resolution; registration is a separate concern.
+    },
+    /**
+     * Hooks use YAML format across all agents.
+     */
+    format(_agent) {
+        return 'yaml';
+    },
+    /**
+     * Hooks are stored in the hooks directory.
+     */
+    targetDir(_agent) {
+        return 'hooks';
+    },
+};
+export default HooksHandler;

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

@@ -0,0 +1,36 @@
+/**
+ * Unified resource system - exports all handlers and provides a registry.
+ *
+ * Usage:
+ *   import { handlers, getHandler } from './resources/index.js';
+ *   const cmds = handlers.commands.listAll('claude');
+ */
+export * from './types.js';
+export { CommandsHandler, commandsHandler, type CommandItem } from './commands.js';
+export { HooksHandler, type HookItem } from './hooks.js';
+export { SkillsHandler, type SkillItem } from './skills.js';
+export { RulesHandler, type RuleItem } from './rules.js';
+export { McpHandler, getMcpConfigPath, type McpItem } from './mcp.js';
+export { PermissionsHandler, type PermissionItem } from './permissions.js';
+export { SubagentsHandler, subagentsHandler, type SubagentItem } from './subagents.js';
+import type { ResourceKind, ResourceHandler } from './types.js';
+/** All resource handlers keyed by kind. */
+export declare const handlers: {
+    readonly command: import("./commands.js").CommandsHandler;
+    readonly commands: import("./commands.js").CommandsHandler;
+    readonly hook: ResourceHandler<import("../types.js").ManifestHook>;
+    readonly hooks: ResourceHandler<import("../types.js").ManifestHook>;
+    readonly skill: ResourceHandler<import("./skills.js").SkillItem>;
+    readonly skills: ResourceHandler<import("./skills.js").SkillItem>;
+    readonly rule: ResourceHandler<import("./rules.js").RuleItem>;
+    readonly rules: ResourceHandler<import("./rules.js").RuleItem>;
+    readonly mcp: ResourceHandler<import("./mcp.js").McpItem>;
+    readonly permission: ResourceHandler<import("../types.js").PermissionSet>;
+    readonly permissions: ResourceHandler<import("../types.js").PermissionSet>;
+    readonly subagent: import("./subagents.js").SubagentsHandler;
+    readonly subagents: import("./subagents.js").SubagentsHandler;
+};
+/** Get a handler by resource kind. */
+export declare function getHandler(kind: ResourceKind): ResourceHandler<unknown> | null;
+/** All resource kinds. */
+export declare const RESOURCE_KINDS: ResourceKind[];

package/dist/lib/resources/index.js

@@ -0,0 +1,69 @@
+/**
+ * Unified resource system - exports all handlers and provides a registry.
+ *
+ * Usage:
+ *   import { handlers, getHandler } from './resources/index.js';
+ *   const cmds = handlers.commands.listAll('claude');
+ */
+export * from './types.js';
+export { CommandsHandler, commandsHandler } from './commands.js';
+export { HooksHandler } from './hooks.js';
+export { SkillsHandler } from './skills.js';
+export { RulesHandler } from './rules.js';
+export { McpHandler, getMcpConfigPath } from './mcp.js';
+export { PermissionsHandler } from './permissions.js';
+export { SubagentsHandler, subagentsHandler } from './subagents.js';
+import { commandsHandler } from './commands.js';
+import { HooksHandler } from './hooks.js';
+import { SkillsHandler } from './skills.js';
+import { RulesHandler } from './rules.js';
+import { McpHandler } from './mcp.js';
+import { PermissionsHandler } from './permissions.js';
+import { subagentsHandler } from './subagents.js';
+/** All resource handlers keyed by kind. */
+export const handlers = {
+    command: commandsHandler,
+    commands: commandsHandler,
+    hook: HooksHandler,
+    hooks: HooksHandler,
+    skill: SkillsHandler,
+    skills: SkillsHandler,
+    rule: RulesHandler,
+    rules: RulesHandler,
+    mcp: McpHandler,
+    permission: PermissionsHandler,
+    permissions: PermissionsHandler,
+    subagent: subagentsHandler,
+    subagents: subagentsHandler,
+};
+/** Get a handler by resource kind. */
+export function getHandler(kind) {
+    switch (kind) {
+        case 'command':
+            return commandsHandler;
+        case 'hook':
+            return HooksHandler;
+        case 'skill':
+            return SkillsHandler;
+        case 'rule':
+            return RulesHandler;
+        case 'mcp':
+            return McpHandler;
+        case 'permission':
+            return PermissionsHandler;
+        case 'subagent':
+            return subagentsHandler;
+        default:
+            return null;
+    }
+}
+/** All resource kinds. */
+export const RESOURCE_KINDS = [
+    'command',
+    'hook',
+    'skill',
+    'rule',
+    'mcp',
+    'permission',
+    'subagent',
+];