claude-tempo 0.3.0 → 0.4.1

package/README.md

@@ -32,7 +32,7 @@ This will:
 1. Check that Temporal CLI is installed
 2. Start the Temporal dev server (data persists in `~/.claude-tempo/`)
 3. Register required search attributes
-4. Create `.mcp.json` in your project
+4. Register the claude-tempo MCP server (globally by default)
 5. Launch a conductor session in a new terminal window
 
 Then add players:
@@ -52,7 +52,7 @@ For more control, run each step individually:
 # Start Temporal dev server (keep running)
 claude-tempo server
 
-# In your project directory, create .mcp.json
+# Register claude-tempo MCP server (globally by default)
 cd your-project
 claude-tempo init
 
@@ -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:
@@ -355,6 +352,7 @@ export TEMPORAL_API_KEY=tcl_...
 | `CLAUDE_TEMPO_ENSEMBLE` | `default` | Ensemble name |
 | `CLAUDE_TEMPO_CONDUCTOR` | `false` | Enable conductor mode |
 | `CLAUDE_TEMPO_PLAYER_NAME` | *(random hex)* | Player name on startup |
+| `CLAUDE_TEMPO_DEFAULT_AGENT` | `claude` | Default agent type (`claude` or `copilot`) |
 
 ## Stale session cleanup
 
@@ -362,7 +360,7 @@ When a session crashes or closes without graceful shutdown, Temporal detects it
 
 - If a message to a dead session remains undelivered for **3 minutes**, the workflow self-completes
 - Before exiting, it notifies the conductor with the undelivered message so work can be reassigned
-- Idle sessions with no pending messages remain running until the 24-hour timeout
+- Idle sessions with no pending messages are probed after 1 hour of inactivity via a heartbeat ping; if the ping goes undelivered, the session self-completes
 
 No manual cleanup needed — `cue` a dead player and the system handles the rest.
 
@@ -370,52 +368,60 @@ No manual cleanup needed — `cue` a dead player and the system handles the rest
 
 > **Warning:** Copilot bridge support is experimental and subject to breaking changes.
 
-GitHub Copilot CLI sessions can join an ensemble via the Copilot bridge. Bridge sessions are headless — they require a Claude conductor or custom Temporal client to receive work via `cue`.
+GitHub Copilot CLI sessions can join an ensemble via the Copilot bridge. Bridge sessions are headless — they require a conductor or another player to receive work via `cue`.
 
 <details>
 <summary>Setup and usage</summary>
 
 ### Prerequisites
 
+- [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) installed and authenticated
+- An active GitHub Copilot subscription
+- Node.js 20+
+- Install the Copilot SDK: `npm install @github/copilot-sdk`
+
+### Starting Copilot sessions
+
+Use `--agent copilot` with any session-launching command:
+
 ```bash
-npm install @github/copilot-sdk    # optional dependency (~243MB)
+claude-tempo start myband --agent copilot -n copilot-1      # start a player
+claude-tempo conduct myband --agent copilot                  # start a conductor
+claude-tempo up myband --agent copilot                       # full setup
 ```
 
-Also requires [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) installed, authenticated, with an active subscription. Node 20+ required for Copilot features.
+Or recruit from within any active session:
 
-### Starting a Copilot player
+> "Recruit a copilot session named 'copilot-dev' in /repos/my-project with agent copilot"
 
-The easiest way is via `recruit` from any active session:
+### Setting a default agent
 
-> "Recruit a copilot session named 'copilot-dev' in /repos/my-project with agent copilot"
+To avoid passing `--agent copilot` every time:
 
-Or start the bridge directly:
+```bash
+claude-tempo config set default-agent copilot
+```
+
+Or via environment variable:
 
 ```bash
-CLAUDE_TEMPO_ENSEMBLE=default COPILOT_BRIDGE_NAME=copilot-dev npx ts-node src/copilot-bridge.ts
+export CLAUDE_TEMPO_DEFAULT_AGENT=copilot
 ```
 
-### How it works
+Resolution order: `--agent` flag → `CLAUDE_TEMPO_DEFAULT_AGENT` env → config file → `claude`.
 
-1. Bridge spawns a Copilot CLI session via the SDK with claude-tempo as MCP server
-2. MCP server registers the session as a Temporal workflow
-3. Bridge polls for pending messages every 2 seconds
-4. Messages are injected as prompts via `session.sendAndWait()`
-5. The Copilot session can use all claude-tempo tools
+### Model override
 
-### Copilot environment variables
+Set `COPILOT_BRIDGE_MODEL` to use a specific model for Copilot sessions:
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `COPILOT_BRIDGE_NAME` | *(none)* | Player name |
-| `COPILOT_BRIDGE_MODEL` | *(Copilot default)* | Model override |
-| `GITHUB_TOKEN` | *(logged-in user)* | GitHub auth token |
+```bash
+COPILOT_BRIDGE_MODEL=gpt-4o claude-tempo start myband --agent copilot
+```
 
 ### Limitations
 
-- No interactive access — bridge sessions only respond to cues
-- 2-second polling latency (vs instant for Claude Code sessions)
-- Must be spawned via the bridge to participate
+- Headless only — bridge sessions respond to cues, no interactive terminal
+- ~2-second polling latency (vs instant for Claude Code sessions)
 - `@github/copilot-sdk` adds ~243MB to node_modules
 - Node 20+ required (rest of claude-tempo works on Node 18+)
 

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;
+}