agent-switchboard 0.1.26 → 0.1.28

package/dist/index.js

@@ -14,13 +14,16 @@ import { getAgentById } from './agents/registry.js';
 import { distributeCommands } from './commands/distribution.js';
 import { importCommandFromFile } from './commands/importer.js';
 import { buildCommandInventory } from './commands/inventory.js';
-import { resolveAgentSectionConfig } from './config/agent-config.js';
+import { resolveApplicationSectionConfig } from './config/application-config.js';
 import { loadMcpConfig, stripLegacyEnabledFlagsFromMcpJson } from './config/mcp-config.js';
-import { getAgentsHome, getClaudeDir, getCodexDir, getCommandsDir, getCursorDir, getGeminiDir, getOpencodePath, getSkillsDir, getSubagentsDir, } from './config/paths.js';
+import { getAgentsDir, getAgentsHome, getClaudeDir, getCodexDir, getCommandsDir, getCursorDir, getGeminiDir, getHooksDir, getOpencodePath, getSkillsDir, getSourceCacheDir, } from './config/paths.js';
 import { loadSwitchboardConfig, loadSwitchboardConfigWithLayers, } from './config/switchboard-config.js';
+import { distributeHooks } from './hooks/distribution.js';
+import { loadHookLibrary } from './hooks/library.js';
 import { ensureLibraryDirectories, writeFileSecure } from './library/fs.js';
-import { loadMcpActiveState, saveMcpActiveState } from './library/state.js';
-import { addSubscription, getSubscriptions, removeSubscription, validateSubscriptionPath, } from './library/subscriptions.js';
+import { addLocalSource, addRemoteSource, getSources, inferSourceName, isGitUrl, parseGitUrl, removeSource, updateRemoteSources, validateSourcePath, } from './library/sources.js';
+import { loadLibraryStateSection, loadMcpActiveState, saveMcpActiveState, } from './library/state.js';
+import { readMarketplace } from './marketplace/reader.js';
 import { RULE_SUPPORTED_AGENTS } from './rules/agents.js';
 import { composeActiveRules } from './rules/composer.js';
 import { distributeRules, listIndirectAgents, listPerFileAgents, listUnsupportedAgents, } from './rules/distribution.js';
@@ -34,17 +37,18 @@ import { distributeSubagents } from './subagents/distribution.js';
 import { importSubagentFromFile } from './subagents/importer.js';
 import { buildSubagentInventory } from './subagents/inventory.js';
 import { showCommandSelector } from './ui/command-ui.js';
+import { showHookSelector } from './ui/hook-ui.js';
 import { showMcpServerUI } from './ui/mcp-ui.js';
 import { showRuleSelector } from './ui/rule-ui.js';
 import { showSkillSelector } from './ui/skill-ui.js';
 import { showSubagentSelector } from './ui/subagent-ui.js';
-import { printActiveSelection, printAgentSyncStatus, printDistributionResults, printTable, } from './util/cli.js';
+import { printActiveSelection, printAgentSyncStatus, printCompactDistributions, printDistributionResults, printTable, shortenPath, } from './util/cli.js';
 const program = new Command();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf-8'));
 program
     .name('asb')
-    .description('Manage MCP servers, rules, commands, subagents, and skills across AI coding agents')
+    .description('Manage MCP servers, rules, commands, agents, skills, and hooks across AI coding agents')
     .version(packageJson.version)
     .addHelpText('after', `
 Examples:
@@ -55,110 +59,202 @@ Examples:
 
 Alias: agent-switchboard
 Config: ~/.agent-switchboard/config.toml`);
-// Initialize library directories for commands/subagents (secure permissions)
+// Initialize library directories for commands/agents (secure permissions)
 ensureLibraryDirectories();
 program
     .command('sync')
-    .description('Synchronize active MCP servers, rules, commands, subagents, and skills to agent targets')
+    .description('Synchronize active MCP servers, rules, commands, agents, and skills to application targets')
     .option('-p, --profile <name>', 'Profile configuration to use')
     .option('--project <path>', 'Project directory containing .asb.toml')
