agent-switchboard 0.3.6 → 0.3.8

package/dist/index.js

@@ -13,39 +13,42 @@ import ora from 'ora';
 import { distributeCommands } from './commands/distribution.js';
 import { importCommandFromFile } from './commands/importer.js';
 import { buildCommandInventory } from './commands/inventory.js';
-import { resolveEffectiveSectionConfig } from './config/application-config.js';
 import { updateConfigLayer } from './config/layered-config.js';
-import { loadMcpConfig, loadMcpConfigWithPlugins, stripLegacyEnabledFlagsFromMcpJson, } from './config/mcp-config.js';
+import { loadMcpConfig, stripLegacyEnabledFlagsFromMcpJson } from './config/mcp-config.js';
 import { getAgentsDir, getAgentsHome, getClaudeDir, getCodexDir, getCommandsDir, getCursorDir, getGeminiDir, getHooksDir, getOpencodePath, getSkillsDir, getSourceCacheDir, } from './config/paths.js';
+import { scopeToLayerOptions } from './config/scope.js';
 import { loadSwitchboardConfig, loadSwitchboardConfigWithLayers, } from './config/switchboard-config.js';
 import { distributeHooks } from './hooks/distribution.js';
 import { loadHookLibrary } from './hooks/library.js';
 import { copyDirRecursive, ensureLibraryDirectories, isDir, isFile, listFilesRecursively, writeFileSecure, } from './library/fs.js';
 import { addLocalSource, addRemoteSource, getSources, inferSourceName, isGitUrl, parseGitUrl, removeSource, updateRemoteSources, validateSourcePath, } from './library/sources.js';
-import { loadLibraryStateSection, loadMcpEnabledState, resetAgentSyncCache, saveMcpEnabledState, } from './library/state.js';
+import { loadLibraryStateSection, saveMcpEnabledState } from './library/state.js';
 import { readMarketplace } from './marketplace/reader.js';
+import { distributeMcp } from './mcp/distribution.js';
 import { buildPluginIndex } from './plugins/index.js';
 import { composeActiveRules } from './rules/composer.js';
 import { distributeRules, listIndirectAgents, listPerFileAgents, listUnsupportedAgents, } from './rules/distribution.js';
 import { buildRuleInventory } from './rules/inventory.js';
 import { loadRuleLibrary } from './rules/library.js';
-import { loadRuleState, updateRuleState } from './rules/state.js';
+import { loadRuleState, loadWritableRuleState, updateRuleState } from './rules/state.js';
 import { distributeSkills } from './skills/distribution.js';
 import { importSkill, listSkillsInDirectory } from './skills/importer.js';
 import { buildSkillInventory } from './skills/inventory.js';
 import { distributeSubagents } from './subagents/distribution.js';
 import { importSubagentFromFile } from './subagents/importer.js';
 import { buildSubagentInventory } from './subagents/inventory.js';
+import { runSyncCommand } from './sync/command.js';
 import { initTargets } from './targets/init.js';
-import { filterInstalled, getTargetById, getTargetsForSection, registerConfigTargets, } from './targets/registry.js';
+import { getTargetsForSection } from './targets/registry.js';
 import { showCommandSelector } from './ui/command-ui.js';
 import { showHookSelector } from './ui/hook-ui.js';
 import { showMcpServerUI } from './ui/mcp-ui.js';
 import { printPluginInfo, printPluginList } from './ui/plugin-ui.js';
 import { showRuleSelector } from './ui/rule-ui.js';
+import { shouldPersistSelection } from './ui/selection-state.js';
 import { showSkillSelector } from './ui/skill-ui.js';
 import { showSubagentSelector } from './ui/subagent-ui.js';
