claude-tempo 0.3.0 → 0.4.0

package/README.md

@@ -98,7 +98,8 @@ claude-tempo <command> [options]
 | `start [ensemble]` | Start a player session |
 | `status [ensemble]` | Show active sessions and Temporal health |
 | `config` | Configure Temporal connection settings (interactive or `set`/`show`) |
-| `init` | Create `.mcp.json` config in the current directory |
+| `stop [ensemble]` | Stop sessions (`-n <name>` for one, `--all` for everything) |
+| `init` | Register claude-tempo MCP server globally (`--project` for per-directory) |
 | `preflight` | Run environment checks |
 | `help` | Show usage info |
 
@@ -180,19 +181,15 @@ Verifies your environment: Node.js >= 18, Temporal reachable, `claude` on PATH,
 
 ### `claude-tempo init`
 
-Creates `.mcp.json` in the current directory (or merges into an existing one):
-
-```json
-{
-  "mcpServers": {
-    "claude-tempo": {
-      "command": "npx",
-      "args": ["claude-tempo-server"]
-    }
-  }
-}
+Registers the claude-tempo MCP server globally so it's available in every Claude Code session:
+
+```bash
+claude-tempo init             # global install (recommended)
+claude-tempo init --project   # per-directory .mcp.json instead
 ```
 
+If the `claude` CLI is not available, falls back to creating `.mcp.json` in the current directory.
+
 ## MCP tools
 
 These tools are available inside Claude Code sessions connected to claude-tempo:

package/dist/cli/commands.d.ts

@@ -15,6 +15,7 @@ interface StatusOpts extends CliOverrides {
 export declare function status(opts: StatusOpts): Promise<void>;
 interface InitOpts {
     dir: string;
+    project?: boolean;
 }
 export declare function init(opts: InitOpts): Promise<void>;
 interface ServerOpts extends CliOverrides {
@@ -32,6 +33,15 @@ interface DownOpts extends CliOverrides {
     dir: string;
 }
 export declare function down(opts: DownOpts): Promise<void>;
+interface StopOpts extends CliOverrides {
+    /** Stop a specific player by name. */
+    name?: string;
+    /** Stop all sessions in this ensemble. */
+    ensemble?: string;
+    /** Stop every session across all ensembles. */
+    all?: boolean;
+}
+export declare function stop(opts: StopOpts): Promise<void>;
 export declare function help(): void;
 export declare function version(): void;
 export {};

package/dist/cli/commands.js

@@ -39,6 +39,7 @@ exports.init = init;
 exports.server = server;
 exports.up = up;
 exports.down = down;
+exports.stop = stop;
 exports.help = help;
 exports.version = version;
 const fs_1 = require("fs");
@@ -48,7 +49,9 @@ const client_1 = require("@temporalio/client");
 const spawn_1 = require("../spawn");
 const config_1 = require("../config");
 const connection_1 = require("../connection");
+const signals_1 = require("../workflows/signals");
 const preflight_1 = require("./preflight");
+const mcp_1 = require("./mcp");
 const out = __importStar(require("./output"));
 /** Package root is two levels up from dist/cli/ */
 const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
@@ -223,7 +226,36 @@ async function status(opts) {
     console.log();
 }
 async function init(opts) {
-    const mcpPath = (0, path_1.join)(opts.dir, '.mcp.json');
+    if (opts.project) {
+        // Per-project .mcp.json mode
+        return initProject(opts.dir);
+    }
+    // Default: global install via `claude mcp add`
+    if ((0, mcp_1.isGlobalMcpRegistered)()) {
+        out.success('claude-tempo already registered globally');
+        out.log(`  ${out.dim('claude mcp list -s user')}`);
+        return;
+    }
+    const claudePath = (0, spawn_1.resolveClaudePath)();
+    if (claudePath === 'claude') {
+        out.warn('claude binary not found — falling back to project-level .mcp.json');
+        return initProject(opts.dir);
+    }
+    if ((0, mcp_1.addGlobalMcp)()) {
+        out.success('Registered claude-tempo globally (user scope)');
+        out.log(`  ${out.dim('Available in all Claude Code sessions')}`);
+    }
+    else {
+        out.warn('Failed to register globally — falling back to project-level .mcp.json');
+        return initProject(opts.dir);
+    }
+    out.log(`\nNext steps:`);
+    out.log(`  1. Start Temporal:  ${out.dim('temporal server start-dev')}`);
+    out.log(`  2. Start conductor: ${out.dim('claude-tempo conduct')}`);
+}
+/** Per-project .mcp.json install (legacy, used with --project flag). */
+function initProject(dir) {
+    const mcpPath = (0, path_1.join)(dir, '.mcp.json');
     const entry = {
         command: 'npx',
         args: ['claude-tempo-server'],
@@ -236,7 +268,6 @@ async function init(opts) {
                 out.log(`  ${out.dim(mcpPath)}`);
                 return;
             }
-            // Merge into existing config
             existing.mcpServers = existing.mcpServers || {};
             existing.mcpServers['claude-tempo'] = entry;
             (0, fs_1.writeFileSync)(mcpPath, JSON.stringify(existing, null, 2) + '\n');
@@ -426,22 +457,13 @@ async function up(opts) {
     }
     // Step 3: Register search attributes
     registerSearchAttributes(config.temporalAddress, config.temporalNamespace);
-    // Step 4: Init .mcp.json if needed
-    const mcpPath = (0, path_1.join)(process.cwd(), '.mcp.json');
-    let mcpExists = false;
-    if ((0, fs_1.existsSync)(mcpPath)) {
-        try {
-            const mcp = JSON.parse((0, fs_1.readFileSync)(mcpPath, 'utf8'));
-            mcpExists = !!mcp?.mcpServers?.['claude-tempo'];
-        }
-        catch { /* invalid */ }
-    }
-    if (mcpExists) {
-        out.check('.mcp.json configured', true);
+    // Step 4: Register MCP server if needed
+    if ((0, mcp_1.isMcpConfigured)(process.cwd())) {
+        out.check('MCP configured', true);
     }
     else {
         await init({ dir: process.cwd() });
-        out.check('.mcp.json created', true);
+        out.check('MCP configured', true);
     }
     // Always forward all resolved Temporal settings to child processes.
     const temporalEnvVars = {
@@ -525,7 +547,9 @@ async function down(opts) {
             out.warn('Could not terminate active sessions');
         }
     }
-    // Step 2: Stop Temporal server
+    // Step 2: Kill bridge processes via PID files
+    killBridgeProcesses();
+    // Step 3: Stop Temporal server
     if (temporalUp) {
         // Find and kill the temporal dev server process
         try {
@@ -545,18 +569,26 @@ async function down(opts) {
     else {
         out.log(`  ${out.dim('Temporal not running')}`);
     }
-    // Step 3: Remove .mcp.json entry
+    // Step 4: Remove MCP config (global + project-level)
     if (opts.removeMcp) {
+        // Remove global registration
+        if ((0, mcp_1.isGlobalMcpRegistered)()) {
+            if ((0, mcp_1.removeGlobalMcp)()) {
+                out.success('Removed claude-tempo from global MCP config');
+            }
+            else {
+                out.warn('Could not remove global MCP entry');
+            }
+        }
+        // Also remove project-level .mcp.json entry if present
         const mcpPath = (0, path_1.join)(opts.dir, '.mcp.json');
         if ((0, fs_1.existsSync)(mcpPath)) {
             try {
                 const existing = JSON.parse((0, fs_1.readFileSync)(mcpPath, 'utf8'));
                 if (existing?.mcpServers?.['claude-tempo']) {
                     delete existing.mcpServers['claude-tempo'];
-                    // If no other MCP servers remain, remove the file entirely
                     if (Object.keys(existing.mcpServers).length === 0) {
-                        const { unlinkSync } = require('fs');
-                        unlinkSync(mcpPath);
+                        (0, fs_1.unlinkSync)(mcpPath);
                         out.success('Removed .mcp.json (no other servers configured)');
                     }
                     else {
@@ -564,23 +596,186 @@ async function down(opts) {
                         out.success('Removed claude-tempo from .mcp.json');
                     }
                 }
-                else {
-                    out.log(`  ${out.dim('.mcp.json has no claude-tempo entry')}`);
-                }
             }
             catch {
                 out.warn(`Could not update ${mcpPath}`);
             }
         }
-        else {
-            out.log(`  ${out.dim('No .mcp.json found')}`);
-        }
     }
     console.log();
     out.success('claude-tempo is shut down');
     out.log(`  ${out.dim('Temporal data preserved in ~/.claude-tempo/ (delete manually to reset)')}`);
     console.log();
 }
+async function stop(opts) {
+    const config = (0, config_1.getConfig)(opts);
+    if (!opts.name && !opts.ensemble && !opts.all) {
+        out.error('Specify what to stop:');
+        out.log(`  ${out.dim('claude-tempo stop <ensemble>')}          Stop all sessions in an ensemble`);
+        out.log(`  ${out.dim('claude-tempo stop <ensemble> -n <name>')} Stop a specific session`);
+        out.log(`  ${out.dim('claude-tempo stop --all')}               Stop everything`);
+        process.exit(1);
+    }
+    let connection;
+    try {
+        connection = await Promise.race([
+            (0, connection_1.createTemporalConnection)(config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+        ]);
+    }
+    catch {
+        out.error(`Cannot connect to Temporal at ${config.temporalAddress}`);
+        process.exit(1);
+        return;
+    }
+    const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+    if (opts.name) {
+        // Stop a specific player by name (optionally scoped to ensemble)
+        await stopByName(client, opts.name, config, opts.ensemble);
+    }
+    else {
+        // Stop multiple sessions (--ensemble or --all)
+        let query = 'WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"';
+        if (opts.ensemble) {
+            query += ` AND ClaudeTempoEnsemble = "${opts.ensemble}"`;
+        }
+        let stopped = 0;
+        for await (const wf of client.workflow.list({ query })) {
+            try {
+                const handle = client.workflow.getHandle(wf.workflowId);
+                await handle.signal(signals_1.shutdownSignal);
+                stopped++;
+                out.log(`  ${out.dim('stopped')} ${wf.workflowId}`);
+            }
+            catch {
+                // already closed
+            }
+        }
+        // Clean up PID files
+        if (opts.ensemble || opts.all) {
+            killBridgeProcesses();
+        }
+        if (stopped > 0) {
+            out.success(`Stopped ${stopped} session${stopped !== 1 ? 's' : ''}`);
+        }
+        else {
+            out.log(opts.ensemble
+                ? `No active sessions in ensemble "${opts.ensemble}".`
+                : 'No active sessions found.');
+        }
+    }
+    await connection.close();
+}
+async function stopByName(client, name, config, ensemble) {
+    // Find the workflow by player name via search attribute
+    let query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoPlayerId = "${name}"`;
+    if (ensemble) {
+        query += ` AND ClaudeTempoEnsemble = "${ensemble}"`;
+    }
+    let found = false;
+    for await (const wf of client.workflow.list({ query })) {
+        found = true;
+        const handle = client.workflow.getHandle(wf.workflowId);
+        // Check if this is a conductor — warn about it
+        try {
+            const metadata = (await handle.query('getMetadata'));
+            if (metadata.isConductor) {
+                out.warn(`"${name}" is a conductor session`);
+            }
+            // Notify the conductor that this session was stopped (if it's not the conductor itself)
+            if (!metadata.isConductor && metadata.ensemble) {
+                try {
+                    const conductorWfId = (0, config_1.conductorWorkflowId)(metadata.ensemble);
+                    const conductorHandle = client.workflow.getHandle(conductorWfId);
+                    await conductorHandle.signal(signals_1.playerReportSignal, {
+                        playerId: name,
+                        text: 'Session stopped by CLI',
+                        type: 'result',
+                    });
+                }
+                catch {
+                    // No conductor or conductor not running — fine
+                }
+            }
+        }
+        catch {
+            // Query failed — proceed with shutdown anyway
+        }
+        // Send shutdown signal (graceful)
+        try {
+            await handle.signal(signals_1.shutdownSignal);
+            out.success(`Stopped "${name}"`);
+        }
+        catch {
+            out.warn(`Could not signal "${name}" — it may have already exited`);
+        }
+        // Try to kill bridge process via PID file
+        killBridgePid(name);
+        break;
+    }
+    if (!found) {
+        out.error(`No active session found with name "${name}"`);
+        process.exit(1);
+    }
+}
+/**
+ * Kill a bridge process by reading its PID file from logs/.
+ * Cleans up the PID file after.
+ */
+function killBridgePid(name) {
+    const pidPath = (0, path_1.join)(process.cwd(), 'logs', `${name}.pid`);
+    if (!(0, fs_1.existsSync)(pidPath))
+        return;
+    try {
+        const pid = parseInt((0, fs_1.readFileSync)(pidPath, 'utf8').trim(), 10);
+        if (!isNaN(pid)) {
+            try {
+                process.kill(pid);
+                out.log(`  ${out.dim(`Killed bridge process (pid ${pid})`)}`);
+            }
+            catch {
+                // Process already dead
+            }
+        }
+        (0, fs_1.unlinkSync)(pidPath);
+    }
+    catch {
+        // PID file unreadable — ignore
+    }
+}
+/**
+ * Kill all bridge processes found in logs/*.pid and clean up PID files.
+ */
+function killBridgeProcesses() {
+    const logsDir = (0, path_1.join)(process.cwd(), 'logs');
+    if (!(0, fs_1.existsSync)(logsDir))
+        return;
+    try {
+        const pidFiles = (0, fs_1.readdirSync)(logsDir).filter(f => f.endsWith('.pid'));
+        for (const pidFile of pidFiles) {
+            const pidPath = (0, path_1.join)(logsDir, pidFile);
+            try {
+                const pid = parseInt((0, fs_1.readFileSync)(pidPath, 'utf8').trim(), 10);
+                if (!isNaN(pid)) {
+                    try {
+                        process.kill(pid);
+                        out.log(`  ${out.dim(`Killed bridge process ${pidFile.replace('.pid', '')} (pid ${pid})`)}`);
+                    }
+                    catch {
+                        // already dead
+                    }
+                }
+                (0, fs_1.unlinkSync)(pidPath);
+            }
+            catch {
+                // unreadable — skip
+            }
+        }
+    }
+    catch {
+        // logs dir unreadable
+    }
+}
 function help() {
     console.log(`
 ${out.bold('claude-tempo')} — Multi-session Claude Code coordination via Temporal
@@ -597,9 +792,10 @@ ${out.bold('Commands:')}
   ${out.cyan('server')}                Start the Temporal dev server and register search attributes
   ${out.cyan('conduct')} [ensemble]    Start a conductor session (one per ensemble)
   ${out.cyan('start')}   [ensemble]    Start a player session
+  ${out.cyan('stop')}    [ensemble]    Stop sessions (-n <name> for one, or --all)
   ${out.cyan('status')}  [ensemble]    Show active sessions and Temporal health
   ${out.cyan('config')}                Configure Temporal connection settings
-  ${out.cyan('init')}                  Create .mcp.json config in the current directory
+  ${out.cyan('init')}                  Register MCP server globally (or --project for .mcp.json)
   ${out.cyan('preflight')}             Run preflight checks only
   ${out.cyan('help')}                  Show this help message
 
@@ -612,10 +808,13 @@ ${out.bold('Connection options (all commands):')}
 
 ${out.bold('Other options:')}
   -n, --name <name>           Set the session window name (start/conduct/up only)
-  --agent <claude|copilot>    Agent type to spawn (default: claude; start/conduct)
+  --agent <claude|copilot>    Agent type to spawn (default: from config; start/conduct)
   --skip-preflight            Skip preflight checks (start/conduct only)
   --background                Run Temporal in background (server only)
-  --keep-mcp                  Don't remove .mcp.json entry (down only)
+  --project                   Use per-project .mcp.json instead of global (init only)
+  --keep-mcp                  Don't remove MCP config (down only)
+  --all                       Stop all sessions (stop only)
+  --ensemble <name>           Target a specific ensemble (stop only)
   -d, --dir <path>            Target directory (default: cwd)
 
 ${out.bold('Config command:')}
@@ -646,6 +845,7 @@ ${out.bold('Environment:')}
   TEMPORAL_API_KEY            Temporal API key
   TEMPORAL_TLS_CERT_PATH      Path to TLS client certificate
   TEMPORAL_TLS_KEY_PATH       Path to TLS client key
+  CLAUDE_TEMPO_DEFAULT_AGENT  Default agent type: claude or copilot (fallback: claude)
 `);
 }
 function version() {

package/dist/cli/config-command.js

@@ -126,6 +126,12 @@ async function configInteractive() {
         config.temporalTlsCertPath = await ask('TLS cert path', existing.temporalTlsCertPath);
         config.temporalTlsKeyPath = await ask('TLS key path', existing.temporalTlsKeyPath);
     }
+    // Default agent type
+    const agentChoice = await choose('Default agent', ['claude', 'copilot']);
+    if (agentChoice === 'copilot') {
+        config.defaultAgent = 'copilot';
+    }
+    // Don't set defaultAgent if claude — it's the default, keeps config clean
     (0, config_1.saveConfigFile)(config);
     out.success(`Saved to ${config_1.CONFIG_FILE_PATH}`);
     // Test connection
@@ -165,6 +171,8 @@ function configSet(key, value) {
         temporalTlsKeyPath: 'temporalTlsKeyPath',
         'temporal-tls-key': 'temporalTlsKeyPath',
         'temporal-tls-key-path': 'temporalTlsKeyPath',
+        defaultAgent: 'defaultAgent',
+        'default-agent': 'defaultAgent',
     };
     const configKey = keyMap[key];
     if (!configKey) {
@@ -172,6 +180,11 @@ function configSet(key, value) {
         out.log(`  Valid keys: ${Object.keys(keyMap).join(', ')}`);
         process.exit(1);
     }
+    // Validate agent type
+    if (configKey === 'defaultAgent' && value !== 'claude' && value !== 'copilot') {
+        out.error(`Invalid agent type: "${value}". Must be "claude" or "copilot".`);
+        process.exit(1);
+    }
     config[configKey] = value;
     (0, config_1.saveConfigFile)(config);
     out.success(`Set ${configKey} = ${configKey.includes('Key') ? '****' : value}`);
@@ -186,6 +199,7 @@ function configShow() {
         { key: 'temporalApiKey', configKey: 'temporalApiKey' },
         { key: 'temporalTlsCertPath', configKey: 'temporalTlsCertPath' },
         { key: 'temporalTlsKeyPath', configKey: 'temporalTlsKeyPath' },
+        { key: 'defaultAgent', configKey: 'defaultAgent' },
     ];
     out.log(`  Config file: ${out.dim(config_1.CONFIG_FILE_PATH)}`);
     console.log();

package/dist/cli/mcp.d.ts

@@ -0,0 +1,8 @@
+/** Check if claude-tempo is registered in `claude mcp list` (global user scope). */
+export declare function isGlobalMcpRegistered(): boolean;
+/** Register claude-tempo globally via `claude mcp add`. */
+export declare function addGlobalMcp(): boolean;
+/** Remove claude-tempo from global MCP config via `claude mcp remove`. */
+export declare function removeGlobalMcp(): boolean;
+/** Check if claude-tempo MCP is configured (global or project-level). */
+export declare function isMcpConfigured(projectDir: string): boolean;

package/dist/cli/mcp.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlobalMcpRegistered = isGlobalMcpRegistered;
+exports.addGlobalMcp = addGlobalMcp;
+exports.removeGlobalMcp = removeGlobalMcp;
+exports.isMcpConfigured = isMcpConfigured;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+/** Check if claude-tempo is registered in `claude mcp list` (global user scope). */
+function isGlobalMcpRegistered() {
+    try {
+        const output = (0, child_process_1.execFileSync)('claude', ['mcp', 'list', '-s', 'user'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return output.includes('claude-tempo');
+    }
+    catch {
+        return false;
+    }
+}
+/** Register claude-tempo globally via `claude mcp add`. */
+function addGlobalMcp() {
+    try {
+        (0, child_process_1.execFileSync)('claude', [
+            'mcp', 'add', 'claude-tempo', '-s', 'user',
+            '--', 'npx', 'claude-tempo-server',
+        ], { stdio: ['ignore', 'ignore', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Remove claude-tempo from global MCP config via `claude mcp remove`. */
+function removeGlobalMcp() {
+    try {
+        (0, child_process_1.execFileSync)('claude', [
+            'mcp', 'remove', 'claude-tempo', '-s', 'user',
+        ], { stdio: ['ignore', 'ignore', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check if claude-tempo MCP is configured (global or project-level). */
+function isMcpConfigured(projectDir) {
+    if (isGlobalMcpRegistered())
+        return true;
+    const mcpPath = (0, path_1.join)(projectDir, '.mcp.json');
+    if ((0, fs_1.existsSync)(mcpPath)) {
+        try {
+            const mcp = JSON.parse((0, fs_1.readFileSync)(mcpPath, 'utf8'));
+            return !!mcp?.mcpServers?.['claude-tempo'];
+        }
+        catch { /* invalid json */ }
+    }
+    return false;
+}

package/dist/cli/preflight.js

@@ -34,12 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runPreflight = runPreflight;
-const fs_1 = require("fs");
 const child_process_1 = require("child_process");
-const path_1 = require("path");
 const config_1 = require("../config");
 const connection_1 = require("../connection");
 const spawn_1 = require("../spawn");
+const mcp_1 = require("./mcp");
 const out = __importStar(require("./output"));
 function whichSync(cmd) {
     const bin = process.platform === 'win32' ? 'where' : 'which';
@@ -87,19 +86,11 @@ async function runPreflight(opts) {
     out.check('claude-tempo-server found', serverOk, serverOk ? serverPath : 'not on PATH');
     if (!serverOk)
         errors.push('claude-tempo-server not found on PATH. Run: npm install -g claude-tempo');
-    // 5. MCP config in project
-    const mcpPath = (0, path_1.join)(opts.dir, '.mcp.json');
-    let mcpOk = false;
-    if ((0, fs_1.existsSync)(mcpPath)) {
-        try {
-            const mcp = JSON.parse((0, fs_1.readFileSync)(mcpPath, 'utf8'));
-            mcpOk = !!mcp?.mcpServers?.['claude-tempo'];
-        }
-        catch { /* invalid json */ }
-    }
-    out.check('.mcp.json configured', mcpOk, mcpOk ? mcpPath : 'missing or no claude-tempo entry');
+    // 5. MCP config (global or project-level)
+    const mcpOk = (0, mcp_1.isMcpConfigured)(opts.dir);
+    out.check('MCP configured', mcpOk, mcpOk ? 'global or project' : 'not found');
     if (!mcpOk)
-        warnings.push(`No claude-tempo MCP config in ${opts.dir}. Run: claude-tempo init`);
+        warnings.push('No claude-tempo MCP config found. Run: claude-tempo init');
     console.log();
     return { ok: errors.length === 0, errors, warnings };
 }

package/dist/cli.js

@@ -47,6 +47,8 @@ function parseArgs(argv) {
         skipPreflight: false,
         background: false,
         keepMcp: false,
+        all: false,
+        project: false,
     };
     let i = 0;
     while (i < argv.length) {
@@ -81,6 +83,15 @@ function parseArgs(argv) {
         else if (arg === '--keep-mcp') {
             result.keepMcp = true;
         }
+        else if (arg === '--all') {
+            result.all = true;
+        }
+        else if (arg === '--project') {
+            result.project = true;
+        }
+        else if (arg === '--ensemble' && i + 1 < argv.length) {
+            result.ensemble = argv[++i];
+        }
         else if (arg === '--agent' && i + 1 < argv.length) {
             const val = argv[++i];
             if (val !== 'claude' && val !== 'copilot') {
@@ -124,6 +135,8 @@ async function main() {
     const args = parseArgs(process.argv.slice(2));
     const ensemble = args.positional[1] || process.env[config_1.ENV.ENSEMBLE] || 'default';
     const overrides = cliOverrides(args);
+    // Resolve the default agent from config (only needed for commands that use it)
+    const resolvedAgent = () => args.agent ?? (0, config_1.getConfig)(overrides).defaultAgent;
     switch (args.command) {
         case 'conduct':
             await (0, commands_1.start)({
@@ -131,7 +144,7 @@ async function main() {
                 conductor: true,
                 name: args.name,
                 skipPreflight: args.skipPreflight,
-                agent: args.agent ?? 'claude',
+                agent: resolvedAgent(),
                 dir: args.dir,
                 ...overrides,
             });
@@ -142,7 +155,7 @@ async function main() {
                 conductor: false,
                 name: args.name,
                 skipPreflight: args.skipPreflight,
-                agent: args.agent ?? 'claude',
+                agent: resolvedAgent(),
                 dir: args.dir,
                 ...overrides,
             });
@@ -159,6 +172,14 @@ async function main() {
                 ...overrides,
             });
             break;
+        case 'stop':
+            await (0, commands_1.stop)({
+                name: args.name,
+                ensemble: args.positional[1],
+                all: args.all || undefined,
+                ...overrides,
+            });
+            break;
         case 'down':
             await (0, commands_1.down)({
                 removeMcp: !args.keepMcp,
@@ -170,12 +191,12 @@ async function main() {
             await (0, commands_1.up)({
                 ensemble,
                 name: args.name,
-                agent: args.agent ?? 'claude',
+                agent: resolvedAgent(),
                 ...overrides,
             });
             break;
         case 'init':
-            await (0, commands_1.init)({ dir: args.dir });
+            await (0, commands_1.init)({ dir: args.dir, project: args.project });
             break;
         case 'config':
             await (0, config_command_1.configCommand)(args.positional);