+    .option('--no-update', 'Skip updating remote sources')
     .action(async (options) => {
     try {
         const scope = resolveScope(options);
         const loadOptions = scopeToLoadOptions(scope);
         const { config, layers } = loadSwitchboardConfigWithLayers(loadOptions);
+        console.log(chalk.yellow('⚠ Sync overwrites agent config without diff.'));
         console.log();
-        console.log(`${chalk.bgRed.white(' WARNING ')} ${chalk.red('`asb sync` overwrites target files without diff checks.')}`);
-        console.log(chalk.red('Proceeding with synchronization...'));
-        console.log();
-        console.log(chalk.blue('Configuration layers:'));
-        const layerEntries = [
-            { label: 'User', exists: layers.user.exists, path: layers.user.path },
-            {
-                label: 'Profile',
-                exists: layers.profile?.exists === true,
-                path: layers.profile?.path ?? '(none)',
-            },
-            {
-                label: 'Project',
-                exists: layers.project?.exists === true,
-                path: layers.project?.path ?? '(none)',
-            },
-        ];
-        for (const entry of layerEntries) {
-            const marker = entry.exists ? chalk.green('✓') : chalk.gray('•');
-            const pathLabel = entry.exists ? chalk.dim(entry.path) : chalk.gray(entry.path);
-            console.log(`  ${marker} ${entry.label}: ${pathLabel}`);
+        if (options.update !== false) {
+            const remoteResults = updateRemoteSources();
+            if (remoteResults.length > 0) {
+                console.log(chalk.blue('Sources:'));
+                for (const result of remoteResults) {
+                    if (result.status === 'updated') {
+                        console.log(`  ${chalk.green('✓')} ${chalk.cyan(result.namespace)} ${chalk.dim(result.url)}`);
+                    }
+                    else {
+                        console.log(`  ${chalk.yellow('⚠')} ${chalk.cyan(result.namespace)} ${chalk.yellow(result.error ?? 'update failed')}`);
+                    }
+                }
+            }
         }
+        // Config summary: show active layers on one line
+        const activeLayers = [];
+        if (layers.user.exists)
+            activeLayers.push(shortenPath(layers.user.path));
+        if (layers.profile?.exists)
+            activeLayers.push(shortenPath(layers.profile.path));
+        if (layers.project?.exists)
+            activeLayers.push(shortenPath(layers.project.path));
+        console.log(`${chalk.blue('Config:')} ${activeLayers.length > 0 ? chalk.dim(activeLayers.join(' + ')) : chalk.gray('no config files')}`);
+        const appsLabel = config.applications.active.length > 0
+            ? chalk.cyan(config.applications.active.join(', '))
+            : chalk.gray('none configured');
+        console.log(`${chalk.blue('Apps:')}   ${appsLabel}`);
         console.log();
-        console.log(chalk.blue('Active selections:'));
-        console.log(`  MCP servers: ${chalk.cyan(String(config.mcp.active.length))}`);
-        console.log(`  Rules: ${chalk.cyan(String(config.rules.active.length))}`);
-        console.log(`  Commands: ${chalk.cyan(String(config.commands.active.length))}`);
-        console.log(`  Subagents: ${chalk.cyan(String(config.subagents.active.length))}`);
-        console.log(`  Skills: ${chalk.cyan(String(config.skills.active.length))}`);
-        if (config.agents.active.length > 0) {
-            console.log(`  Agents: ${chalk.cyan(config.agents.active.join(', '))}`);
+        const cursorSkillsDeduped = config.applications.active.includes('claude-code') &&
+            resolveApplicationSectionConfig('skills', 'claude-code', scope).active.length > 0;
+        console.log(chalk.blue('Inventory:'));
+        {
+            const sections = ['mcp', 'rules', 'commands', 'agents', 'skills', 'hooks'];
+            // Keep in sync with platform lists in each distribution module
+            const sectionPlatforms = {
+                mcp: ['claude-code', 'claude-desktop', 'codex', 'cursor', 'gemini', 'opencode'],
+                rules: ['claude-code', 'codex', 'cursor', 'gemini', 'opencode'],
+                commands: ['claude-code', 'codex', 'cursor', 'gemini', 'opencode'],
+                agents: ['claude-code', 'opencode', 'cursor'],
+                skills: cursorSkillsDeduped
+                    ? ['claude-code', 'codex', 'gemini', 'opencode']
+                    : ['claude-code', 'codex', 'gemini', 'opencode', 'cursor'],
+                hooks: ['claude-code'],
+            };
+            const termWidth = process.stdout.columns || 80;
+            const maxSectionLen = Math.max(...sections.map((s) => s.length));
+            const maxCountLen = Math.max(...sections.map((s) => `(${config[s].active.length})`.length));
+            const prefixPlainLen = 2 + maxSectionLen + 1 + maxCountLen + 2;
+            const fitPreview = (ids, maxWidth) => {
+                if (ids.length === 0)
+                    return chalk.gray('none');
+                const full = ids.join(', ');
+                if (full.length <= maxWidth)
+                    return full;
+                let text = '';
+                let shown = 0;
+                for (let i = 0; i < ids.length; i++) {
+                    const sep = shown > 0 ? ', ' : '';
+                    const candidate = text + sep + ids[i];
+                    const remaining = ids.length - (i + 1);
+                    if (remaining > 0) {
+                        const suffix = `, ... (+${remaining} more)`;
+                        if (candidate.length + suffix.length > maxWidth && shown > 0) {
+                            const left = ids.length - shown;
+                            return `${text}${chalk.gray(`, ... (+${left} more)`)}`;
+                        }
+                    }
+                    text = candidate;
+                    shown++;
+                }
+                return text;
+            };
+            for (const section of sections) {
+                const globalActive = config[section].active;
+                const globalCount = globalActive.length;
+                const supported = new Set(sectionPlatforms[section] ?? []);
+                const applicableApps = config.applications.active.filter((id) => supported.has(id));
+                const effectiveByApp = new Map();
+                for (const appId of applicableApps) {
+                    effectiveByApp.set(appId, resolveApplicationSectionConfig(section, appId, scope).active);
+                }
+                const perAppParts = applicableApps.map((appId) => {
+                    const eff = effectiveByApp.get(appId) ?? [];
+                    const delta = eff.length - globalCount;
+                    const d = delta === 0 ? '' : delta > 0 ? `(+${delta})` : `(${delta})`;
+                    return `${appId}:${eff.length}${d}`;
+                });
+                const union = new Set();
+                for (const [, ids] of effectiveByApp) {
+                    for (const id of ids)
+                        union.add(id);
+                }
+                const previewIds = globalActive.length > 0 ? [...globalActive] : [...union];
+                const paddedSection = section.padEnd(maxSectionLen);
+                const countStr = `(${globalCount})`.padStart(maxCountLen);
+                const appsStr = perAppParts.join('  ');
+                console.log(`  ${chalk.cyan(paddedSection)} ${chalk.gray(countStr)}  ${appsStr}`);
+                if (previewIds.length > 0) {
+                    const indent = ' '.repeat(prefixPlainLen);
+                    const previewWidth = Math.max(20, termWidth - prefixPlainLen - 2);
+                    const preview = fitPreview(previewIds, previewWidth);
+                    console.log(`${indent}${chalk.gray('→')} ${preview}`);
+                }
+            }
         }
-        else {
-            console.log(`  Agents: ${chalk.gray('none configured')}`);
+        console.log();
+        const notes = ['rules, skills also distribute to gemini'];
+        if (cursorSkillsDeduped)
+            notes.push('cursor reads skills via claude-code');
+        for (let i = 0; i < notes.length; i++) {
+            const prefix = i === 0 ? '  Note: ' : '        ';
+            const suffix = i === notes.length - 1 ? '.' : '.';
+            console.log(chalk.gray(`${prefix}${notes[i]}${suffix}`));
         }
         console.log();
-        // Sync MCP servers to agents
-        console.log(chalk.blue('MCP server distribution:'));
-        await applyToAgents(scope);
-        const ruleDistribution = distributeRules(undefined, { force: true }, scope);
+        const mcpDistribution = await applyToAgents(scope, undefined, { useSpinner: false });
+        const ruleDistribution = distributeRules(undefined, undefined, scope);
         const commandDistribution = distributeCommands(scope);
-        const subagentDistribution = distributeSubagents(scope);
+        const agentDistribution = distributeSubagents(scope);
         const skillDistribution = distributeSkills(scope, {
             useAgentsDir: config.distribution.use_agents_dir,
         });
-        const ruleErrors = ruleDistribution.results.filter((result) => result.status === 'error');
-        const commandErrors = commandDistribution.results.filter((result) => result.status === 'error');
-        const subagentErrors = subagentDistribution.results.filter((result) => result.status === 'error');
-        const skillErrors = skillDistribution.results.filter((result) => result.status === 'error');
-        printDistributionResults({
-            title: 'Rule distribution',
-            results: ruleDistribution.results,
-            emptyMessage: 'no supported agents configured',
-            getTargetLabel: (result) => result.agent,
-            getPath: (result) => result.filePath,
-        });
-        console.log();
-        printDistributionResults({
-            title: 'Command distribution',
-            results: commandDistribution.results,
-            emptyMessage: 'no active commands',
-            getTargetLabel: (result) => result.platform,
-            getPath: (result) => result.filePath,
-        });
-        console.log();
-        printDistributionResults({
-            title: 'Subagent distribution',
-            results: subagentDistribution.results,
-            emptyMessage: 'no active subagents',
-            getTargetLabel: (result) => result.platform,
-            getPath: (result) => result.filePath,
-        });
-        console.log();
-        printDistributionResults({
-            title: 'Skill distribution',
-            results: skillDistribution.results,
-            emptyMessage: 'no active skills',
-            getTargetLabel: (result) => result.platform === 'agents' ? 'codex+gemini+opencode' : result.platform,
-            getPath: (result) => result.targetDir,
-        });
+        const hookDistribution = distributeHooks(scope);
+        const distSections = [
+            {
+                label: 'mcp',
+                results: mcpDistribution,
+                emptyMessage: 'no apps configured',
+                getTargetLabel: (r) => r.application,
+                getPath: (r) => r.filePath,
+            },
+            {
+                label: 'rules',
+                results: ruleDistribution.results,
+                emptyMessage: 'none',
+                getTargetLabel: (r) => r.agent,
+                getPath: (r) => r.filePath,
+            },
+            {
+                label: 'commands',
+                results: commandDistribution.results,
+                emptyMessage: 'none',
+                getTargetLabel: (r) => r.platform,
+                getPath: (r) => r.filePath,
+            },
+            {
+                label: 'agents',
+                results: agentDistribution.results,
+                emptyMessage: 'none',
+                getTargetLabel: (r) => r.platform,
+                getPath: (r) => r.filePath,
+            },
+            {
+                label: 'skills',
+                results: skillDistribution.results,
+                emptyMessage: 'none',
+                getTargetLabel: (r) => {
+                    const sr = r;
+                    return sr.platform === 'agents' ? 'codex+gemini+opencode' : sr.platform;
+                },
+                getPath: (r) => r.targetDir,
+            },
+            {
+                label: 'hooks',
+                results: hookDistribution.results,
+                emptyMessage: 'none',
+                getTargetLabel: (r) => r.platform,
+                getPath: (r) => {
+                    const hr = r;
+                    return 'filePath' in hr ? hr.filePath : hr.targetDir;
+                },
+            },
+        ];
+        const { hasErrors } = printCompactDistributions(distSections);
         console.log();
-        const hasErrors = ruleErrors.length > 0 ||
-            commandErrors.length > 0 ||
-            subagentErrors.length > 0 ||
-            skillErrors.length > 0;
         if (hasErrors) {
-            console.log(chalk.red('✗ Synchronization completed with errors.'));
+            console.log(chalk.red('✗ Sync completed with errors.'));
             process.exit(1);
         }
         else {
-            console.log(chalk.green('✓ Synchronization complete.'));
+            console.log(chalk.green('✓ Sync complete.'));
         }
     }
     catch (error) {
@@ -219,7 +315,7 @@ function defaultCommandSourceDir(platform) {
             return getOpencodePath('command');
     }
 }
-function defaultSubagentSourceDir(platform) {
+function defaultAgentSourceDir(platform) {
     switch (platform) {
         case 'claude-code':
             return path.join(getClaudeDir(), 'agents');
@@ -227,6 +323,8 @@ function defaultSubagentSourceDir(platform) {
             return path.join(getCursorDir(), 'agents');
         case 'opencode':
             return getOpencodePath('agent');
+        default:
+            throw new Error(`Unknown agent platform: ${String(platform)}`);
     }
 }
 function defaultSkillSourceDir(platform) {
@@ -275,6 +373,141 @@ async function confirmOverwrite(filePath, force) {
         return true;
     return await confirm({ message: `File exists: ${filePath}. Overwrite?`, default: false });
 }
+function copyDirRecursive(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+            // Preserve executable permissions
+            try {
+                const mode = fs.statSync(srcPath).mode;
+                if (mode & 0o111)
+                    fs.chmodSync(destPath, mode & 0o777);
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+}
+/**
+ * Extract hooks from Claude Code's ~/.claude/settings.json and import as a
+ * bundle into ~/.asb/hooks/. Copies referenced script files if they exist
+ * alongside the hooks and rewrites commands to use ${HOOK_DIR}.
+ */
+async function importHooksFromClaudeCode(opts) {
+    const settingsPath = path.join(getClaudeDir(), 'settings.json');
+    if (!isFile(settingsPath)) {
+        console.error(chalk.red(`\n✗ Claude Code settings not found: ${settingsPath}`));
+        process.exit(1);
+    }
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    const hooks = settings.hooks;
+    if (!hooks || Object.keys(hooks).length === 0) {
+        console.log(chalk.yellow('\n⚠ No hooks found in Claude Code settings.'));
+        return;
+    }
+    // Filter out ASB-managed hooks (avoid re-importing our own output)
+    const userHooks = {};
+    for (const [event, groups] of Object.entries(hooks)) {
+        const userGroups = groups.filter((g) => g._asb_source === undefined);
+        if (userGroups.length > 0)
+            userHooks[event] = userGroups;
+    }
+    if (Object.keys(userHooks).length === 0) {
+        console.log(chalk.yellow('\n⚠ No user-defined hooks found (all are ASB-managed).'));
+        return;
+    }
+    // Collect script paths referenced in commands
+    const referencedScripts = new Set();
+    for (const groups of Object.values(userHooks)) {
+        for (const group of groups) {
+            const handlers = group.hooks;
+            if (!handlers)
+                continue;
+            for (const handler of handlers) {
+                if (typeof handler.command !== 'string')
+                    continue;
+                // Extract file paths from commands like "node ~/.claude/hooks/script.mjs"
+                const match = handler.command.match(/(?:^|\s)(~\/\.claude\/hooks\/\S+|(?:\/\S*\/)?\.claude\/hooks\/\S+)/);
+                if (match) {
+                    const scriptPath = match[1].replace(/^~/, process.env.HOME ?? '');
+                    if (fs.existsSync(scriptPath)) {
+                        referencedScripts.add(scriptPath);
+                    }
+                }
+            }
+        }
+    }
+    const slug = 'claude-code-hooks';
+    const bundleDir = path.join(getHooksDir(), slug);
+    if (fs.existsSync(bundleDir)) {
+        if (!(await confirmOverwrite(bundleDir, opts.force)))
+            return;
+        fs.rmSync(bundleDir, { recursive: true });
+    }
+    fs.mkdirSync(bundleDir, { recursive: true });
+    // Copy referenced scripts and rewrite commands to use ${HOOK_DIR}
+    const { HOOK_DIR_PLACEHOLDER } = await import('./hooks/schema.js');
+    const rewrittenHooks = {};
+    for (const [event, groups] of Object.entries(userHooks)) {
+        rewrittenHooks[event] = groups.map((group) => {
+            const handlers = group.hooks;
+            if (!handlers)
+                return group;
+            return {
+                ...group,
+                hooks: handlers.map((handler) => {
+                    if (typeof handler.command !== 'string')
+                        return handler;
+                    let cmd = handler.command;
+                    for (const scriptPath of referencedScripts) {
+                        const scriptName = path.basename(scriptPath);
+                        if (cmd.includes(scriptPath) ||
+                            cmd.includes(scriptPath.replace(process.env.HOME ?? '', '~'))) {
+                            cmd = cmd.replace(scriptPath, `${HOOK_DIR_PLACEHOLDER}/${scriptName}`);
+                            cmd = cmd.replace(scriptPath.replace(process.env.HOME ?? '', '~'), `${HOOK_DIR_PLACEHOLDER}/${scriptName}`);
+                        }
+                    }
+                    return { ...handler, command: cmd };
+                }),
+            };
+        });
+    }
+    // Copy script files into the bundle
+    let scriptsCopied = 0;
+    for (const scriptPath of referencedScripts) {
+        const scriptName = path.basename(scriptPath);
+        const destPath = path.join(bundleDir, scriptName);
+        fs.copyFileSync(scriptPath, destPath);
+        try {
+            const mode = fs.statSync(scriptPath).mode;
+            if (mode & 0o111)
+                fs.chmodSync(destPath, mode & 0o777);
+        }
+        catch {
+            // Ignore
+        }
+        scriptsCopied++;
+        console.log(`  ${chalk.green('✓')} ${chalk.dim(scriptName)}`);
+    }
+    // Write hook.json
+    const hookJson = {
+        name: 'claude-code-hooks',
+        description: 'Hooks imported from Claude Code settings.json',
+        hooks: rewrittenHooks,
+    };
+    fs.writeFileSync(path.join(bundleDir, 'hook.json'), `${JSON.stringify(hookJson, null, 2)}\n`, 'utf-8');
+    const eventCount = Object.keys(rewrittenHooks).length;
+    console.log(`\n${chalk.green('✓')} Imported ${eventCount} event(s) + ${scriptsCopied} script(s) → ${chalk.dim(bundleDir)}`);
+    console.log(chalk.gray('  Activate with: asb hook  (interactive) or add to [hooks].active in config.toml'));
+}
 program
     .command('mcp')
     .description('Interactive UI to enable/disable MCP servers')
@@ -652,13 +885,13 @@ commandRoot
         process.exit(1);
     }
 });
-// Subagents library: scaffold, load, list, and interactive distribute
-const subagentRoot = program
-    .command('subagent')
-    .description('Select subagent definitions interactively and distribute to agents')
+// Agents library: load, list, and interactive distribute
+const agentRoot = program
+    .command('agent')
+    .description('Select agent definitions interactively and distribute to applications')
     .option('-p, --profile <name>', 'Profile configuration to use')
     .option('--project <path>', 'Project directory containing .asb.toml');
-subagentRoot.action(async (options) => {
+agentRoot.action(async (options) => {
     try {
         const scope = resolveScope(options);
         const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
@@ -666,18 +899,17 @@ subagentRoot.action(async (options) => {
         if (!selection)
             return;
         console.log();
-        printActiveSelection('subagents', selection.active);
+        printActiveSelection('agents', selection.active);
         const out = distributeSubagents(scope);
         if (out.results.length > 0) {
             console.log();
             printDistributionResults({
-                title: 'Subagent distribution',
+                title: 'Agent distribution',
                 results: out.results,
                 getTargetLabel: (result) => result.platform,
                 getPath: (result) => result.filePath,
             });
         }
-        // Guidance: unsupported platforms for subagents
         console.log();
         console.log(chalk.gray('Unsupported platforms (manual steps required): Codex, Gemini'));
     }
@@ -688,9 +920,9 @@ subagentRoot.action(async (options) => {
         process.exit(1);
     }
 });
-subagentRoot
+agentRoot
     .command('load')
-    .description('Import existing platform files into the subagent library')
+    .description('Import existing platform files into the agent library')
     .argument('<platform>', 'claude-code | opencode | cursor')
     .argument('[path]', 'Source file or directory (defaults by platform)')
     .option('-r, --recursive', 'When [path] is a directory, import files recursively')
@@ -698,7 +930,7 @@ subagentRoot
     .action(async (platform, srcPath, opts) => {
     try {
         const exts = ['.md', '.markdown'];
-        const source = srcPath && srcPath.trim().length > 0 ? srcPath : defaultSubagentSourceDir(platform);
+        const source = srcPath && srcPath.trim().length > 0 ? srcPath : defaultAgentSourceDir(platform);
         if (!fs.existsSync(source)) {
             console.error(chalk.red(`\n✗ Source not found: ${source}`));
             process.exit(1);
@@ -718,7 +950,7 @@ subagentRoot
             console.log(chalk.yellow('\n⚠ No files to import.'));
             return;
         }
-        const outDir = getSubagentsDir();
+        const outDir = getAgentsDir();
         let imported = 0;
         for (const file of inputs) {
             try {
@@ -735,7 +967,7 @@ subagentRoot
                 console.log(`${chalk.red('✗')} ${chalk.dim(file)} ${chalk.red(msg)}`);
             }
         }
-        console.log(`\n${chalk.green('✓')} Imported ${imported} file(s) into subagent library.`);
+        console.log(`\n${chalk.green('✓')} Imported ${imported} file(s) into agent library.`);
     }
     catch (error) {
         if (error instanceof Error) {
@@ -744,9 +976,9 @@ subagentRoot
         process.exit(1);
     }
 });
-subagentRoot
+agentRoot
     .command('list')
-    .description('Display subagent inventory and sync information')
+    .description('Display agent inventory and sync information')
     .option('--json', 'Output inventory as JSON')
     .option('-p, --profile <name>', 'Profile configuration to use')
     .option('--project <path>', 'Project directory containing .asb.toml')
@@ -763,10 +995,10 @@ subagentRoot
             return;
         }
         if (inventory.entries.length === 0) {
-            console.log(chalk.yellow('⚠ No subagents found. Use `asb subagent load <platform> [path]`.'));
+            console.log(chalk.yellow('⚠ No agents found. Use `asb agent load <platform> [path]`.'));
         }
         else {
-            console.log(chalk.blue('Subagents:'));
+            console.log(chalk.blue('Agents:'));
             const header = ['ID', 'Active', 'Title', 'Model', 'Tools', 'Extras'];
             const rows = inventory.entries.map((row) => {
                 const activePlain = row.active ? 'yes' : 'no';
@@ -790,7 +1022,6 @@ subagentRoot
         }
         console.log();
         printAgentSyncStatus({ agentSync: inventory.state.agentSync });
-        // Guidance: unsupported platforms for subagents
         console.log();
         console.log(chalk.gray('Unsupported platforms (manual steps required): Codex, Gemini'));
     }
@@ -942,30 +1173,198 @@ skillRoot
         process.exit(1);
     }
 });
-/**
- * Apply enabled MCP servers to all registered agents
- * @param scope - Configuration scope (profile/project)
- * @param enabledServerNames - List of enabled server names
- */
-async function applyToAgents(scope, enabledServerNames) {
+// Hooks library: manage and distribute hooks to Claude Code
+const hookRoot = program
+    .command('hook')
+    .description('Select hooks interactively and distribute to Claude Code')
+    .option('-p, --profile <name>', 'Profile configuration to use')
+    .option('--project <path>', 'Project directory containing .asb.toml');
+hookRoot.action(async (options) => {
+    try {
+        const scope = resolveScope(options);
+        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const selection = await showHookSelector({ scope, pageSize: config.ui.page_size });
+        if (!selection)
+            return;
+        console.log();
+        printActiveSelection('hooks', selection.active);
+        const out = distributeHooks(scope);
+        if (out.results.length > 0) {
+            console.log();
+            printDistributionResults({
+                title: 'Hook distribution',
+                results: out.results,
+                getTargetLabel: (result) => result.platform,
+                getPath: (result) => 'filePath' in result ? result.filePath : result.targetDir,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red(`\n✗ Error: ${error.message}`));
+        }
+        process.exit(1);
+    }
+});
+hookRoot
+    .command('list')
+    .description('Display hook library entries')
+    .option('--json', 'Output inventory as JSON')
+    .option('-p, --profile <name>', 'Profile configuration to use')
+    .option('--project <path>', 'Project directory containing .asb.toml')
+    .action((options) => {
+    try {
+        const scope = resolveScope(options);
+        const entries = loadHookLibrary();
+        const state = loadLibraryStateSection('hooks', scope);
+        const activeSet = new Set(state.active);
+        if (options.json) {
+            console.log(JSON.stringify({
+                entries: entries.map((e) => ({
+                    id: e.id,
+                    name: e.name,
+                    description: e.description,
+                    events: Object.keys(e.hooks),
+                    active: activeSet.has(e.id),
+                })),
+                active: state.active,
+            }, null, 2));
+            return;
+        }
+        if (entries.length === 0) {
+            console.log(chalk.yellow(`⚠ No hooks found. Add JSON hook files to ${getHooksDir()}`));
+        }
+        else {
+            console.log(chalk.blue('Hooks:'));
+            const header = ['ID', 'Active', 'Name', 'Events', 'Description'];
+            const rows = entries.map((e) => {
+                const active = activeSet.has(e.id);
+                const activePlain = active ? 'yes' : 'no';
+                const events = Object.keys(e.hooks).join(', ');
+                const desc = e.description ?? '—';
+                const descTrunc = desc.length > 40 ? `${desc.substring(0, 37)}...` : desc;
+                return [
+                    { plain: e.id, formatted: e.id },
+                    {
+                        plain: activePlain,
+                        formatted: active ? chalk.green(activePlain) : chalk.gray(activePlain),
+                    },
+                    { plain: e.name ?? e.id, formatted: e.name ?? e.id },
+                    { plain: events, formatted: events },
+                    { plain: descTrunc, formatted: descTrunc },
+                ];
+            });
+            printTable(header, rows);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red(`\n✗ Error: ${error.message}`));
+        }
+        process.exit(1);
+    }
+});
+hookRoot
+    .command('load')
+    .description('Import hooks into the library. Accepts:\n' +
+    '  - A JSON file (single-file hook)\n' +
+    '  - A directory with hook.json (bundle hook)\n' +
+    '  - "claude-code" to extract from ~/.claude/settings.json')
+    .argument('<source>', 'JSON file, directory, or "claude-code"')
+    .option('-f, --force', 'Overwrite existing library entries without confirmation')
+    .option('-n, --name <name>', 'Override the hook ID (default: basename of source)')
+    .action(async (source, opts) => {
+    try {
+        if (source === 'claude-code') {
+            await importHooksFromClaudeCode(opts);
+            return;
+        }
+        const resolved = path.resolve(source);
+        if (isFile(resolved)) {
+            // Single-file hook import
+            const content = fs.readFileSync(resolved, 'utf-8');
+            try {
+                const { hookFileSchema } = await import('./hooks/schema.js');
+                hookFileSchema.parse(JSON.parse(content));
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`\n✗ Invalid hook file: ${msg}`));
+                process.exit(1);
+            }
+            const slug = opts.name ?? path.basename(resolved, path.extname(resolved));
+            const target = path.join(getHooksDir(), `${slug}.json`);
+            if (!(await confirmOverwrite(target, opts.force)))
+                return;
+            writeFileSecure(target, content);
+            console.log(`${chalk.green('✓')} ${chalk.cyan(slug)} → ${chalk.dim(target)}`);
+        }
+        else if (isDir(resolved)) {
+            // Bundle hook import (directory with hook.json + scripts)
+            const hookJsonPath = path.join(resolved, 'hook.json');
+            if (!isFile(hookJsonPath)) {
+                console.error(chalk.red('\n✗ Directory does not contain hook.json'));
+                process.exit(1);
+            }
+            // Validate hook.json
+            try {
+                const { hookFileSchema } = await import('./hooks/schema.js');
+                hookFileSchema.parse(JSON.parse(fs.readFileSync(hookJsonPath, 'utf-8')));
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`\n✗ Invalid hook.json: ${msg}`));
+                process.exit(1);
+            }
+            const slug = opts.name ?? path.basename(resolved);
+            const targetDir = path.join(getHooksDir(), slug);
+            if (fs.existsSync(targetDir)) {
+                if (!(await confirmOverwrite(targetDir, opts.force)))
+                    return;
+                fs.rmSync(targetDir, { recursive: true });
+            }
+            // Copy entire directory
+            copyDirRecursive(resolved, targetDir);
+            const fileCount = listFilesRecursively(targetDir, []).length;
+            console.log(`${chalk.green('✓')} ${chalk.cyan(slug)} → ${chalk.dim(targetDir)} (${fileCount} files)`);
+        }
+        else {
+            console.error(chalk.red(`\n✗ Source not found: ${resolved}`));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red(`\n✗ Error: ${error.message}`));
+        }
+        process.exit(1);
+    }
+});
+async function applyToAgents(scope, enabledServerNames, options) {
     const mcpConfig = loadMcpConfig();
     const switchboardConfig = loadSwitchboardConfig(scopeToLoadOptions(scope));
-    if (switchboardConfig.agents.active.length === 0) {
-        console.log(chalk.yellow('\n⚠ No agents found in the active configuration stack.'));
-        console.log();
-        console.log('Add agents under the relevant TOML layer (user, profile, or project).');
-        console.log(chalk.dim('  Example: [agents]\n  active = ["claude-code", "cursor"]'));
-        return;
+    const useSpinner = options?.useSpinner ?? true;
+    const results = [];
+    if (switchboardConfig.applications.active.length === 0) {
+        if (useSpinner) {
+            console.log(chalk.yellow('\n⚠ No applications found in the active configuration stack.'));
+            console.log();
+            console.log('Add applications under the relevant TOML layer (user, profile, or project).');
+            console.log(chalk.dim('  Example: [applications]\n  active = ["claude-code", "cursor"]'));
+        }
+        return results;
     }
     // Global MCP servers list (from UI selection or config)
     const globalMcpServers = enabledServerNames ?? loadMcpActiveState(scope);
-    // Apply to each registered agent with per-agent MCP overrides
-    for (const agentId of switchboardConfig.agents.active) {
-        const spinner = ora({ indent: 2 }).start(`Applying to ${agentId}...`);
-        const persist = (symbol, text) => spinner.stopAndPersist({ symbol: `  ${symbol}`, text });
+    for (const agentId of switchboardConfig.applications.active) {
+        const spinner = useSpinner ? ora({ indent: 2 }).start(`Applying to ${agentId}...`) : null;
+        const persist = (symbol, text) => {
+            if (!spinner)
+                return;
+            spinner.stopAndPersist({ symbol: `  ${symbol}`, text });
+        };
         try {
-            // Get per-agent MCP config (applies add/remove overrides)
-            const agentMcpConfig = resolveAgentSectionConfig('mcp', agentId, scope);
+            const agentMcpConfig = resolveApplicationSectionConfig('mcp', agentId, scope);
             // If user selected servers via UI, use that as base; otherwise use per-agent resolved config
             const agentActiveServers = enabledServerNames
                 ? agentMcpConfig.active.filter((s) => globalMcpServers.includes(s))
@@ -975,23 +1374,57 @@ async function applyToAgents(scope, enabledServerNames) {
             const enabledServers = Object.fromEntries(Object.entries(mcpConfig.mcpServers).filter(([name]) => activeSet.has(name)));
             const configToApply = { mcpServers: enabledServers };
             const agent = getAgentById(agentId);
+            const readFileSafe = (p) => {
+                try {
+                    return fs.readFileSync(p, 'utf-8');
+                }
+                catch {
+                    return null;
+                }
+            };
             // Use project-level config when --project is specified
             if (scope?.project && agent.applyProjectConfig) {
-                agent.applyProjectConfig(scope.project, configToApply);
                 const projectPath = agent.projectConfigPath?.(scope.project) ?? 'project config';
-                persist(chalk.green('✓'), `${chalk.cyan(agentId)} ${chalk.dim(projectPath)}`);
+                const before = readFileSafe(projectPath);
+                agent.applyProjectConfig(scope.project, configToApply);
+                const after = readFileSafe(projectPath);
+                const changed = before !== after;
+                persist(chalk.green('✓'), `${chalk.cyan(agentId)} ${chalk.dim(shortenPath(projectPath))}`);
+                results.push({
+                    application: agentId,
+                    filePath: projectPath,
+                    status: changed ? 'written' : 'skipped',
+                    reason: changed ? 'applied' : 'up-to-date',
+                });
             }
             else {
+                const configPath = agent.configPath();
+                const before = readFileSafe(configPath);
                 agent.applyConfig(configToApply);
-                persist(chalk.green('✓'), `${chalk.cyan(agentId)} ${chalk.dim(agent.configPath())}`);
+                const after = readFileSafe(configPath);
+                const changed = before !== after;
+                persist(chalk.green('✓'), `${chalk.cyan(agentId)} ${chalk.dim(shortenPath(configPath))}`);
+                results.push({
+                    application: agentId,
+                    filePath: configPath,
+                    status: changed ? 'written' : 'skipped',
+                    reason: changed ? 'applied' : 'up-to-date',
+                });
             }
         }
         catch (error) {
             if (error instanceof Error) {
                 persist(chalk.yellow('⚠'), `${chalk.cyan(agentId)} - ${error.message} (skipped)`);
+                results.push({
+                    application: agentId,
+                    filePath: '(unknown)',
+                    status: 'error',
+                    error: `${error.message} (skipped)`,
+                });
             }
         }
     }
+    return results;
 }
 /**
  * Show summary of enabled/disabled servers and applied agents
@@ -1016,33 +1449,99 @@ function showSummary(selectedServers, scope) {
         }
     }
     const switchboardConfig = loadSwitchboardConfig(scopeToLoadOptions(scope));
-    if (switchboardConfig.agents.active.length > 0) {
-        console.log(chalk.blue(`\nApplied to agents (${switchboardConfig.agents.active.length}):`));
-        for (const agent of switchboardConfig.agents.active) {
+    if (switchboardConfig.applications.active.length > 0) {
+        console.log(chalk.blue(`\nApplied to applications (${switchboardConfig.applications.active.length}):`));
+        for (const agent of switchboardConfig.applications.active) {
             console.log(`  ${chalk.dim('•')} ${agent}`);
         }
     }
     console.log();
 }
-// Library subscription commands
-program
-    .command('subscribe')
-    .description('Add a library subscription with a namespace')
-    .argument('<name>', 'Namespace for this subscription (e.g., "team", "project")')
-    .argument('<path>', 'Path to the library directory')
-    .action((name, libraryPath) => {
+function printMarketplaceSummary(localPath) {
     try {
-        // Validate the path has library structure
-        const validation = validateSubscriptionPath(libraryPath);
-        if (!validation.valid) {
-            console.error(chalk.red(`\n✗ Path does not contain any library folders (rules/, commands/, subagents/, skills/).`));
-            process.exit(1);
+        const mp = readMarketplace(localPath);
+        console.log(chalk.dim(`  Type: marketplace (${mp.name})`));
+        console.log(chalk.dim(`  Plugins: ${mp.plugins.length}`));
+        for (const plugin of mp.plugins) {
+            const desc = plugin.description ? ` - ${plugin.description}` : '';
+            console.log(chalk.dim(`    ${plugin.name}${desc}`));
+        }
+        for (const w of mp.warnings) {
+            console.log(chalk.yellow(`  ⚠ ${w}`));
         }
-        addSubscription(name, libraryPath);
-        console.log(chalk.green(`\n✓ Subscribed to "${name}" at ${path.resolve(libraryPath)}`));
-        console.log(chalk.dim(`  Found: ${validation.found.join(', ')}`));
-        if (validation.missing.length > 0) {
-            console.log(chalk.dim(`  Missing: ${validation.missing.join(', ')}`));
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.log(chalk.yellow(`  ⚠ Failed to read marketplace: ${msg}`));
+    }
+}
+const sourceRoot = program
+    .command('source')
+    .description('Manage external library sources (local paths or git repos)');
+sourceRoot
+    .command('add')
+    .description('Add a library source (local path or git URL)')
+    .argument('<location>', 'Local path or git URL (e.g., https://github.com/org/repo)')
+    .argument('[name]', 'Namespace (defaults to repo or directory name)')
+    .action((location, nameArg) => {
+    try {
+        const name = nameArg ?? inferSourceName(location);
+        if (isGitUrl(location)) {
+            const parsed = parseGitUrl(location);
+            const spinner = ora(`Cloning ${parsed.url}...`).start();
+            try {
+                addRemoteSource(name, {
+                    url: parsed.url,
+                    ref: parsed.ref,
+                    subdir: parsed.subdir,
+                });
+                spinner.succeed(chalk.green(`✓ Cloned ${parsed.url}`));
+            }
+            catch (err) {
+                spinner.fail(chalk.red('Failed to clone'));
+                throw err;
+            }
+            let effectivePath = getSourceCacheDir(name);
+            if (parsed.subdir)
+                effectivePath = path.join(effectivePath, parsed.subdir);
+            const validation = validateSourcePath(effectivePath);
+            if (!validation.valid) {
+                removeSource(name);
+                console.error(chalk.red('\n✗ Cloned repository does not contain any library folders (rules/, commands/, agents/, skills/) or marketplace manifest.'));
+                process.exit(1);
+            }
+            console.log(chalk.green(`\n✓ Added source "${name}" from ${parsed.url}`));
+            if (parsed.ref)
+                console.log(chalk.dim(`  Ref: ${parsed.ref}`));
+            if (parsed.subdir)
+                console.log(chalk.dim(`  Subdir: ${parsed.subdir}`));
+            if (validation.isMarketplace) {
+                printMarketplaceSummary(effectivePath);
+            }
+            else {
+                console.log(chalk.dim(`  Found: ${validation.found.join(', ')}`));
+                if (validation.missing.length > 0) {
+                    console.log(chalk.dim(`  Missing: ${validation.missing.join(', ')}`));
+                }
+            }
+        }
+        else {
+            const validation = validateSourcePath(location);
+            if (!validation.valid) {
+                console.error(chalk.red('\n✗ Path does not contain any library folders (rules/, commands/, agents/, skills/) or marketplace manifest.'));
+                process.exit(1);
+            }
+            addLocalSource(name, location);
+            console.log(chalk.green(`\n✓ Added source "${name}" at ${path.resolve(location)}`));
+            if (validation.isMarketplace) {
+                printMarketplaceSummary(path.resolve(location));
+            }
+            else {
+                console.log(chalk.dim(`  Found: ${validation.found.join(', ')}`));
+                if (validation.missing.length > 0) {
+                    console.log(chalk.dim(`  Missing: ${validation.missing.join(', ')}`));
+                }
+            }
         }
         console.log();
         console.log(chalk.dim('Library entries will now use the namespace prefix, e.g., ') +
@@ -1055,14 +1554,21 @@ program
         process.exit(1);
     }
 });
-program
-    .command('unsubscribe')
-    .description('Remove a library subscription by namespace')
+sourceRoot
+    .command('remove')
+    .description('Remove a library source by namespace')
     .argument('<name>', 'Namespace to remove')
     .action((name) => {
     try {
-        removeSubscription(name);
-        console.log(chalk.green(`\n✓ Unsubscribed from "${name}"`));
+        const sources = getSources();
+        const source = sources.find((s) => s.namespace === name);
+        removeSource(name);
+        if (source?.remote) {
+            console.log(chalk.green(`\n✓ Removed source "${name}" and cleaned up cache`));
+        }
+        else {
+            console.log(chalk.green(`\n✓ Removed source "${name}"`));
+        }
     }
     catch (error) {
         if (error instanceof Error) {
@@ -1071,32 +1577,63 @@ program
         process.exit(1);
     }
 });
-program
-    .command('subscriptions')
-    .description('List all library subscriptions')
-    .option('--json', 'Output as JSON')
+sourceRoot
+    .command('list')
+    .description('List all library sources')
+    .option('--json', 'Output inventory as JSON')
     .action((options) => {
     try {
-        const subscriptions = getSubscriptions();
+        const sources = getSources();
         if (options.json) {
-            console.log(JSON.stringify(subscriptions, null, 2));
+            console.log(JSON.stringify(sources, null, 2));
             return;
         }
-        if (subscriptions.length === 0) {
-            console.log(chalk.yellow('\n⚠ No library subscriptions configured.'));
-            console.log(chalk.dim('  Use `asb subscribe <name> <path>` to add one.'));
+        if (sources.length === 0) {
+            console.log(chalk.yellow('⚠ No library sources configured.'));
+            console.log(chalk.dim('  Use `asb source add <location> [name]` to add one.'));
             return;
         }
-        console.log(chalk.blue('\nLibrary subscriptions:'));
-        const header = ['Namespace', 'Path', 'Status', 'Contains'];
-        const rows = subscriptions.map((sub) => {
-            const exists = fs.existsSync(sub.path);
-            const validation = exists ? validateSubscriptionPath(sub.path) : { found: [], missing: [] };
-            const statusPlain = exists ? 'ok' : 'missing';
-            const containsPlain = validation.found.length > 0 ? validation.found.join(', ') : '-';
+        console.log(chalk.blue('\nLibrary sources:'));
+        const header = ['Namespace', 'Type', 'Source', 'Status', 'Contains'];
+        const rows = sources.map((src) => {
+            const isRemote = !!src.remote;
+            const exists = fs.existsSync(src.path);
+            const validation = exists
+                ? validateSourcePath(src.path)
+                : { found: [], missing: [], isMarketplace: false };
+            const typePlain = validation.isMarketplace ? 'marketplace' : isRemote ? 'remote' : 'local';
+            const sourcePlain = isRemote ? (src.remote?.url ?? src.path) : src.path;
+            let statusPlain;
+            if (isRemote) {
+                statusPlain = exists ? 'cached' : 'not cached';
+            }
+            else {
+                statusPlain = exists ? 'ok' : 'missing';
+            }
+            let containsPlain;
+            if (validation.isMarketplace && exists) {
+                try {
+                    const mp = readMarketplace(src.path);
+                    containsPlain = `${mp.plugins.length} plugin(s)`;
+                }
+                catch {
+                    containsPlain = 'marketplace (error)';
+                }
+            }
+            else {
+                containsPlain = validation.found.length > 0 ? validation.found.join(', ') : '-';
+            }
             return [
-                { plain: sub.namespace, formatted: chalk.cyan(sub.namespace) },
-                { plain: sub.path, formatted: chalk.dim(sub.path) },
+                { plain: src.namespace, formatted: chalk.cyan(src.namespace) },
+                {
+                    plain: typePlain,
+                    formatted: validation.isMarketplace
+                        ? chalk.magenta(typePlain)
+                        : isRemote
+                            ? chalk.blue(typePlain)
+                            : chalk.gray(typePlain),
+                },
+                { plain: sourcePlain, formatted: chalk.dim(sourcePlain) },
                 {
                     plain: statusPlain,
                     formatted: exists ? chalk.green(statusPlain) : chalk.red(statusPlain),
@@ -1114,5 +1651,8 @@ program
         process.exit(1);
     }
 });
+sourceRoot.action(() => {
+    sourceRoot.commands.find((c) => c.name() === 'list')?.parse(process.argv);
+});
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map