-import { printActiveSelection, printAgentSyncStatus, printCompactDistributions, printDistributionResults, printTable, shortenPath, } from './util/cli.js';
+import { printActiveSelection, printAgentSyncStatus, printDistributionResults, printTable, } 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'));
@@ -58,7 +61,7 @@ Examples:
   $ asb mcp                          Enable/disable MCP servers interactively
   $ asb rule                         Select and order rule snippets
   $ asb sync                         Push all libraries to every active agent
-  $ asb sync --project .             Sync with project-level overrides
+  $ asb sync -P .                    Sync with project-level overrides
 
 Alias: agent-switchboard
 Config: ~/.agent-switchboard/config.toml`);
@@ -68,69 +71,21 @@ program
     .command('sync')
     .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('-P, --project <path>', 'Project directory containing .asb.toml')
     .option('--no-update', 'Skip updating remote sources')
     .action(async (options) => {
     try {
         const scope = resolveScope(options);
-        console.log(chalk.yellow('⚠ Sync overwrites agent config without diff.'));
+        const hasErrors = await runSyncCommand({
+            scope,
+            updateSources: options.update !== false,
+        });
         console.log();
-        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')}`);
-                    }
-                }
-            }
-        }
-        if (scope?.project) {
-            // Dual sync: global first, then project
-            const { config: globalConfig, layers: globalLayers } = loadSwitchboardConfigWithLayers(scopeToLoadOptions(undefined));
-            await initTargets(globalConfig);
-            console.log(chalk.blue.bold('── Global ──'));
-            const globalErrors = await runSyncPhase({
-                scope: undefined,
-                config: globalConfig,
-                layers: globalLayers,
-            });
-            console.log();
-            resetAgentSyncCache();
-            console.log(chalk.blue.bold(`── Project: ${shortenPath(scope.project)} ──`));
-            const { config: projectConfig, layers: projectLayers } = loadSwitchboardConfigWithLayers(scopeToLoadOptions(scope));
-            // Register any project-level [targets] not seen during initTargets (which only ran once)
-            const projectTargets = projectConfig.targets;
-            if (projectTargets && Object.keys(projectTargets).length > 0) {
-                registerConfigTargets(projectTargets);
-            }
-            const projectErrors = await runSyncPhase({
-                scope,
-                config: projectConfig,
-                layers: projectLayers,
-            });
-            console.log();
-            if (globalErrors || projectErrors) {
-                console.log(chalk.red('✗ Sync completed with errors.'));
-                process.exit(1);
-            }
-            console.log(chalk.green('✓ Sync complete.'));
-        }
-        else {
-            const { config, layers } = loadSwitchboardConfigWithLayers(scopeToLoadOptions(scope));
-            await initTargets(config);
-            const hasErrors = await runSyncPhase({ scope, config, layers });
-            console.log();
-            if (hasErrors) {
-                console.log(chalk.red('✗ Sync completed with errors.'));
-                process.exit(1);
-            }
-            console.log(chalk.green('✓ Sync complete.'));
+        if (hasErrors) {
+            console.log(chalk.red('✗ Sync completed with errors.'));
+            process.exit(1);
         }
+        console.log(chalk.green('✓ Sync complete.'));
     }
     catch (error) {
         if (error instanceof Error) {
@@ -139,211 +94,6 @@ program
         process.exit(1);
     }
 });
