@swarmify/agents-cli 1.5.13 → 1.5.15

package/dist/index.js

@@ -16,7 +16,7 @@ function isPromptCancelled(err) {
         err.message.includes('force closed') ||
         err.message.includes('User force closed'));
 }
-import { AGENTS, ALL_AGENT_IDS, MCP_CAPABLE_AGENTS, SKILLS_CAPABLE_AGENTS, HOOKS_CAPABLE_AGENTS, getAllCliStates, isCliInstalled, getCliVersion, isMcpRegistered, registerMcp, unregisterMcp, listInstalledMcpsWithScope, promoteMcpToUser, } from './lib/agents.js';
+import { AGENTS, ALL_AGENT_IDS, MCP_CAPABLE_AGENTS, SKILLS_CAPABLE_AGENTS, HOOKS_CAPABLE_AGENTS, getAllCliStates, getCliVersion, isMcpRegistered, registerMcp, unregisterMcp, listInstalledMcpsWithScope, promoteMcpToUser, } from './lib/agents.js';
 import { readManifest, writeManifest, createDefaultManifest, MANIFEST_FILENAME, } from './lib/manifest.js';
 import { readState, ensureAgentsDir, getRepoLocalPath, getScope, setScope, removeScope, getScopesByPriority, getScopePriority, } from './lib/state.js';
 import { SCOPE_PRIORITIES, DEFAULT_SYSTEM_REPO } from './lib/types.js';
@@ -24,8 +24,11 @@ import { cloneRepo, parseSource } from './lib/git.js';
 import { discoverCommands, resolveCommandSource, installCommand, uninstallCommand, listInstalledCommandsWithScope, promoteCommandToUser, commandExists, commandContentMatches, } from './lib/commands.js';
 import { discoverHooksFromRepo, installHooks, listInstalledHooksWithScope, promoteHookToUser, removeHook, hookExists, hookContentMatches, getSourceHookEntry, } from './lib/hooks.js';
 import { discoverSkillsFromRepo, installSkill, uninstallSkill, listInstalledSkillsWithScope, promoteSkillToUser, getSkillInfo, getSkillRules, skillExists, skillContentMatches, } from './lib/skills.js';
+import { discoverInstructionsFromRepo, resolveInstructionsSource, installInstructions, uninstallInstructions, listInstalledInstructionsWithScope, promoteInstructionsToUser, instructionsExists, instructionsContentMatches, getInstructionsContent, } from './lib/instructions.js';
 import { DEFAULT_REGISTRIES } from './lib/types.js';
 import { search as searchRegistries, getRegistries, setRegistry, removeRegistry, resolvePackage, } from './lib/registry.js';
