@phnx-labs/agents-cli 1.14.2 → 1.14.4

package/dist/lib/migrate.js

@@ -76,10 +76,133 @@ function migratePromptcutsIntoHooks() {
         catch { /* best-effort */ }
     }
 }
+/**
+ * Move installed agent versions from the legacy single-root layout
+ * (~/.agents/versions/<agent>/<ver>/) into the system root
+ * (~/.agents-system/versions/<agent>/<ver>/).
+ *
+ * Pre-split installs put binaries and home dirs under ~/.agents/. After the
+ * split, the system code only scans ~/.agents-system/versions/, so without
+ * this migration the versions become invisible to listInstalledVersions and
+ * every command that depends on it (view, prune, run).
+ *
+ * Idempotent and non-destructive: if a same-named dest already exists we
+ * leave the legacy copy in place so the user can reconcile manually.
+ */
+function migrateUserVersionsToSystem() {
+    const userVersions = path.join(USER_DIR, 'versions');
+    const sysVersions = path.join(SYSTEM_DIR, 'versions');
+    if (!fs.existsSync(userVersions))
+        return;
+    let movedCount = 0;
+    let skippedCount = 0;
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(userVersions, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const agent of agentEntries) {
+        if (!agent.isDirectory())
+            continue;
+        const srcAgentDir = path.join(userVersions, agent.name);
+        const dstAgentDir = path.join(sysVersions, agent.name);
+        try {
+            fs.mkdirSync(dstAgentDir, { recursive: true, mode: 0o700 });
+        }
+        catch { /* best-effort */ }
+        let verEntries;
+        try {
+            verEntries = fs.readdirSync(srcAgentDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const ver of verEntries) {
+            if (!ver.isDirectory())
+                continue;
+            const src = path.join(srcAgentDir, ver.name);
+            const dst = path.join(dstAgentDir, ver.name);
+            if (fs.existsSync(dst)) {
+                skippedCount++;
+                continue;
+            }
+            try {
+                fs.renameSync(src, dst);
+                movedCount++;
+            }
+            catch { /* best-effort, leave legacy in place */ }
+        }
+        try {
+            if (fs.readdirSync(srcAgentDir).length === 0)
+                fs.rmdirSync(srcAgentDir);
+        }
+        catch { /* best-effort */ }
+    }
+    try {
+        if (fs.readdirSync(userVersions).length === 0)
+            fs.rmdirSync(userVersions);
+    }
+    catch { /* best-effort */ }
+    if (movedCount > 0) {
+        console.log(`Migrated ${movedCount} version dir${movedCount === 1 ? '' : 's'} from ~/.agents/versions/ to ~/.agents-system/versions/`);
+    }
+    if (skippedCount > 0) {
+        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();
     deleteSystemPromptsJson();
     migrateSystemConfigJson();
     migratePromptcutsIntoHooks();
+    migrateUserVersionsToSystem();
+    migrateRunsIntoRoutines();
+    migrateTrashToHidden();
+    migrateBackupsToHidden();
 }

package/dist/lib/pty-client.js

@@ -9,7 +9,7 @@ import * as fs from 'fs';
 import { spawn, execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import * as path from 'path';
-import { getSocketPath, isPtyServerRunning } from './pty-server.js';
+import { getSocketPath, getPtyLogPath, isPtyServerRunning } from './pty-server.js';
 const CONNECT_TIMEOUT_MS = 5000;
 const RESPONSE_TIMEOUT_MS = 30000;
 /**
@@ -33,7 +33,7 @@ async function ensureServer() {
         return;
     // Find the entry point to spawn the server
     const { bin, args } = getServerSpawnArgs();
-    const logPath = path.join(path.dirname(getSocketPath()), 'pty.log');
+    const logPath = getPtyLogPath();
     const logFd = fs.openSync(logPath, 'a');
     const child = spawn(bin, args, {
         stdio: ['ignore', logFd, logFd],
@@ -57,7 +57,7 @@ async function ensureServer() {
         }
         await new Promise(r => setTimeout(r, 100));
     }
-    throw new Error('PTY server failed to start within 5 seconds. Check ~/.agents/pty.log');
+    throw new Error('PTY server failed to start within 5 seconds. Check ~/.agents-system/helpers/pty/logs.jsonl');
 }
 function getServerSpawnArgs() {
     // Prefer the dist/index.js from the same installation as this code.

package/dist/lib/pty-server.js

@@ -53,9 +53,12 @@ export function captureProcessStartTime(pid) {
 }
 // --- Constants ---
 const SENTINEL = '__AGENTS_PTY_DONE__';
+const PTY_DIR = 'helpers/pty';
 const SOCKET_NAME = 'pty.sock';
 const PID_FILE = 'pty.pid';
-const LOG_FILE = 'pty.log';
+const LOG_FILE = 'logs.jsonl';
+const LOG_MAX_SIZE = 5 * 1024 * 1024; // 5 MB
+const LOG_ROTATE_COUNT = 3;
 const SESSION_IDLE_MS = 30 * 60 * 1000; // 30 min
 const SERVER_IDLE_MS = 60 * 60 * 1000; // 1 hour
 // --- Path helpers ---
@@ -79,17 +82,24 @@ function buildPtyEnv() {
     }
     return env;
 }
+/** Get the PTY helper directory, creating it if needed. */
+function getPtyDir() {
+    const dir = path.join(getAgentsDir(), PTY_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
 /** Get the unix socket path for the PTY server. */
 export function getSocketPath() {
-    return path.join(getAgentsDir(), SOCKET_NAME);
+    return path.join(getPtyDir(), SOCKET_NAME);
 }
 /** Get the path to the PTY server PID file. */
 export function getPtyPidPath() {
-    return path.join(getAgentsDir(), PID_FILE);
+    return path.join(getPtyDir(), PID_FILE);
 }
 /** Get the path to the PTY server log file. */
 export function getPtyLogPath() {
-    return path.join(getAgentsDir(), LOG_FILE);
+    const logDir = getPtyDir();
+    return path.join(logDir, LOG_FILE);
 }
 /** Check if the PTY server process is alive by probing the stored PID. */
 export function isPtyServerRunning() {
@@ -112,11 +122,30 @@ export function isPtyServerRunning() {
     }
 }
 // --- Logging ---
+function rotateLogsIfNeeded(logPath) {
+    try {
+        const stat = fs.statSync(logPath);
+        if (stat.size < LOG_MAX_SIZE)
+            return;
+        for (let i = LOG_ROTATE_COUNT - 1; i >= 1; i--) {
+            const older = `${logPath}.${i}`;
+            const newer = i === 1 ? logPath : `${logPath}.${i - 1}`;
+            if (fs.existsSync(newer)) {
+                fs.renameSync(newer, older);
+            }
+        }
+        if (fs.existsSync(logPath)) {
+            fs.renameSync(logPath, `${logPath}.1`);
+        }
+    }
+    catch { }
+}
 function log(level, message) {
-    const ts = new Date().toISOString();
-    const line = `[${ts}] [${level}] ${message}\n`;
+    const logPath = getPtyLogPath();
+    rotateLogsIfNeeded(logPath);
+    const entry = { ts: new Date().toISOString(), level, message };
     try {
-        fs.appendFileSync(getPtyLogPath(), line, 'utf-8');
+        fs.appendFileSync(logPath, JSON.stringify(entry) + '\n', 'utf-8');
     }
     catch { }
 }

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[];