-async function runSyncPhase({ scope, config, layers }) {
-    // Config summary
-    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 assumeInstalledSet = new Set(config.applications.assume_installed);
-    const appsLabel = config.applications.active.length > 0
-        ? config.applications.active
-            .map((id) => {
-            const t = getTargetById(id);
-            if (t?.isInstalled?.() === false) {
-                if (assumeInstalledSet.has(id))
-                    return chalk.yellow(`${id} (assumed installed)`);
-                return chalk.gray(`${id} (not installed)`);
-            }
-            return chalk.cyan(id);
-        })
-            .join(', ')
-        : chalk.gray('none configured');
-    console.log(`${chalk.blue('Apps:')}   ${appsLabel}`);
-    console.log();
-    const cursorSkillsDeduped = config.applications.active.includes('claude-code') &&
-        resolveEffectiveSectionConfig('skills', 'claude-code', scope).enabled.length > 0;
-    console.log(chalk.blue('Inventory:'));
-    {
-        const sections = ['mcp', 'rules', 'commands', 'agents', 'skills', 'hooks'];
-        const sectionPlatforms = {};
-        for (const s of sections) {
-            let ids = filterInstalled(getTargetsForSection(s), assumeInstalledSet).map((t) => t.id);
-            if (s === 'skills' && cursorSkillsDeduped) {
-                ids = ids.filter((id) => id !== 'cursor');
-            }
-            sectionPlatforms[s] = ids;
-        }
-        const termWidth = process.stdout.columns || 80;
-        const maxSectionLen = Math.max(...sections.map((s) => s.length));
-        const maxCountLen = Math.max(...sections.map((s) => `(${config[s].enabled.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].enabled;
-            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, resolveEffectiveSectionConfig(section, appId, scope).enabled);
-            }
-            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}`);
-            }
-        }
-    }
-    // Show enabled plugins summary
-    {
-        const pluginIndex = buildPluginIndex();
-        const enabledPluginRefs = config.plugins.enabled;
-        if (enabledPluginRefs.length > 0) {
-            const names = enabledPluginRefs
-                .map((pid) => {
-                const p = pluginIndex.get(pid);
-                return p ? pid : chalk.strikethrough(pid);
-            })
-                .join(', ');
-            console.log(`  ${chalk.magenta('plugins')} ${chalk.gray(`(${enabledPluginRefs.length})`)}  ${names}`);
-        }
-        else if (pluginIndex.plugins.length > 0) {
-            console.log(`  ${chalk.magenta('plugins')} ${chalk.gray('(0)')}  ${chalk.gray(`${pluginIndex.plugins.length} available`)}`);
-        }
-    }
-    console.log();
-    const notes = [];
-    if (cursorSkillsDeduped && config.applications.active.includes('cursor')) {
-        notes.push('cursor reads skills via claude-code');
-    }
-    if (config.distribution.use_agents_dir) {
-        const agentsMembers = ['codex', 'gemini', 'opencode'].filter((a) => config.applications.active.includes(a));
-        if (agentsMembers.length > 0) {
-            notes.push(`skills for ${agentsMembers.join(', ')} sync to shared .agents/skills`);
-        }
-    }
-    for (let i = 0; i < notes.length; i++) {
-        const prefix = i === 0 ? '  Note: ' : '        ';
-        console.log(chalk.gray(`${prefix}${notes[i]}.`));
-    }
-    if (notes.length > 0)
-        console.log();
-    const activeAppIds = config.applications.active;
-    const mcpDistribution = await applyToAgents(scope, undefined, {
-        useSpinner: false,
-        assumeInstalled: assumeInstalledSet,
-    });
-    const ruleDistribution = distributeRules(undefined, { activeAppIds, assumeInstalled: assumeInstalledSet }, scope);
-    const commandDistribution = distributeCommands(scope, activeAppIds, assumeInstalledSet);
-    const agentDistribution = distributeSubagents(scope, activeAppIds, assumeInstalledSet);
-    const skillDistribution = distributeSkills(scope, {
-        useAgentsDir: config.distribution.use_agents_dir,
-        activeAppIds,
-        assumeInstalled: assumeInstalledSet,
-    });
-    const hookDistribution = distributeHooks(scope, activeAppIds, assumeInstalledSet);
-    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;
-                if (sr.platform === 'agents') {
-                    const members = ['codex', 'gemini', 'opencode'].filter((a) => activeAppIds.includes(a));
-                    return members.length > 0 ? members.join('+') : 'agents';
-                }
-                return 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);
-    return hasErrors;
-}
 function resolveScope(input) {
     if (!input)
         return undefined;
@@ -357,14 +107,6 @@ function resolveScope(input) {
         project: project,
     };
 }