+import { parseAgentSpec, installVersion, removeVersion, removeAllVersions, listInstalledVersions, getGlobalDefault, setGlobalDefault, isVersionInstalled, } from './lib/versions.js';
+import { createShim, removeShim, shimExists, isShimsInPath, getPathSetupInstructions, getShimsDir, } from './lib/shims.js';
 const program = new Command();
 /**
  * Ensure at least one scope is configured.
@@ -179,6 +182,10 @@ program
         agent: AGENTS[agentId],
         mcps: listInstalledMcpsWithScope(agentId, cwd),
     }));
+    const instructionsData = agentsToShow.map((agentId) => ({
+        agent: AGENTS[agentId],
+        instructions: listInstalledInstructionsWithScope(agentId, cwd),
+    }));
     const scopes = filterAgentId ? [] : getScopesByPriority();
     spinner.stop();
     // Helper to format MCP with version
@@ -249,6 +256,23 @@ program
             }
         }
     }
+    console.log(chalk.bold('\nInstalled Instructions\n'));
+    for (const { agent, instructions } of instructionsData) {
+        const userInstr = instructions.find((i) => i.scope === 'user' && i.exists);
+        const projectInstr = instructions.find((i) => i.scope === 'project' && i.exists);
+        if (!userInstr && !projectInstr) {
+            console.log(`  ${chalk.bold(agent.name)}: ${chalk.gray('none')}`);
+        }
+        else {
+            console.log(`  ${chalk.bold(agent.name)}:`);
+            if (userInstr) {
+                console.log(`    ${chalk.gray('User:')} ${chalk.cyan(agent.instructionsFile)}`);
+            }
+            if (projectInstr) {
+                console.log(`    ${chalk.gray('Project:')} ${chalk.yellow(agent.instructionsFile)}`);
+            }
+        }
+    }
     // Only show scopes when not filtering by agent
     if (!filterAgentId) {
         if (scopes.length > 0) {
@@ -364,6 +388,9 @@ program
         const allCommands = discoverCommands(localPath);
         const allSkills = discoverSkillsFromRepo(localPath);
         const discoveredHooks = discoverHooksFromRepo(localPath);
+        const allInstructions = discoverInstructionsFromRepo(localPath);
+        const allDiscoveredJobs = discoverJobsFromRepo(localPath);
+        const allDiscoveredDrives = discoverDrivesFromRepo(localPath);
         // Determine which agents to sync
         const cliStates = await getAllCliStates();
         let selectedAgents;
@@ -506,12 +533,51 @@ program
                 }
             }
         }
+        // Process instructions
+        for (const instr of allInstructions) {
+            if (!selectedAgents.includes(instr.agentId))
+                continue;
+            const hasExisting = instructionsExists(instr.agentId, 'user');
+            if (!hasExisting) {
+                newItems.push({ type: 'instructions', name: AGENTS[instr.agentId].instructionsFile, agents: [instr.agentId], isNew: true });
+            }
+            else if (instructionsContentMatches(instr.agentId, instr.sourcePath, 'user')) {
+                upToDateItems.push({ type: 'instructions', name: AGENTS[instr.agentId].instructionsFile, agents: [instr.agentId], isNew: false });
+            }
+            else {
+                existingItems.push({ type: 'instructions', name: AGENTS[instr.agentId].instructionsFile, agents: [instr.agentId], isNew: false });
+            }
+        }
+        // Process jobs
+        for (const discoveredJob of allDiscoveredJobs) {
+            if (!jobExists(discoveredJob.name)) {
+                newItems.push({ type: 'job', name: discoveredJob.name, agents: [], isNew: true });
+            }
+            else if (jobContentMatches(discoveredJob.name, discoveredJob.path)) {
+                upToDateItems.push({ type: 'job', name: discoveredJob.name, agents: [], isNew: false });
+            }
+            else {
+                existingItems.push({ type: 'job', name: discoveredJob.name, agents: [], isNew: false });
+            }
+        }
+        // Process drives
+        for (const discoveredDrive of allDiscoveredDrives) {
+            if (!driveExists(discoveredDrive.name)) {
+                newItems.push({ type: 'drive', name: discoveredDrive.name, agents: [], isNew: true });
+            }
+            else if (driveContentMatches(discoveredDrive.name, discoveredDrive.path)) {
+                upToDateItems.push({ type: 'drive', name: discoveredDrive.name, agents: [], isNew: false });
+            }
+            else {
+                existingItems.push({ type: 'drive', name: discoveredDrive.name, agents: [], isNew: false });
+            }
+        }
         // Display overview
         console.log(chalk.bold('\nOverview\n'));
         const formatAgentList = (agents) => agents.map((id) => AGENTS[id].name).join(', ');
         if (newItems.length > 0) {
             console.log(chalk.green('  NEW (will install):\n'));
-            const byType = { command: [], skill: [], hook: [], mcp: [] };
+            const byType = { command: [], skill: [], hook: [], mcp: [], instructions: [], job: [], drive: [] };
             for (const item of newItems)
                 byType[item.type].push(item);
             if (byType.command.length > 0) {
@@ -538,11 +604,29 @@ program
                     console.log(`      ${chalk.cyan(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
                 }
             }
+            if (byType.instructions.length > 0) {
+                console.log(`    Instructions:`);
+                for (const item of byType.instructions) {
+                    console.log(`      ${chalk.cyan(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
+            }
+            if (byType.job.length > 0) {
+                console.log(`    Jobs:`);
+                for (const item of byType.job) {
+                    console.log(`      ${chalk.cyan(item.name)}`);
+                }
+            }
+            if (byType.drive.length > 0) {
+                console.log(`    Drives:`);
+                for (const item of byType.drive) {
+                    console.log(`      ${chalk.cyan(item.name)}`);
+                }
+            }
             console.log();
         }
         if (upToDateItems.length > 0) {
             console.log(chalk.gray('  UP TO DATE (no changes):\n'));
-            const byType = { command: [], skill: [], hook: [], mcp: [] };
+            const byType = { command: [], skill: [], hook: [], mcp: [], instructions: [], job: [], drive: [] };
             for (const item of upToDateItems)
                 byType[item.type].push(item);
             if (byType.command.length > 0) {
@@ -563,11 +647,29 @@ program
                     console.log(`      ${chalk.dim(item.name.padEnd(20))} ${chalk.dim(formatAgentList(item.agents))}`);
                 }
             }
+            if (byType.instructions.length > 0) {
+                console.log(`    Instructions:`);
+                for (const item of byType.instructions) {
+                    console.log(`      ${chalk.dim(item.name.padEnd(20))} ${chalk.dim(formatAgentList(item.agents))}`);
+                }
+            }
+            if (byType.job.length > 0) {
+                console.log(`    Jobs:`);
+                for (const item of byType.job) {
+                    console.log(`      ${chalk.dim(item.name)}`);
+                }
+            }
+            if (byType.drive.length > 0) {
+                console.log(`    Drives:`);
+                for (const item of byType.drive) {
+                    console.log(`      ${chalk.dim(item.name)}`);
+                }
+            }
             console.log();
         }
         if (existingItems.length > 0) {
             console.log(chalk.yellow('  EXISTING (conflicts):\n'));
-            const byType = { command: [], skill: [], hook: [], mcp: [] };
+            const byType = { command: [], skill: [], hook: [], mcp: [], instructions: [], job: [], drive: [] };
             for (const item of existingItems)
                 byType[item.type].push(item);
             if (byType.command.length > 0) {
@@ -594,6 +696,24 @@ program
                     console.log(`      ${chalk.yellow(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
                 }
             }
+            if (byType.instructions.length > 0) {
+                console.log(`    Instructions:`);
+                for (const item of byType.instructions) {
+                    console.log(`      ${chalk.yellow(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
+            }
+            if (byType.job.length > 0) {
+                console.log(`    Jobs:`);
+                for (const item of byType.job) {
+                    console.log(`      ${chalk.yellow(item.name)}`);
+                }
+            }
+            if (byType.drive.length > 0) {
+                console.log(`    Drives:`);
+                for (const item of byType.drive) {
+                    console.log(`      ${chalk.yellow(item.name)}`);
+                }
+            }
             console.log();
         }
         if (newItems.length === 0 && existingItems.length === 0) {
@@ -666,8 +786,8 @@ program
         }
         // Install new items (no conflicts)
         console.log();
-        let installed = { commands: 0, skills: 0, hooks: 0, mcps: 0 };
-        let skipped = { commands: 0, skills: 0, hooks: 0, mcps: 0 };
+        let installed = { commands: 0, skills: 0, hooks: 0, mcps: 0, instructions: 0, jobs: 0, drives: 0 };
+        let skipped = { commands: 0, skills: 0, hooks: 0, mcps: 0, instructions: 0, jobs: 0, drives: 0 };
         // Install commands
         const cmdSpinner = ora('Installing commands...').start();
         for (const item of [...newItems, ...existingItems].filter((i) => i.type === 'command')) {
@@ -679,8 +799,13 @@ program
             for (const agentId of item.agents) {
                 const sourcePath = resolveCommandSource(localPath, item.name, agentId);
                 if (sourcePath) {
-                    installCommand(sourcePath, agentId, item.name, method);
-                    installed.commands++;
+                    const result = installCommand(sourcePath, agentId, item.name, method);
+                    if (result.error) {
+                        console.log(chalk.yellow(`\n  Warning: ${item.name} (${AGENTS[agentId].name}): ${result.error}`));
+                    }
+                    else {
+                        installed.commands++;
+                    }
                 }
             }
         }
@@ -759,6 +884,104 @@ program
                 mcpSpinner.info('No MCP servers to register');
             }
         }
+        // Install instructions
+        const instructionItems = [...newItems, ...existingItems].filter((i) => i.type === 'instructions');
+        if (instructionItems.length > 0) {
+            const instrSpinner = ora('Installing instructions...').start();
+            for (const item of instructionItems) {
+                const decision = item.isNew ? 'overwrite' : decisions.get(`instructions:${item.name}`);
+                if (decision === 'skip') {
+                    skipped.instructions++;
+                    continue;
+                }
+                for (const agentId of item.agents) {
+                    const sourcePath = resolveInstructionsSource(localPath, agentId);
+                    if (sourcePath) {
+                        const result = installInstructions(sourcePath, agentId, method);
+                        if (result.error) {
+                            console.log(chalk.yellow(`\n  Warning: ${item.name} (${AGENTS[agentId].name}): ${result.error}`));
+                        }
+                        else {
+                            installed.instructions++;
+                        }
+                    }
+                }
+            }
+            if (skipped.instructions > 0) {
+                instrSpinner.succeed(`Installed ${installed.instructions} instructions (skipped ${skipped.instructions})`);
+            }
+            else if (installed.instructions > 0) {
+                instrSpinner.succeed(`Installed ${installed.instructions} instructions`);
+            }
+            else {
+                instrSpinner.info('No instructions to install');
+            }
+        }
+        // Install jobs
+        const jobItems = [...newItems, ...existingItems].filter((i) => i.type === 'job');
+        if (jobItems.length > 0) {
+            const jobSpinner = ora('Installing jobs...').start();
+            for (const item of jobItems) {
+                const decision = item.isNew ? 'overwrite' : decisions.get(`job:${item.name}`);
+                if (decision === 'skip') {
+                    skipped.jobs++;
+                    continue;
+                }
+                const discovered = allDiscoveredJobs.find((j) => j.name === item.name);
+                if (discovered) {
+                    const result = installJobFromSource(discovered.path, discovered.name);
+                    if (result.success) {
+                        installed.jobs++;
+                    }
+                    else {
+                        console.log(chalk.yellow(`\n  Warning: job ${item.name}: ${result.error}`));
+                    }
+                }
+            }
+            if (skipped.jobs > 0) {
+                jobSpinner.succeed(`Installed ${installed.jobs} jobs (skipped ${skipped.jobs})`);
+            }
+            else if (installed.jobs > 0) {
+                jobSpinner.succeed(`Installed ${installed.jobs} jobs`);
+            }
+            else {
+                jobSpinner.info('No jobs to install');
+            }
+            if (installed.jobs > 0 && isDaemonRunning()) {
+                signalDaemonReload();
+            }
+        }
+        // Install drives
+        const driveItems = [...newItems, ...existingItems].filter((i) => i.type === 'drive');
+        if (driveItems.length > 0) {
+            const driveSpinner = ora('Installing drives...').start();
+            for (const item of driveItems) {
+                const decision = item.isNew ? 'overwrite' : decisions.get(`drive:${item.name}`);
+                if (decision === 'skip') {
+                    skipped.drives++;
+                    continue;
+                }
+                const discovered = allDiscoveredDrives.find((d) => d.name === item.name);
+                if (discovered) {
+                    const result = installDriveFromSource(discovered.path, discovered.name);
+                    if (result.success) {
+                        installed.drives++;
+                    }
+                    else {
+                        console.log(chalk.yellow(`\n  Warning: drive ${item.name}: ${result.error}`));
+                    }
+                }
+            }
+            if (skipped.drives > 0) {
+                driveSpinner.succeed(`Installed ${installed.drives} drives (skipped ${skipped.drives})`);
+            }
+            else if (installed.drives > 0) {
+                driveSpinner.succeed(`Installed ${installed.drives} drives`);
+            }
+            else {
+                driveSpinner.info('No drives to install');
+            }
+        }
         // Sync CLI versions (user scope only)
         if (isUserScope && !options.skipClis && manifest?.clis) {
             const cliSpinner = ora('Checking CLI versions...').start();
@@ -852,6 +1075,44 @@ program
             exported++;
         }
     }
+    // Export MCP servers from installed agents
+    console.log();
+    let mcpExported = 0;
+    const mcpByName = new Map();
+    for (const agentId of MCP_CAPABLE_AGENTS) {
+        if (!cliStates[agentId]?.installed)
+            continue;
+        const mcps = listInstalledMcpsWithScope(agentId);
+        for (const mcp of mcps) {
+            if (mcp.scope !== 'user')
+                continue; // Only export user-scoped MCPs
+            const existing = mcpByName.get(mcp.name);
+            if (existing) {
+                if (!existing.agents.includes(agentId)) {
+                    existing.agents.push(agentId);
+                }
+            }
+            else {
+                mcpByName.set(mcp.name, {
+                    command: mcp.command || '',
+                    agents: [agentId],
+                });
+            }
+        }
+    }
+    if (mcpByName.size > 0) {
+        manifest.mcp = manifest.mcp || {};
+        for (const [name, config] of mcpByName) {
+            manifest.mcp[name] = {
+                command: config.command,
+                transport: 'stdio',
+                agents: config.agents,
+                scope: 'user',
+            };
+            console.log(`  ${chalk.green('+')} MCP: ${name} (${config.agents.map(id => AGENTS[id].name).join(', ')})`);
+            mcpExported++;
+        }
+    }
     if (!options.exportOnly) {
         writeManifest(localPath, manifest);
         console.log(chalk.bold(`\nUpdated ${MANIFEST_FILENAME}`));
@@ -952,8 +1213,13 @@ commandsCmd
                     continue;
                 const sourcePath = resolveCommandSource(localPath, command.name, agentId);
                 if (sourcePath) {
-                    installCommand(sourcePath, agentId, command.name, 'symlink');
-                    console.log(`    ${chalk.green('+')} ${AGENTS[agentId].name}`);
+                    const result = installCommand(sourcePath, agentId, command.name, 'symlink');
+                    if (result.error) {
+                        console.log(`    ${chalk.yellow('!')} ${AGENTS[agentId].name}: ${result.error}`);
+                    }
+                    else {
+                        console.log(`    ${chalk.green('+')} ${AGENTS[agentId].name}`);
+                    }
                 }
             }
         }
@@ -1427,6 +1693,152 @@ skillsCmd
     }
 });
 // =============================================================================
+// INSTRUCTIONS COMMANDS
+// =============================================================================
+const instructionsCmd = program
+    .command('instructions')
+    .alias('instr')
+    .description('Manage agent instructions (CLAUDE.md, GEMINI.md, etc.)');
+instructionsCmd
+    .command('list')
+    .description('List installed instructions files')
+    .option('-a, --agent <agent>', 'Filter by agent')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const agents = options.agent
+        ? [resolveAgentName(options.agent)].filter(Boolean)
+        : ALL_AGENT_IDS;
+    console.log(chalk.bold('Installed Instructions\n'));
+    for (const agentId of agents) {
+        const agent = AGENTS[agentId];
+        const installed = listInstalledInstructionsWithScope(agentId, cwd);
+        const userInstr = installed.find((i) => i.scope === 'user');
+        const projectInstr = installed.find((i) => i.scope === 'project');
+        const userStatus = userInstr?.exists ? chalk.green(agent.instructionsFile) : chalk.gray('none');
+        const projectStatus = projectInstr?.exists ? chalk.yellow(agent.instructionsFile) : chalk.gray('none');
+        console.log(`  ${chalk.bold(agent.name)}:`);
+        console.log(`    ${chalk.gray('User:')} ${userStatus}`);
+        console.log(`    ${chalk.gray('Project:')} ${projectStatus}`);
+        console.log();
+    }
+});
+instructionsCmd
+    .command('view [agent]')
+    .alias('show')
+    .description('View instructions content for an agent')
+    .option('-s, --scope <scope>', 'Scope: user or project', 'user')
+    .action(async (agentArg, options) => {
+    const cwd = process.cwd();
+    let agentId;
+    if (agentArg) {
+        agentId = resolveAgentName(agentArg) || undefined;
+        if (!agentId) {
+            console.log(chalk.red(`Unknown agent: ${agentArg}`));
+            process.exit(1);
+        }
+    }
+    else {
+        const choices = ALL_AGENT_IDS.filter((id) => instructionsExists(id, 'user', cwd) || instructionsExists(id, 'project', cwd));
+        if (choices.length === 0) {
+            console.log(chalk.yellow('No instructions files found.'));
+            return;
+        }
+        agentId = await select({
+            message: 'Select agent:',
+            choices: choices.map((id) => ({ name: AGENTS[id].name, value: id })),
+        });
+    }
+    const scope = (options?.scope || 'user');
+    const content = getInstructionsContent(agentId, scope, cwd);
+    if (!content) {
+        console.log(chalk.yellow(`No ${scope} instructions found for ${AGENTS[agentId].name}`));
+        return;
+    }
+    console.log(chalk.bold(`\n${AGENTS[agentId].name} Instructions (${scope}):\n`));
+    console.log(content);
+});
+instructionsCmd
+    .command('diff [agent]')
+    .description('Show differences between local and repo instructions')
+    .action(async (agentArg) => {
+    const cwd = process.cwd();
+    const meta = readState();
+    const scopes = getScopesByPriority();
+    if (scopes.length === 0) {
+        console.log(chalk.yellow('No repo configured. Run: agents repo add <source>'));
+        return;
+    }
+    const agents = agentArg
+        ? [resolveAgentName(agentArg)].filter(Boolean)
+        : ALL_AGENT_IDS;
+    const diff = await import('diff');
+    for (const { name: scopeName, config } of scopes) {
+        const localPath = getRepoLocalPath(config.source);
+        const repoInstructions = discoverInstructionsFromRepo(localPath);
+        for (const agentId of agents) {
+            const repoInstr = repoInstructions.find((i) => i.agentId === agentId);
+            if (!repoInstr)
+                continue;
+            const installedContent = getInstructionsContent(agentId, 'user', cwd);
+            if (!installedContent) {
+                console.log(`${chalk.bold(AGENTS[agentId].name)}: ${chalk.green('NEW')} (not installed)`);
+                continue;
+            }
+            const repoContent = fs.readFileSync(repoInstr.sourcePath, 'utf-8');
+            if (installedContent.trim() === repoContent.trim()) {
+                console.log(`${chalk.bold(AGENTS[agentId].name)}: ${chalk.gray('up to date')}`);
+                continue;
+            }
+            console.log(`${chalk.bold(AGENTS[agentId].name)}:`);
+            const changes = diff.diffLines(installedContent, repoContent);
+            for (const change of changes) {
+                if (change.added) {
+                    process.stdout.write(chalk.green(change.value));
+                }
+                else if (change.removed) {
+                    process.stdout.write(chalk.red(change.value));
+                }
+            }
+            console.log();
+        }
+    }
+});
+instructionsCmd
+    .command('push <agent>')
+    .description('Save project-scoped instructions to user scope')
+    .action((agentArg) => {
+    const cwd = process.cwd();
+    const agentId = resolveAgentName(agentArg);
+    if (!agentId) {
+        console.log(chalk.red(`Unknown agent: ${agentArg}`));
+        process.exit(1);
+    }
+    const result = promoteInstructionsToUser(agentId, cwd);
+    if (result.success) {
+        console.log(chalk.green(`Pushed ${AGENTS[agentId].instructionsFile} to user scope`));
+    }
+    else {
+        console.log(chalk.red(result.error || 'Failed to push instructions'));
+    }
+});
+instructionsCmd
+    .command('remove <agent>')
+    .description('Remove user-scoped instructions for an agent')
+    .action((agentArg) => {
+    const agentId = resolveAgentName(agentArg);
+    if (!agentId) {
+        console.log(chalk.red(`Unknown agent: ${agentArg}`));
+        process.exit(1);
+    }
+    const result = uninstallInstructions(agentId);
+    if (result) {
+        console.log(chalk.green(`Removed ${AGENTS[agentId].instructionsFile}`));
+    }
+    else {
+        console.log(chalk.yellow(`No instructions file found for ${AGENTS[agentId].name}`));
+    }
+});
+// =============================================================================
 // MCP COMMANDS
 // =============================================================================
 const mcpCmd = program
@@ -1641,207 +2053,313 @@ mcpCmd
     }
 });
 // =============================================================================
-// CLI COMMANDS
+// VERSION MANAGEMENT COMMANDS (add, remove, use, list, upgrade)
 // =============================================================================
-const cliCmd = program
-    .command('cli')
-    .description('Manage agent CLIs');
-cliCmd
-    .command('list')
-    .description('List installed agent CLIs')
-    .action(async () => {
-    const spinner = ora('Checking installed CLIs...').start();
-    const states = await getAllCliStates();
-    spinner.stop();
-    console.log(chalk.bold('Agent CLIs\n'));
-    for (const agentId of ALL_AGENT_IDS) {
-        const agent = AGENTS[agentId];
-        const state = states[agentId];
-        if (state?.installed) {
-            console.log(`  ${agent.name.padEnd(14)} ${chalk.green(state.version || 'installed')}`);
-            if (state.path) {
-                console.log(`  ${''.padEnd(14)} ${chalk.gray(state.path)}`);
-            }
+program
+    .command('add <specs...>')
+    .description('Install agent CLI(s). Examples: agents add claude@1.5.0, agents add claude codex')
+    .option('-p, --project', 'Pin version in project manifest (.agents/agents.yaml)')
+    .action(async (specs, options) => {
+    const isProject = options.project;
+    for (const spec of specs) {
+        const parsed = parseAgentSpec(spec);
+        if (!parsed) {
+            console.log(chalk.red(`Invalid agent: ${spec}`));
+            console.log(chalk.gray(`Format: <agent>[@version]. Available: ${ALL_AGENT_IDS.join(', ')}`));
+            continue;
         }
-        else {
-            console.log(`  ${agent.name.padEnd(14)} ${chalk.gray('not installed')}`);
-        }
-    }
-});
-cliCmd
-    .command('add <agents...>')
-    .description('Install agent CLI(s)')
-    .option('-v, --version <version>', 'Version to install', 'latest')
-    .option('--manifest-only', 'Only add to manifest, do not install')
-    .action(async (agents, options) => {
-    const validAgents = [];
-    for (const agent of agents) {
-        const agentId = agent.toLowerCase();
-        if (!AGENTS[agentId]) {
-            console.log(chalk.red(`Unknown agent: ${agent}`));
-            console.log(chalk.gray(`Available: ${ALL_AGENT_IDS.join(', ')}`));
-            return;
+        const { agent, version } = parsed;
+        const agentConfig = AGENTS[agent];
+        if (!agentConfig.npmPackage) {
+            console.log(chalk.yellow(`${agentConfig.name} has no npm package. Install manually.`));
+            continue;
         }
-        validAgents.push(agentId);
-    }
-    const { exec } = await import('child_process');
-    const { promisify } = await import('util');
-    const execAsync = promisify(exec);
-    const version = options.version;
-    for (const agentId of validAgents) {
-        const agentConfig = AGENTS[agentId];
-        const pkg = agentConfig.npmPackage;
-        const installScript = agentConfig.installScript;
-        if (!options.manifestOnly) {
-            if (pkg) {
-                const spinner = ora(`Installing ${agentConfig.name}@${version}...`).start();
-                try {
-                    await execAsync(`npm install -g ${pkg}@${version}`);
-                    spinner.succeed(`Installed ${agentConfig.name}@${version}`);
-                }
-                catch (err) {
-                    spinner.fail(`Failed to install ${agentConfig.name}`);
-                    console.error(chalk.gray(err.message));
-                    continue;
-                }
-            }
-            else if (installScript) {
-                const spinner = ora(`Installing ${agentConfig.name}...`).start();
-                try {
-                    await execAsync(installScript, { shell: '/bin/bash' });
-                    spinner.succeed(`Installed ${agentConfig.name}`);
+        // Check if already installed
+        if (isVersionInstalled(agent, version)) {
+            console.log(chalk.gray(`${agentConfig.name}@${version} already installed`));
+        }
+        else {
+            const spinner = ora(`Installing ${agentConfig.name}@${version}...`).start();
+            const result = await installVersion(agent, version, (msg) => {
+                spinner.text = msg;
+            });
+            if (result.success) {
+                spinner.succeed(`Installed ${agentConfig.name}@${result.installedVersion}`);
+                // Create shim if first install
+                if (!shimExists(agent)) {
+                    createShim(agent);
+                    console.log(chalk.gray(`  Created shim: ${getShimsDir()}/${agentConfig.cliCommand}`));
                 }
-                catch (err) {
-                    spinner.fail(`Failed to install ${agentConfig.name}`);
-                    console.error(chalk.gray(err.message));
-                    continue;
+                // Check if shims in PATH
+                if (!isShimsInPath()) {
+                    console.log();
+                    console.log(chalk.yellow('Shims directory not in PATH. Add it to use version switching:'));
+                    console.log(chalk.gray(getPathSetupInstructions()));
+                    console.log();
                 }
             }
             else {
-                console.log(chalk.yellow(`${agentConfig.name} has no installer. Install manually.`));
+                spinner.fail(`Failed to install ${agentConfig.name}@${version}`);
+                console.error(chalk.gray(result.error || 'Unknown error'));
+                continue;
             }
         }
+        // Update project manifest if -p flag
+        if (isProject) {
+            const projectManifestDir = path.join(process.cwd(), '.agents');
+            const projectManifestPath = path.join(projectManifestDir, 'agents.yaml');
+            if (!fs.existsSync(projectManifestDir)) {
+                fs.mkdirSync(projectManifestDir, { recursive: true });
+            }
+            const manifest = fs.existsSync(projectManifestPath)
+                ? readManifest(process.cwd()) || createDefaultManifest()
+                : createDefaultManifest();
+            manifest.clis = manifest.clis || {};
+            manifest.clis[agent] = {
+                package: agentConfig.npmPackage,
+                version: version === 'latest' ? (await getInstalledVersionForAgent(agent, version)) : version,
+            };
+            writeManifest(process.cwd(), manifest);
+            console.log(chalk.green(`  Pinned ${agentConfig.name}@${version} in .agents/agents.yaml`));
+        }
     }
-    const source = await ensureSource();
-    const localPath = getRepoLocalPath(source);
-    const manifest = readManifest(localPath) || createDefaultManifest();
-    manifest.clis = manifest.clis || {};
-    for (const agentId of validAgents) {
-        const agentConfig = AGENTS[agentId];
-        manifest.clis[agentId] = {
-            package: agentConfig.npmPackage,
-            version: version,
-        };
-    }
-    writeManifest(localPath, manifest);
-    if (validAgents.length === 1) {
-        console.log(chalk.green(`Added ${AGENTS[validAgents[0]].name} to manifest`));
+});
+/**
+ * Helper to get actual installed version for an agent.
+ */
+async function getInstalledVersionForAgent(agent, requestedVersion) {
+    const versions = listInstalledVersions(agent);
+    if (versions.length > 0) {
+        return versions[versions.length - 1];
     }
-    else {
-        console.log(chalk.green(`Added ${validAgents.length} agents to manifest`));
-    }
-});
-cliCmd
-    .command('remove <agents...>')
-    .description('Uninstall agent CLI(s)')
-    .option('--manifest-only', 'Only remove from manifest, do not uninstall')
-    .action(async (agents, options) => {
-    const validAgents = [];
-    for (const agent of agents) {
-        const agentId = agent.toLowerCase();
-        if (!AGENTS[agentId]) {
-            console.log(chalk.red(`Unknown agent: ${agent}`));
-            console.log(chalk.gray(`Available: ${ALL_AGENT_IDS.join(', ')}`));
-            return;
+    return requestedVersion;
+}
+program
+    .command('remove <specs...>')
+    .description('Remove agent CLI version(s). Examples: agents remove claude@1.5.0, agents remove claude')
+    .option('-p, --project', 'Also remove from project manifest')
+    .action(async (specs, options) => {
+    const isProject = options.project;
+    for (const spec of specs) {
+        const parsed = parseAgentSpec(spec);
+        if (!parsed) {
+            console.log(chalk.red(`Invalid agent: ${spec}`));
+            console.log(chalk.gray(`Format: <agent>[@version]. Available: ${ALL_AGENT_IDS.join(', ')}`));
+            continue;
         }
-        validAgents.push(agentId);
-    }
-    const { exec } = await import('child_process');
-    const { promisify } = await import('util');
-    const execAsync = promisify(exec);
-    for (const agentId of validAgents) {
-        const agentConfig = AGENTS[agentId];
-        const pkg = agentConfig.npmPackage;
-        if (!options.manifestOnly) {
-            if (!pkg) {
-                console.log(chalk.yellow(`${agentConfig.name} has no npm package.`));
+        const { agent, version } = parsed;
+        const agentConfig = AGENTS[agent];
+        if (version === 'latest' || !spec.includes('@')) {
+            // Remove all versions
+            const versions = listInstalledVersions(agent);
+            if (versions.length === 0) {
+                console.log(chalk.gray(`No versions of ${agentConfig.name} installed`));
             }
-            else if (!(await isCliInstalled(agentId))) {
-                console.log(chalk.gray(`${agentConfig.name} is not installed`));
+            else {
+                const count = removeAllVersions(agent);
+                removeShim(agent);
+                console.log(chalk.green(`Removed ${count} version(s) of ${agentConfig.name}`));
+            }
+        }
+        else {
+            // Remove specific version
+            if (!isVersionInstalled(agent, version)) {
+                console.log(chalk.gray(`${agentConfig.name}@${version} not installed`));
             }
             else {
-                const spinner = ora(`Uninstalling ${agentConfig.name}...`).start();
-                try {
-                    await execAsync(`npm uninstall -g ${pkg}`);
-                    spinner.succeed(`Uninstalled ${agentConfig.name}`);
+                removeVersion(agent, version);
+                console.log(chalk.green(`Removed ${agentConfig.name}@${version}`));
+                // Remove shim if no versions left
+                const remaining = listInstalledVersions(agent);
+                if (remaining.length === 0) {
+                    removeShim(agent);
                 }
-                catch (err) {
-                    spinner.fail(`Failed to uninstall ${agentConfig.name}`);
-                    console.error(chalk.gray(err.message));
+            }
+        }
+        // Update project manifest if -p flag
+        if (isProject) {
+            const projectManifestPath = path.join(process.cwd(), '.agents', 'agents.yaml');
+            if (fs.existsSync(projectManifestPath)) {
+                const manifest = readManifest(process.cwd());
+                if (manifest?.clis?.[agent]) {
+                    delete manifest.clis[agent];
+                    writeManifest(process.cwd(), manifest);
+                    console.log(chalk.gray(`  Removed from .agents/agents.yaml`));
                 }
             }
         }
     }
-    const source = await ensureSource();
-    const localPath = getRepoLocalPath(source);
-    const manifest = readManifest(localPath);
-    let removed = 0;
-    for (const agentId of validAgents) {
-        if (manifest?.clis?.[agentId]) {
-            delete manifest.clis[agentId];
-            removed++;
+});
+program
+    .command('use <spec>')
+    .description('Set default agent version. Examples: agents use claude@1.5.0')
+    .option('-p, --project', 'Set in project manifest instead of global default')
+    .action(async (spec, options) => {
+    const parsed = parseAgentSpec(spec);
+    if (!parsed) {
+        console.log(chalk.red(`Invalid agent: ${spec}`));
+        console.log(chalk.gray(`Format: <agent>@<version>. Available: ${ALL_AGENT_IDS.join(', ')}`));
+        return;
+    }
+    const { agent, version } = parsed;
+    const agentConfig = AGENTS[agent];
+    if (!spec.includes('@') || version === 'latest') {
+        console.log(chalk.red('Please specify a version: agents use <agent>@<version>'));
+        const versions = listInstalledVersions(agent);
+        if (versions.length > 0) {
+            console.log(chalk.gray(`Installed versions: ${versions.join(', ')}`));
         }
+        return;
     }
-    if (removed > 0 && manifest) {
-        writeManifest(localPath, manifest);
-        if (removed === 1) {
-            console.log(chalk.green(`Removed ${AGENTS[validAgents[0]].name} from manifest`));
+    if (!isVersionInstalled(agent, version)) {
+        console.log(chalk.red(`${agentConfig.name}@${version} not installed`));
+        console.log(chalk.gray(`Run: agents add ${agent}@${version}`));
+        return;
+    }
+    if (options.project) {
+        // Set in project manifest
+        const projectManifestDir = path.join(process.cwd(), '.agents');
+        const projectManifestPath = path.join(projectManifestDir, 'agents.yaml');
+        if (!fs.existsSync(projectManifestDir)) {
+            fs.mkdirSync(projectManifestDir, { recursive: true });
+        }
+        const manifest = fs.existsSync(projectManifestPath)
+            ? readManifest(process.cwd()) || createDefaultManifest()
+            : createDefaultManifest();
+        manifest.clis = manifest.clis || {};
+        manifest.clis[agent] = {
+            package: agentConfig.npmPackage,
+            version,
+        };
+        writeManifest(process.cwd(), manifest);
+        console.log(chalk.green(`Set ${agentConfig.name}@${version} for this project`));
+    }
+    else {
+        // Set global default
+        setGlobalDefault(agent, version);
+        console.log(chalk.green(`Set ${agentConfig.name}@${version} as global default`));
+    }
+});
+program
+    .command('list')
+    .description('List installed agent CLI versions')
+    .action(async () => {
+    console.log(chalk.bold('Installed Agent CLIs\n'));
+    let hasAny = false;
+    for (const agentId of ALL_AGENT_IDS) {
+        const agent = AGENTS[agentId];
+        const versions = listInstalledVersions(agentId);
+        const globalDefault = getGlobalDefault(agentId);
+        if (versions.length > 0) {
+            hasAny = true;
+            console.log(`  ${chalk.bold(agent.name)}`);
+            for (const version of versions) {
+                const isDefault = version === globalDefault;
+                const marker = isDefault ? chalk.green(' (default)') : '';
+                console.log(`    ${version}${marker}`);
+            }
+            // Check for project override
+            const projectVersion = getProjectVersionFromCwd(agentId);
+            if (projectVersion && projectVersion !== globalDefault) {
+                console.log(chalk.cyan(`    -> ${projectVersion} (project)`));
+            }
+            console.log();
+        }
+    }
+    if (!hasAny) {
+        console.log(chalk.gray('  No agent CLIs installed.'));
+        console.log(chalk.gray('  Run: agents add claude@latest'));
+        console.log();
+    }
+    // Show shims path status
+    if (hasAny) {
+        const shimsDir = getShimsDir();
+        if (isShimsInPath()) {
+            console.log(chalk.gray(`Shims: ${shimsDir} (in PATH)`));
         }
         else {
-            console.log(chalk.green(`Removed ${removed} agents from manifest`));
+            console.log(chalk.yellow(`Shims: ${shimsDir} (not in PATH)`));
+            console.log(chalk.gray('Add to PATH for automatic version switching'));
         }
     }
 });
-cliCmd
+/**
+ * Helper to get project version from current working directory.
+ */
+function getProjectVersionFromCwd(agent) {
+    const manifestPath = path.join(process.cwd(), '.agents', 'agents.yaml');
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const manifest = readManifest(process.cwd());
+        return manifest?.clis?.[agent]?.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+program
     .command('upgrade [agent]')
-    .description('Upgrade agent CLI(s) to version in manifest')
-    .option('-s, --scope <scope>', 'Target scope (default: user)', 'user')
-    .option('--latest', 'Upgrade to latest version (ignore manifest)')
+    .description('Upgrade agent CLI(s) to latest version')
+    .option('-p, --project', 'Upgrade to version in project manifest')
     .action(async (agent, options) => {
-    const scopeName = options.scope;
-    const scope = getScope(scopeName);
-    const localPath = scope ? getRepoLocalPath(scope.source) : null;
-    const manifest = localPath ? readManifest(localPath) : null;
     const agentsToUpgrade = agent
         ? [agent.toLowerCase()]
-        : ALL_AGENT_IDS.filter((id) => manifest?.clis?.[id] || options.latest);
+        : ALL_AGENT_IDS.filter((id) => listInstalledVersions(id).length > 0);
     if (agentsToUpgrade.length === 0) {
-        console.log(chalk.yellow('No CLIs to upgrade. Add CLIs to manifest or use --latest'));
+        console.log(chalk.yellow('No agent CLIs installed. Run: agents add <agent>@<version>'));
         return;
     }
-    const { exec } = await import('child_process');
-    const { promisify } = await import('util');
-    const execAsync = promisify(exec);
     for (const agentId of agentsToUpgrade) {
         const agentConfig = AGENTS[agentId];
         if (!agentConfig) {
             console.log(chalk.red(`Unknown agent: ${agentId}`));
             continue;
         }
-        const cliConfig = manifest?.clis?.[agentId];
-        const version = options.latest ? 'latest' : (cliConfig?.version || 'latest');
-        const pkg = cliConfig?.package || agentConfig.npmPackage;
-        const spinner = ora(`Upgrading ${agentConfig.name} to ${version}...`).start();
-        try {
-            await execAsync(`npm install -g ${pkg}@${version}`);
-            spinner.succeed(`${agentConfig.name} upgraded to ${version}`);
+        // Determine target version
+        let targetVersion = 'latest';
+        if (options.project) {
+            const projectVersion = getProjectVersionFromCwd(agentId);
+            if (projectVersion) {
+                targetVersion = projectVersion;
+            }
         }
-        catch (err) {
+        const spinner = ora(`Upgrading ${agentConfig.name} to ${targetVersion}...`).start();
+        const result = await installVersion(agentId, targetVersion, (msg) => {
+            spinner.text = msg;
+        });
+        if (result.success) {
+            spinner.succeed(`Upgraded ${agentConfig.name} to ${result.installedVersion}`);
+            // Update global default to new version
+            setGlobalDefault(agentId, result.installedVersion);
+        }
+        else {
             spinner.fail(`Failed to upgrade ${agentConfig.name}`);
-            console.error(chalk.gray(err.message));
+            console.error(chalk.gray(result.error || 'Unknown error'));
         }
     }
 });
+// Legacy alias for backwards compatibility
+program
+    .command('cli')
+    .description('(deprecated) Use: agents add, agents remove, agents list')
+    .action(() => {
+    console.log(chalk.yellow('The "cli" subcommand is deprecated.'));
+    console.log();
+    console.log('New commands:');
+    console.log('  agents add <agent>@<version>     Install agent CLI');
+    console.log('  agents remove <agent>[@version]  Remove agent CLI');
+    console.log('  agents use <agent>@<version>     Set default version');
+    console.log('  agents list                      List installed versions');
+    console.log('  agents upgrade [agent]           Upgrade to latest');
+    console.log();
+    console.log('Examples:');
+    console.log('  agents add claude@1.5.0');
+    console.log('  agents add claude@1.5.0 -p       Pin to project');
+    console.log('  agents use claude@1.4.0');
+    console.log('  agents remove claude@1.4.0');
+});
 // =============================================================================
 // REPO COMMANDS
 // =============================================================================
@@ -2189,11 +2707,11 @@ program
     }
 });
 // =============================================================================
-// ADD COMMAND (unified package installation)
+// INSTALL COMMAND (unified package installation)
 // =============================================================================
 program
-    .command('add <identifier>')
-    .description('Add a package (mcp:name, skill:user/repo, or gh:user/repo)')
+    .command('install <identifier>')
+    .description('Install a package (mcp:name, skill:user/repo, or gh:user/repo)')
     .option('-a, --agents <list>', 'Comma-separated agents to install to')
     .action(async (identifier, options) => {
     const spinner = ora('Resolving package...').start();
@@ -2300,18 +2818,29 @@ program
             if (hasCommands) {
                 console.log(chalk.bold('\nInstalling commands...'));
                 let installed = 0;
+                let failed = 0;
                 for (const command of commands) {
                     for (const agentId of agents) {
                         if (!gitCliStates[agentId]?.installed && agentId !== 'cursor')
                             continue;
                         const sourcePath = resolveCommandSource(localPath, command.name, agentId);
                         if (sourcePath) {
-                            installCommand(sourcePath, agentId, command.name, 'symlink');
-                            installed++;
+                            const result = installCommand(sourcePath, agentId, command.name, 'symlink');
+                            if (result.error) {
+                                failed++;
+                            }
+                            else {
+                                installed++;
+                            }
                         }
                     }
                 }
-                console.log(`  Installed ${installed} command instances`);
+                if (failed > 0) {
+                    console.log(`  Installed ${installed} command instances (${failed} failed)`);
+                }
+                else {
+                    console.log(`  Installed ${installed} command instances`);
+                }
             }
             // Install skills
             if (hasSkills) {
@@ -2344,7 +2873,7 @@ program
 });
 // Self-upgrade command
 program
-    .command('upgrade')
+    .command('self-upgrade')
     .description('Upgrade agents-cli to the latest version')
     .action(async () => {
     const spinner = ora('Checking for updates...').start();
@@ -2406,6 +2935,498 @@ program
         process.exit(1);
     }
 });
+// =============================================================================
+// DAEMON COMMANDS
+// =============================================================================
+import { startDaemon, stopDaemon, isDaemonRunning, readDaemonPid, readDaemonLog, runDaemon, signalDaemonReload, } from './lib/daemon.js';
+import { listJobs as listAllJobs, readJob, validateJob, writeJob, setJobEnabled, getLatestRun, getRunDir, discoverJobsFromRepo, jobExists, jobContentMatches, installJobFromSource, } from './lib/jobs.js';
+import { executeJob } from './lib/runner.js';
+import { JobScheduler } from './lib/scheduler.js';
+const daemonCmd = program.command('daemon').description('Manage the jobs daemon');
+daemonCmd
+    .command('start')
+    .description('Start the daemon')
+    .action(() => {
+    const result = startDaemon();
+    if (result.method === 'already-running') {
+        console.log(chalk.yellow(`Daemon already running (PID: ${result.pid})`));
+    }
+    else {
+        console.log(chalk.green(`Daemon started (PID: ${result.pid}, method: ${result.method})`));
+    }
+});
+daemonCmd
+    .command('stop')
+    .description('Stop the daemon')
+    .action(() => {
+    if (!isDaemonRunning()) {
+        console.log(chalk.yellow('Daemon is not running'));
+        return;
+    }
+    stopDaemon();
+    console.log(chalk.green('Daemon stopped'));
+});
+daemonCmd
+    .command('status')
+    .description('Show daemon status')
+    .action(() => {
+    const running = isDaemonRunning();
+    const pid = readDaemonPid();
+    console.log(chalk.bold('Daemon Status\n'));
+    console.log(`  Status:  ${running ? chalk.green('running') : chalk.gray('stopped')}`);
+    if (pid)
+        console.log(`  PID:     ${pid}`);
+    const jobs = listAllJobs();
+    const enabled = jobs.filter((j) => j.enabled);
+    console.log(`  Jobs:    ${enabled.length} enabled / ${jobs.length} total`);
+    if (running && enabled.length > 0) {
+        const scheduler = new JobScheduler(async () => { });
+        scheduler.loadAll();
+        const scheduled = scheduler.listScheduled();
+        console.log(chalk.bold('\n  Scheduled Jobs\n'));
+        for (const job of scheduled) {
+            const next = job.nextRun ? job.nextRun.toLocaleString() : 'unknown';
+            console.log(`    ${chalk.cyan(job.name.padEnd(24))} next: ${chalk.gray(next)}`);
+        }
+        scheduler.stopAll();
+    }
+});
+daemonCmd
+    .command('logs')
+    .description('Show daemon logs')
+    .option('-n, --lines <number>', 'Number of lines to show', '50')
+    .option('-f, --follow', 'Follow log output')
+    .action(async (options) => {
+    if (options.follow) {
+        const { exec: execCb } = await import('child_process');
+        const { getAgentsDir } = await import('./lib/state.js');
+        const logPath = path.join(getAgentsDir(), 'daemon.log');
+        const child = execCb(`tail -f "${logPath}"`);
+        child.stdout?.pipe(process.stdout);
+        child.stderr?.pipe(process.stderr);
+        child.on('exit', () => process.exit(0));
+        process.on('SIGINT', () => { child.kill(); process.exit(0); });
+        return;
+    }
+    const lines = parseInt(options.lines, 10);
+    const output = readDaemonLog(lines);
+    if (output) {
+        console.log(output);
+    }
+    else {
+        console.log(chalk.gray('No daemon logs'));
+    }
+});
+daemonCmd
+    .command('_run')
+    .description('Run daemon in foreground (internal)')
+    .action(async () => {
+    await runDaemon();
+});
+// =============================================================================
+// JOBS COMMANDS
+// =============================================================================
+const jobsCmd = program.command('jobs').description('Manage scheduled jobs');
+jobsCmd
+    .command('list')
+    .description('List all jobs')
+    .action(() => {
+    const jobs = listAllJobs();
+    if (jobs.length === 0) {
+        console.log(chalk.gray('No jobs configured'));
+        console.log(chalk.gray('  Add a job: agents jobs add <path-to-job.yml>'));
+        return;
+    }
+    const scheduler = new JobScheduler(async () => { });
+    scheduler.loadAll();
+    console.log(chalk.bold('Scheduled Jobs\n'));
+    const header = `  ${'Name'.padEnd(24)} ${'Agent'.padEnd(10)} ${'Schedule'.padEnd(20)} ${'Enabled'.padEnd(10)} ${'Next Run'.padEnd(24)} ${'Last Status'}`;
+    console.log(chalk.gray(header));
+    console.log(chalk.gray('  ' + '-'.repeat(110)));
+    for (const job of jobs) {
+        const nextRun = scheduler.getNextRun(job.name);
+        const nextStr = nextRun ? nextRun.toLocaleString() : '-';
+        const latestRun = getLatestRun(job.name);
+        const lastStatus = latestRun?.status || '-';
+        const enabledStr = job.enabled ? chalk.green('yes') : chalk.gray('no');
+        const statusColor = lastStatus === 'completed' ? chalk.green : lastStatus === 'failed' ? chalk.red : lastStatus === 'timeout' ? chalk.yellow : chalk.gray;
+        console.log(`  ${chalk.cyan(job.name.padEnd(24))} ${job.agent.padEnd(10)} ${job.schedule.padEnd(20)} ${enabledStr.padEnd(10 + 10)} ${chalk.gray(nextStr.padEnd(24))} ${statusColor(lastStatus)}`);
+    }
+    scheduler.stopAll();
+    console.log();
+});
+jobsCmd
+    .command('add <path>')
+    .description('Add a job from a YAML file')
+    .action(async (filePath) => {
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+        console.log(chalk.red(`File not found: ${resolved}`));
+        process.exit(1);
+    }
+    const content = fs.readFileSync(resolved, 'utf-8');
+    let parsed;
+    try {
+        const yamlMod = await import('yaml');
+        parsed = yamlMod.parse(content);
+    }
+    catch (err) {
+        console.log(chalk.red(`Invalid YAML: ${err.message}`));
+        process.exit(1);
+    }
+    const name = parsed.name || path.basename(resolved).replace(/\.ya?ml$/, '');
+    parsed.name = name;
+    const errors = validateJob(parsed);
+    if (errors.length > 0) {
+        console.log(chalk.red('Validation errors:'));
+        for (const err of errors) {
+            console.log(chalk.red(`  - ${err}`));
+        }
+        process.exit(1);
+    }
+    const config = {
+        mode: 'plan',
+        effort: 'default',
+        timeout: '30m',
+        enabled: true,
+        ...parsed,
+    };
+    writeJob(config);
+    console.log(chalk.green(`Job '${name}' added`));
+    if (isDaemonRunning()) {
+        signalDaemonReload();
+        console.log(chalk.gray('Daemon reloaded'));
+    }
+});
+jobsCmd
+    .command('run <name>')
+    .description('Run a job immediately in the foreground')
+    .action(async (name) => {
+    const job = readJob(name);
+    if (!job) {
+        console.log(chalk.red(`Job '${name}' not found`));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`Running job '${name}' (agent: ${job.agent}, mode: ${job.mode})\n`));
+    const spinner = ora('Executing...').start();
+    try {
+        const result = await executeJob(job);
+        if (result.meta.status === 'completed') {
+            spinner.succeed(`Job completed (exit code: ${result.meta.exitCode})`);
+        }
+        else if (result.meta.status === 'timeout') {
+            spinner.warn(`Job timed out after ${job.timeout}`);
+        }
+        else {
+            spinner.fail(`Job failed (exit code: ${result.meta.exitCode})`);
+        }
+        console.log(chalk.gray(`  Run: ${result.meta.runId}`));
+        console.log(chalk.gray(`  Log: ${getRunDir(name, result.meta.runId)}/stdout.log`));
+        if (result.reportPath) {
+            console.log(chalk.bold('\nReport:\n'));
+            console.log(fs.readFileSync(result.reportPath, 'utf-8'));
+        }
+    }
+    catch (err) {
+        spinner.fail('Execution failed');
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+jobsCmd
+    .command('logs <name>')
+    .description('Show stdout from the latest (or specific) run')
+    .option('-r, --run <runId>', 'Specific run ID')
+    .action((name, options) => {
+    let runId = options.run;
+    if (!runId) {
+        const latest = getLatestRun(name);
+        if (!latest) {
+            console.log(chalk.yellow(`No runs found for job '${name}'`));
+            return;
+        }
+        runId = latest.runId;
+    }
+    const logPath = path.join(getRunDir(name, runId), 'stdout.log');
+    if (!fs.existsSync(logPath)) {
+        console.log(chalk.yellow(`Log not found: ${logPath}`));
+        return;
+    }
+    console.log(chalk.gray(`Run: ${runId}\n`));
+    console.log(fs.readFileSync(logPath, 'utf-8'));
+});
+jobsCmd
+    .command('report <name>')
+    .description('Show report from the latest (or specific) run')
+    .option('-r, --run <runId>', 'Specific run ID')
+    .action((name, options) => {
+    let runId = options.run;
+    if (!runId) {
+        const latest = getLatestRun(name);
+        if (!latest) {
+            console.log(chalk.yellow(`No runs found for job '${name}'`));
+            return;
+        }
+        runId = latest.runId;
+    }
+    const reportPath = path.join(getRunDir(name, runId), 'report.md');
+    if (!fs.existsSync(reportPath)) {
+        console.log(chalk.yellow(`No report found for run ${runId}`));
+        console.log(chalk.gray(`  Reports are extracted from agent output on completion`));
+        return;
+    }
+    console.log(chalk.gray(`Run: ${runId}\n`));
+    console.log(fs.readFileSync(reportPath, 'utf-8'));
+});
+jobsCmd
+    .command('enable <name>')
+    .description('Enable a job')
+    .action((name) => {
+    try {
+        setJobEnabled(name, true);
+        console.log(chalk.green(`Job '${name}' enabled`));
+        if (isDaemonRunning()) {
+            signalDaemonReload();
+            console.log(chalk.gray('Daemon reloaded'));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+jobsCmd
+    .command('disable <name>')
+    .description('Disable a job')
+    .action((name) => {
+    try {
+        setJobEnabled(name, false);
+        console.log(chalk.green(`Job '${name}' disabled`));
+        if (isDaemonRunning()) {
+            signalDaemonReload();
+            console.log(chalk.gray('Daemon reloaded'));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// =============================================================================
+// DRIVE COMMANDS
+// =============================================================================
+import { createDrive, readDrive, listDrives as listAllDrives, deleteDrive, updateDriveFrontmatter, driveExists, discoverDrivesFromRepo, installDriveFromSource, driveContentMatches, } from './lib/drives.js';
+import { runDriveServer } from './lib/drive-server.js';
+const driveCmd = program.command('drive').description('Manage context drives');
+driveCmd
+    .command('create <name>')
+    .description('Create a new empty drive')
+    .option('-d, --description <desc>', 'Drive description')
+    .option('-p, --project <path>', 'Link to a project directory')
+    .action((name, options) => {
+    try {
+        const filePath = createDrive(name, options.description);
+        if (options.project) {
+            updateDriveFrontmatter(name, { project: path.resolve(options.project) });
+        }
+        console.log(chalk.green(`Drive '${name}' created`));
+        console.log(chalk.gray(`  ${filePath}`));
+    }
+    catch (err) {
+        console.log(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+driveCmd
+    .command('list')
+    .description('List all drives')
+    .action(() => {
+    const drives = listAllDrives();
+    if (drives.length === 0) {
+        console.log(chalk.gray('No drives configured'));
+        console.log(chalk.gray('  Create a drive: agents drive create <name>'));
+        return;
+    }
+    console.log(chalk.bold('Context Drives\n'));
+    const header = `  ${'Name'.padEnd(24)} ${'Description'.padEnd(40)} ${'Project'}`;
+    console.log(chalk.gray(header));
+    console.log(chalk.gray('  ' + '-'.repeat(90)));
+    for (const drive of drives) {
+        const desc = (drive.description || '-').slice(0, 38);
+        const proj = drive.project || '-';
+        console.log(`  ${chalk.cyan(drive.name.padEnd(24))} ${desc.padEnd(40)} ${chalk.gray(proj)}`);
+    }
+    console.log();
+});
+driveCmd
+    .command('info <name>')
+    .description('Show drive metadata and content preview')
+    .action((name) => {
+    const drive = readDrive(name);
+    if (!drive) {
+        console.log(chalk.red(`Drive '${name}' not found`));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`Drive: ${drive.frontmatter.name}\n`));
+    if (drive.frontmatter.description) {
+        console.log(chalk.gray(`  Description: ${drive.frontmatter.description}`));
+    }
+    if (drive.frontmatter.project) {
+        console.log(chalk.gray(`  Project:     ${drive.frontmatter.project}`));
+    }
+    if (drive.frontmatter.repo) {
+        console.log(chalk.gray(`  Repo:        ${drive.frontmatter.repo}`));
+    }
+    if (drive.frontmatter.updated) {
+        console.log(chalk.gray(`  Updated:     ${drive.frontmatter.updated}`));
+    }
+    console.log(chalk.gray(`  Path:        ${drive.path}`));
+    const content = drive.content.trim();
+    if (content) {
+        console.log(chalk.bold('\nContent:\n'));
+        const lines = content.split('\n');
+        const preview = lines.slice(0, 30);
+        for (const line of preview) {
+            console.log(`  ${line}`);
+        }
+        if (lines.length > 30) {
+            console.log(chalk.gray(`\n  ... ${lines.length - 30} more lines`));
+        }
+    }
+    console.log();
+});
+driveCmd
+    .command('edit <name>')
+    .description('Open drive in $EDITOR')
+    .action((name) => {
+    const drive = readDrive(name);
+    if (!drive) {
+        console.log(chalk.red(`Drive '${name}' not found`));
+        process.exit(1);
+    }
+    const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+    const { execSync } = require('child_process');
+    try {
+        execSync(`${editor} "${drive.path}"`, { stdio: 'inherit' });
+    }
+    catch {
+        console.log(chalk.red(`Failed to open editor: ${editor}`));
+        process.exit(1);
+    }
+});
+driveCmd
+    .command('delete <name>')
+    .description('Delete a drive')
+    .action(async (name) => {
+    if (!driveExists(name)) {
+        console.log(chalk.red(`Drive '${name}' not found`));
+        process.exit(1);
+    }
+    try {
+        const answer = await confirm({ message: `Delete drive '${name}'?` });
+        if (!answer)
+            return;
+    }
+    catch (err) {
+        if (isPromptCancelled(err))
+            return;
+        throw err;
+    }
+    deleteDrive(name);
+    console.log(chalk.green(`Drive '${name}' deleted`));
+});
+driveCmd
+    .command('link <name> <path>')
+    .description('Link a drive to a project directory')
+    .action((name, projectPath) => {
+    if (!driveExists(name)) {
+        console.log(chalk.red(`Drive '${name}' not found`));
+        process.exit(1);
+    }
+    const resolved = path.resolve(projectPath);
+    if (!fs.existsSync(resolved)) {
+        console.log(chalk.red(`Directory not found: ${resolved}`));
+        process.exit(1);
+    }
+    updateDriveFrontmatter(name, { project: resolved });
+    console.log(chalk.green(`Drive '${name}' linked to ${resolved}`));
+});
+driveCmd
+    .command('sync')
+    .description('Sync drives with .agents repo')
+    .action(async () => {
+    const source = await ensureSource();
+    const repoPath = getRepoLocalPath(source);
+    const discovered = discoverDrivesFromRepo(repoPath);
+    if (discovered.length === 0) {
+        console.log(chalk.gray('No drives found in repo'));
+        return;
+    }
+    let installed = 0;
+    let skipped = 0;
+    for (const d of discovered) {
+        if (driveExists(d.name) && driveContentMatches(d.name, d.path)) {
+            skipped++;
+            continue;
+        }
+        const result = installDriveFromSource(d.path, d.name);
+        if (result.success) {
+            installed++;
+            console.log(chalk.green(`  + ${d.name}`));
+        }
+        else {
+            console.log(chalk.red(`  x ${d.name}: ${result.error}`));
+        }
+    }
+    if (installed === 0 && skipped > 0) {
+        console.log(chalk.gray(`All ${skipped} drives up to date`));
+    }
+    else if (installed > 0) {
+        console.log(chalk.green(`\nSynced ${installed} drive(s)`));
+    }
+});
+driveCmd
+    .command('generate <name>')
+    .description('Run a drive generation job now')
+    .action(async (name) => {
+    if (!driveExists(name)) {
+        console.log(chalk.red(`Drive '${name}' not found`));
+        process.exit(1);
+    }
+    const jobName = `update-drive-${name}`;
+    const job = readJob(jobName);
+    if (!job) {
+        console.log(chalk.red(`No generation job found for drive '${name}'`));
+        console.log(chalk.gray(`  Expected job name: ${jobName}`));
+        console.log(chalk.gray(`  Create one at: ~/.agents/jobs/${jobName}.yml`));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`Generating drive '${name}' (job: ${jobName})\n`));
+    const spinner = ora('Executing...').start();
+    try {
+        const result = await executeJob(job);
+        if (result.meta.status === 'completed') {
+            spinner.succeed(`Drive '${name}' updated`);
+        }
+        else if (result.meta.status === 'timeout') {
+            spinner.warn(`Generation timed out after ${job.timeout}`);
+        }
+        else {
+            spinner.fail(`Generation failed (exit code: ${result.meta.exitCode})`);
+        }
+    }
+    catch (err) {
+        spinner.fail('Generation failed');
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+driveCmd
+    .command('serve')
+    .description('Start the drive MCP server (stdio)')
+    .action(async () => {
+    await runDriveServer();
+});
 async function showWhatsNew(fromVersion, toVersion) {
     try {
         // Fetch changelog from npm package