-function scopeToLoadOptions(scope) {
-    return scope
-        ? {
-            profile: scope.profile ?? undefined,
-            projectPath: scope.project ?? undefined,
-        }
-        : undefined;
-}
 function defaultCommandSourceDir(platform) {
     switch (platform) {
         case 'claude-code':
@@ -533,11 +275,11 @@ program
     .command('mcp')
     .description('Interactive UI to enable/disable MCP servers')
     .option('-p, --profile <name>', 'Profile configuration to use')
-    .option('--project <path>', 'Project directory containing .asb.toml')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .action(async (options) => {
     try {
         const scope = resolveScope(options);
-        const { config, layers } = loadSwitchboardConfigWithLayers(scopeToLoadOptions(scope));
+        const { config, layers } = loadSwitchboardConfigWithLayers(scopeToLayerOptions(scope));
         const mcpConfig = loadMcpConfig();
         // Determine initial selection:
         // - If writing to project/profile scope, only use that layer's explicit [mcp].enabled (no fallback).
@@ -585,7 +327,7 @@ program
             }
         }
         // Step 3: Apply to registered agents
-        await applyToAgents(scope, selectedServers);
+        await distributeMcp(scope, selectedServers);
         // Step 4: Show summary
         showSummary(selectedServers, scope);
     }
@@ -600,13 +342,13 @@ const ruleCommand = program
     .command('rule')
     .description('Select and order rule snippets interactively, then sync to agents')
     .option('-p, --profile <name>', 'Profile configuration to use')
-    .option('--project <path>', 'Project directory containing .asb.toml');
+    .option('-P, --project <path>', 'Project directory containing .asb.toml');
 ruleCommand
     .command('list')
     .description('Display rule snippets 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')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .action((options) => {
     try {
         const scope = resolveScope(options);
@@ -678,7 +420,7 @@ ruleCommand
 ruleCommand.action(async (options) => {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         await initTargets(config);
         const selection = await showRuleSelector({ scope, pageSize: config.ui.page_size });
         if (!selection) {
@@ -686,24 +428,22 @@ ruleCommand.action(async (options) => {
         }
         const rules = loadRuleLibrary();
         const ruleMap = new Map(rules.map((rule) => [rule.id, rule]));
-        const previousState = loadRuleState(scope);
+        const previousState = loadWritableRuleState(scope);
+        const effectiveState = loadRuleState(scope);
         const desiredEnabled = selection.enabled;
-        const arraysEqual = (a, b) => {
-            if (a.length !== b.length)
-                return false;
-            return a.every((value, index) => value === b[index]);
-        };
-        const selectionChanged = !arraysEqual(previousState.enabled, desiredEnabled);
-        const updatedState = updateRuleState((current) => {
-            if (!selectionChanged) {
-                return current;
-            }
-            return {
+        const selectionChanged = selection.explicitEmpty ||
+            shouldPersistSelection({
+                currentEnabled: previousState.enabled,
+                effectiveEnabled: effectiveState.enabled,
+                selectedEnabled: desiredEnabled,
+            });
+        const updatedState = selectionChanged
+            ? updateRuleState((current) => ({
                 ...current,
                 enabled: desiredEnabled,
                 agentSync: {},
-            };
-        }, scope);
+            }), scope)
+            : previousState;
         if (!selectionChanged) {
             console.log(chalk.gray('\nNo changes to enabled rules. Refreshing agent files...'));
         }
@@ -725,7 +465,7 @@ ruleCommand.action(async (options) => {
         }
         const distribution = distributeRules(composeActiveRules(scope), {
             force: !selectionChanged,
-            activeAppIds: config.applications.active,
+            activeAppIds: config.applications.enabled,
             assumeInstalled: new Set(config.applications.assume_installed),
         }, scope);
         if (distribution.results.length > 0) {
@@ -767,18 +507,18 @@ const commandRoot = program
     .command('command')
     .description('Select slash commands interactively and distribute to agents')
     .option('-p, --profile <name>', 'Profile configuration to use')
-    .option('--project <path>', 'Project directory containing .asb.toml');
+    .option('-P, --project <path>', 'Project directory containing .asb.toml');
 commandRoot.action(async (options) => {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         await initTargets(config);
         const selection = await showCommandSelector({ scope, pageSize: config.ui.page_size });
         if (!selection)
             return;
         console.log();
         printActiveSelection('commands', selection.enabled);
-        const out = distributeCommands(scope, config.applications.active, new Set(config.applications.assume_installed));
+        const out = distributeCommands(scope, config.applications.enabled, new Set(config.applications.assume_installed));
         if (out.results.length > 0) {
             console.log();
             printDistributionResults({
@@ -862,7 +602,7 @@ commandRoot
     .description('Display command 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')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .action((options) => {
     try {
         const scope = resolveScope(options);
@@ -917,18 +657,18 @@ 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');
+    .option('-P, --project <path>', 'Project directory containing .asb.toml');
 agentRoot.action(async (options) => {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         await initTargets(config);
         const selection = await showSubagentSelector({ scope, pageSize: config.ui.page_size });
         if (!selection)
             return;
         console.log();
         printActiveSelection('agents', selection.enabled);
-        const out = distributeSubagents(scope, config.applications.active, new Set(config.applications.assume_installed));
+        const out = distributeSubagents(scope, config.applications.enabled, new Set(config.applications.assume_installed));
         if (out.results.length > 0) {
             console.log();
             printDistributionResults({
@@ -1009,7 +749,7 @@ agentRoot
     .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')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .action((options) => {
     try {
         const scope = resolveScope(options);
@@ -1065,11 +805,11 @@ const skillRoot = program
     .command('skill')
     .description('Select skill bundles interactively and distribute to agents')
     .option('-p, --profile <name>', 'Profile configuration to use')
-    .option('--project <path>', 'Project directory containing .asb.toml');
+    .option('-P, --project <path>', 'Project directory containing .asb.toml');
 skillRoot.action(async (options) => {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         await initTargets(config);
         const selection = await showSkillSelector({ scope, pageSize: config.ui.page_size });
         if (!selection)
@@ -1078,7 +818,7 @@ skillRoot.action(async (options) => {
         printActiveSelection('skills', selection.enabled);
         const out = distributeSkills(scope, {
             useAgentsDir: config.distribution.use_agents_dir,
-            activeAppIds: config.applications.active,
+            activeAppIds: config.applications.enabled,
             assumeInstalled: new Set(config.applications.assume_installed),
         });
         if (out.results.length > 0) {
@@ -1088,7 +828,7 @@ skillRoot.action(async (options) => {
                 results: out.results,
                 getTargetLabel: (result) => {
                     if (result.platform === 'agents') {
-                        const members = ['codex', 'gemini', 'opencode'].filter((a) => config.applications.active.includes(a));
+                        const members = ['codex', 'gemini', 'opencode'].filter((a) => config.applications.enabled.includes(a));
                         return members.length > 0 ? members.join('+') : 'agents';
                     }
                     return result.platform;
@@ -1109,7 +849,7 @@ skillRoot
     .description('Display skill 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')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .action((options) => {
     try {
         const scope = resolveScope(options);
@@ -1215,17 +955,17 @@ 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');
+    .option('-P, --project <path>', 'Project directory containing .asb.toml');
 hookRoot.action(async (options) => {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         const selection = await showHookSelector({ scope, pageSize: config.ui.page_size });
         if (!selection)
             return;
         console.log();
         printActiveSelection('hooks', selection.enabled);
-        const out = distributeHooks(scope, config.applications.active, new Set(config.applications.assume_installed));
+        const out = distributeHooks(scope, config.applications.enabled, new Set(config.applications.assume_installed));
         if (out.results.length > 0) {
             console.log();
             printDistributionResults({
@@ -1248,7 +988,7 @@ hookRoot
     .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')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .action((options) => {
     try {
         const scope = resolveScope(options);
@@ -1377,114 +1117,6 @@ hookRoot
         process.exit(1);
     }
 });
-async function applyToAgents(scope, enabledServerNames, options) {
-    const mcpConfig = loadMcpConfigWithPlugins(scope);
-    const switchboardConfig = loadSwitchboardConfig(scopeToLoadOptions(scope));
-    await initTargets(switchboardConfig);
-    const useSpinner = options?.useSpinner ?? true;
-    const assumeInstalled = options?.assumeInstalled ?? new Set(switchboardConfig.applications.assume_installed);
-    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 ?? loadMcpEnabledState(scope);
-    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 {
-            const agentMcpConfig = resolveEffectiveSectionConfig('mcp', agentId, scope);
-            // If user selected servers via UI, use that as base; otherwise use per-agent resolved config
-            const agentActiveServers = enabledServerNames
-                ? agentMcpConfig.enabled.filter((s) => globalMcpServers.includes(s))
-                : agentMcpConfig.enabled;
-            // Filter to only enabled servers for this agent
-            const activeSet = new Set(agentActiveServers);
-            const enabledServers = Object.fromEntries(Object.entries(mcpConfig.mcpServers).filter(([name]) => activeSet.has(name)));
-            const configToApply = { mcpServers: enabledServers };
-            const target = getTargetById(agentId);
-            if (!assumeInstalled.has(agentId) && target?.isInstalled?.() === false) {
-                persist(chalk.gray('○'), `${chalk.cyan(agentId)} ${chalk.gray('(not installed, skipped)')}`);
-                results.push({
-                    application: agentId,
-                    filePath: '(not installed)',
-                    status: 'skipped',
-                    reason: 'not installed',
-                });
-                continue;
-            }
-            if (!target?.mcp) {
-                persist(chalk.yellow('⚠'), `${chalk.cyan(agentId)} - no MCP handler (skipped)`);
-                results.push({
-                    application: agentId,
-                    filePath: '(unknown)',
-                    status: 'skipped',
-                    reason: 'no MCP handler',
-                });
-                continue;
-            }
-            const mcpHandler = target.mcp;
-            const readFileSafe = (p) => {
-                try {
-                    return fs.readFileSync(p, 'utf-8');
-                }
-                catch {
-                    return null;
-                }
-            };
-            if (scope?.project && mcpHandler.applyProjectConfig) {
-                const projectPath = mcpHandler.projectConfigPath?.(scope.project) ?? 'project config';
-                const before = readFileSafe(projectPath);
-                mcpHandler.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 = mcpHandler.configPath();
-                const before = readFileSafe(configPath);
-                mcpHandler.applyConfig(configToApply);
-                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
  */
@@ -1507,10 +1139,10 @@ function showSummary(selectedServers, scope) {
             console.log(`  ${chalk.gray('✗')} ${server}`);
         }
     }
-    const switchboardConfig = loadSwitchboardConfig(scopeToLoadOptions(scope));
-    if (switchboardConfig.applications.active.length > 0) {
-        console.log(chalk.blue(`\nApplied to applications (${switchboardConfig.applications.active.length}):`));
-        for (const agent of switchboardConfig.applications.active) {
+    const switchboardConfig = loadSwitchboardConfig(scopeToLayerOptions(scope));
+    if (switchboardConfig.applications.enabled.length > 0) {
+        console.log(chalk.blue(`\nApplied to applications (${switchboardConfig.applications.enabled.length}):`));
+        for (const agent of switchboardConfig.applications.enabled) {
             console.log(`  ${chalk.dim('•')} ${agent}`);
         }
     }
@@ -1539,7 +1171,7 @@ const pluginRoot = program
     .command('plugin')
     .description('Manage plugins: interactive selection, install/uninstall, marketplace sources')
     .option('-p, --profile <name>', 'Profile configuration to use')
-    .option('--project <path>', 'Project directory containing .asb.toml');
+    .option('-P, --project <path>', 'Project directory containing .asb.toml');
 pluginRoot.action((_options) => {
     pluginRoot.outputHelp();
 });
@@ -1548,13 +1180,13 @@ pluginRoot
     .alias('ls')
     .description('List all discoverable plugins from configured sources')
     .option('-p, --profile <name>', 'Profile configuration to use')
-    .option('--project <path>', 'Project directory containing .asb.toml')
+    .option('-P, --project <path>', 'Project directory containing .asb.toml')
     .option('--json', 'Output as JSON')
     .action((options) => {
     try {
         const index = buildPluginIndex();
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         const enabledList = config.plugins.enabled;
         const enabledSet = new Set(enabledList);
         if (options.json) {
@@ -1606,7 +1238,7 @@ pluginRoot
 function pluginEnableAction(id, options) {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         if (config.plugins.enabled.includes(id)) {
             console.log(chalk.yellow(`⚠ Plugin "${id}" is already enabled.`));
             return;
@@ -1623,7 +1255,7 @@ function pluginEnableAction(id, options) {
                 ...(layer.plugins ?? {}),
                 enabled: [...(layer.plugins?.enabled ?? []), id],
             },
-        }), scopeToLoadOptions(scope));
+        }), scopeToLayerOptions(scope));
         console.log(chalk.green(`✓ Plugin "${id}" enabled.`));
     }
     catch (error) {
@@ -1636,7 +1268,7 @@ function pluginEnableAction(id, options) {
 function pluginDisableAction(id, options) {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         if (!config.plugins.enabled.includes(id)) {
             console.log(chalk.yellow(`⚠ Plugin "${id}" is not enabled.`));
             return;
@@ -1647,7 +1279,7 @@ function pluginDisableAction(id, options) {
                 ...(layer.plugins ?? {}),
                 enabled: (layer.plugins?.enabled ?? []).filter((x) => x !== id),
             },
-        }), scopeToLoadOptions(scope));
+        }), scopeToLayerOptions(scope));
         console.log(chalk.green(`✓ Plugin "${id}" disabled.`));
     }
     catch (error) {
@@ -1660,7 +1292,7 @@ function pluginDisableAction(id, options) {
 function pluginUninstallAction(id, options) {
     try {
         const scope = resolveScope(options);
-        const config = loadSwitchboardConfig(scopeToLoadOptions(scope));
+        const config = loadSwitchboardConfig(scopeToLayerOptions(scope));
         if (!config.plugins.enabled.includes(id)) {
             console.log(chalk.yellow(`⚠ Plugin "${id}" is not enabled.`));
             return;
@@ -1671,7 +1303,7 @@ function pluginUninstallAction(id, options) {
                 ...(layer.plugins ?? {}),
                 enabled: (layer.plugins?.enabled ?? []).filter((x) => x !== id),
             },
-        }), scopeToLoadOptions(scope));
+        }), scopeToLayerOptions(scope));
         console.log(chalk.green(`✓ Plugin "${id}" uninstalled.`));
     }
     catch (error) {
@@ -1683,7 +1315,7 @@ function pluginUninstallAction(id, options) {
 }
 const pluginScopeOpts = [
     ['-p, --profile <name>', 'Profile configuration to use'],
-    ['--project <path>', 'Project directory containing .asb.toml'],
+    ['-P, --project <path>', 'Project directory containing .asb.toml'],
 ];
 const enableCmd = pluginRoot.command('enable <id>').description('Add a plugin to the enabled list');
 for (const [flag, desc] of pluginScopeOpts)