claude-tempo 0.2.0 → 0.2.1

package/README.md

@@ -156,7 +156,6 @@ The `claude-tempo` CLI handles setup, session management, and diagnostics.
 ```
 --temporal-address <addr>   Temporal server address (default: localhost:7233)
 -n, --name <name>           Set the player name for the session (start/conduct/up)
---agent <claude|copilot>    Agent type to spawn (default: claude; start/conduct)
 --skip-preflight            Skip preflight checks (start/conduct)
 --background, -d            Run Temporal in background (server only)
 --dir <path>                Target directory for init (default: cwd)
@@ -187,7 +186,6 @@ ok You're all set!
 
   What next?
   claude-tempo start myband    Add a player session
-  claude-tempo start myband --agent copilot -n copilot-1   Add a Copilot player
   claude-tempo status myband   See who's active
   Or ask the conductor to recruit players for you
 ```
@@ -395,8 +393,14 @@ When a Claude Code session crashes or is closed without graceful shutdown, its T
 
 This means you don't need to manually clean up crashed sessions — just `cue` the dead player and the system handles the rest.
 
+## Known limitations
+
+- **`recruit` requires manual acknowledgment**: Recruited Claude Code sessions use `--dangerously-load-development-channels` to enable channel-based message delivery. Claude Code shows an interactive confirmation prompt that must be manually acknowledged (press Enter) in the spawned terminal window. This will be resolved once claude-tempo is published as an approved channel plugin. Copilot bridge sessions do not have this limitation.
+
 ## Copilot CLI integration (experimental)
 
+> **Warning:** Copilot bridge support is **experimental** and subject to breaking changes. Copilot bridge sessions are headless — they have no interactive terminal. A Claude conductor (or custom Temporal client) is required to send them work via `cue`. Do not rely on this feature for production workflows.
+
 GitHub Copilot CLI sessions can join an ensemble via the **Copilot bridge**. The bridge uses the [Copilot SDK](https://github.com/github/copilot-sdk) to spawn a Copilot session with claude-tempo as an MCP server, and injects incoming messages as prompts.
 
 ### Setup
@@ -413,54 +417,26 @@ You also need:
 
 ### Starting a Copilot player
 
-```bash
-# Via CLI (recommended):
-claude-tempo start --agent copilot -n copilot-dev
-
-# Or directly with env vars (Linux/macOS):
-CLAUDE_TEMPO_ENSEMBLE=default COPILOT_BRIDGE_NAME=copilot-dev npx ts-node src/copilot-bridge.ts
-
-# Or directly with env vars (Windows PowerShell):
-$env:TEMPORAL_ADDRESS="localhost:7233"; $env:CLAUDE_TEMPO_ENSEMBLE="default"; $env:COPILOT_BRIDGE_NAME="copilot-dev"; npx ts-node src/copilot-bridge.ts
-
-# Or from any session in the ensemble, recruit one:
-# "Recruit a copilot session named 'copilot-dev' with agent copilot"
-```
+The easiest way to add a Copilot player is via the `recruit` tool from any active session in the ensemble. The `agent` parameter accepts `"claude"` (default) or `"copilot"`:
 
-The CLI `--agent` flag and the `recruit` tool's `agent` parameter both accept `"claude"` (default) or `"copilot"`.
+> "Recruit a copilot session named 'copilot-dev' in /repos/my-project with agent copilot"
 
-### Shell shortcuts
+This spawns a headless bridge process, registers it as a Temporal workflow, and sets the player name automatically.
 
-Add these functions to your shell profile to simplify launching Copilot bridge sessions:
+<details>
+<summary>Advanced: running the bridge directly</summary>
 
-**Linux/macOS** — add to `~/.bashrc` or `~/.zshrc`:
+You can also start the bridge manually with environment variables:
 
 ```bash
-copilot-tempo() {
-  CLAUDE_TEMPO_ENSEMBLE="${1:-default}" COPILOT_BRIDGE_NAME="${2}" \
-    npx ts-node /path/to/claude-tempo/src/copilot-bridge.ts
-}
-```
-
-**Windows** — add to your PowerShell `$PROFILE`:
+# Linux/macOS
+CLAUDE_TEMPO_ENSEMBLE=default COPILOT_BRIDGE_NAME=copilot-dev npx ts-node src/copilot-bridge.ts
 
-```powershell
-function copilot-tempo($ensemble = "default", $name = "") {
-  $env:TEMPORAL_ADDRESS = "localhost:7233"
-  $env:CLAUDE_TEMPO_ENSEMBLE = $ensemble
-  $env:COPILOT_BRIDGE_NAME = $name
-  npx ts-node C:\path\to\claude-tempo\src\copilot-bridge.ts
-  $env:CLAUDE_TEMPO_ENSEMBLE = ""
-  $env:COPILOT_BRIDGE_NAME = ""
-}
+# Windows PowerShell
+$env:TEMPORAL_ADDRESS="localhost:7233"; $env:CLAUDE_TEMPO_ENSEMBLE="default"; $env:COPILOT_BRIDGE_NAME="copilot-dev"; npx ts-node src/copilot-bridge.ts
 ```
 
-Usage:
-
-```bash
-copilot-tempo                        # join "default" ensemble, auto-generated name
-copilot-tempo my-project copilot-1   # join "my-project" ensemble as "copilot-1"
-```
+</details>
 
 ### How it works
 
@@ -481,10 +457,8 @@ copilot-tempo my-project copilot-1   # join "my-project" ensemble as "copilot-1"
 
 ### Limitations
 
-- **`recruit` requires manual acknowledgment (Claude backend)**: Recruited Claude Code sessions use `--dangerously-load-development-channels` to enable channel-based message delivery. Claude Code shows an interactive confirmation prompt that must be manually acknowledged (press Enter) in the spawned terminal window. This will be resolved once claude-tempo is published as an approved channel plugin. The Copilot backend does not have this limitation.
 - **No interactive access** — Copilot bridge sessions run in the background. Unlike Claude Code sessions where you can chat directly, bridge sessions only respond to cues from other players. To send messages to a bridge session, use `cue` from another player or signal the workflow directly via the Temporal CLI.
-- **Conductor polling latency** — Copilot conductors poll for messages every 2 seconds, unlike Claude Code conductors which receive instant channel notifications. This adds slight latency to orchestration.
-- **No push-based message delivery** — the bridge polls for messages (2s interval), unlike Claude Code sessions which receive instant channel notifications.
+- **Polling latency** — the bridge polls for messages every 2 seconds, unlike Claude Code sessions which receive instant channel notifications. This adds slight latency to message delivery and orchestration.
 - **Copilot sessions must be spawned via the bridge** to participate (not standalone Copilot CLI).
 - **The `@github/copilot-sdk` adds ~243MB** to node_modules when installed.
 - **Node 20+ required for Copilot features** — the `@github/copilot-sdk` requires Node.js 20 or later. The rest of claude-tempo works on Node 18+.

package/dist/cli/commands.d.ts

@@ -1,10 +1,11 @@
+import { AgentType } from '../types';
 interface StartOpts {
     ensemble: string;
     conductor: boolean;
     temporalAddress: string;
     name?: string;
     skipPreflight?: boolean;
-    agent: 'claude' | 'copilot';
+    agent: AgentType;
 }
 export declare function start(opts: StartOpts): Promise<void>;
 interface StatusOpts {

package/dist/cli/commands.js

@@ -87,38 +87,14 @@ async function start(opts) {
     }
     out.log(`Starting ${out.bold(role)} in ensemble ${out.cyan(opts.ensemble)}${opts.agent === 'copilot' ? out.dim(' (copilot)') : ''}`);
     if (opts.agent === 'copilot') {
-        // Spawn copilot-bridge as a detached headless subprocess
-        const isDev = __filename.endsWith('.ts');
-        const cmd = isDev ? 'npx' : 'node';
-        const cmdArgs = isDev
-            ? ['ts-node', (0, path_1.resolve)(__dirname, '..', '..', 'src', 'copilot-bridge.ts')]
-            : [(0, path_1.resolve)(__dirname, '..', 'copilot-bridge.js')];
-        // Log bridge output for debugging
-        const fs = require('fs');
-        const logName = opts.name || `copilot-${Date.now()}`;
-        const logPath = (0, path_1.join)(workDir, 'logs', `${logName}.log`);
-        fs.mkdirSync((0, path_1.join)(workDir, 'logs'), { recursive: true });
-        const logFd = fs.openSync(logPath, 'a');
-        let child;
-        try {
-            child = (0, child_process_1.spawn)(cmd, cmdArgs, {
-                cwd: workDir,
-                detached: true,
-                stdio: ['ignore', logFd, logFd],
-                env: {
-                    ...process.env,
-                    CLAUDE_TEMPO_ENSEMBLE: opts.ensemble,
-                    COPILOT_BRIDGE_NAME: opts.name || '',
-                    TEMPORAL_ADDRESS: opts.temporalAddress,
-                    ...(opts.conductor ? { CLAUDE_TEMPO_CONDUCTOR: 'true' } : {}),
-                },
-            });
-            child.unref();
-        }
-        finally {
-            fs.closeSync(logFd);
-        }
-        out.success(`Launched copilot bridge${opts.name ? ` "${opts.name}"` : ''} (pid ${child.pid ?? 'unknown'})`);
+        const { pid } = (0, spawn_1.spawnCopilotBridge)({
+            name: opts.name || `copilot-${Date.now()}`,
+            ensemble: opts.ensemble,
+            temporalAddress: opts.temporalAddress,
+            isConductor: opts.conductor,
+            workDir,
+        });
+        out.success(`Launched copilot bridge${opts.name ? ` "${opts.name}"` : ''} (pid ${pid ?? 'unknown'})`);
     }
     else {
         const claudeArgs = [
@@ -129,13 +105,13 @@ async function start(opts) {
             claudeArgs.push('-n', opts.name);
         }
         const envVars = {
-            CLAUDE_TEMPO_ENSEMBLE: opts.ensemble,
+            [config_1.ENV.ENSEMBLE]: opts.ensemble,
         };
         if (opts.conductor) {
-            envVars.CLAUDE_TEMPO_CONDUCTOR = 'true';
+            envVars[config_1.ENV.CONDUCTOR] = 'true';
         }
         if (opts.name) {
-            envVars.CLAUDE_TEMPO_PLAYER_NAME = opts.name;
+            envVars[config_1.ENV.PLAYER_NAME] = opts.name;
         }
         const { pid } = (0, spawn_1.spawnInTerminal)(claudeArgs, workDir, envVars);
         out.success(`Launched ${role} session${opts.name ? ` "${opts.name}"` : ''} (pid ${pid ?? 'unknown'})`);
@@ -454,8 +430,8 @@ async function up(opts) {
     if (opts.name)
         claudeArgs.push('-n', opts.name);
     const { pid } = (0, spawn_1.spawnInTerminal)(claudeArgs, process.cwd(), {
-        CLAUDE_TEMPO_ENSEMBLE: opts.ensemble,
-        CLAUDE_TEMPO_CONDUCTOR: 'true',
+        [config_1.ENV.ENSEMBLE]: opts.ensemble,
+        [config_1.ENV.CONDUCTOR]: 'true',
     });
     console.log();
     out.success('You\'re all set!');

package/dist/cli.js

@@ -37,11 +37,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commands_1 = require("./cli/commands");
 const preflight_1 = require("./cli/preflight");
 const out = __importStar(require("./cli/output"));
+const config_1 = require("./config");
 function parseArgs(argv) {
     const result = {
         command: 'help',
         positional: [],
-        temporalAddress: process.env.TEMPORAL_ADDRESS || 'localhost:7233',
+        temporalAddress: process.env[config_1.ENV.TEMPORAL_ADDRESS] || 'localhost:7233',
         dir: process.cwd(),
         skipPreflight: false,
         background: false,
@@ -99,7 +100,7 @@ function parseArgs(argv) {
 }
 async function main() {
     const args = parseArgs(process.argv.slice(2));
-    const ensemble = args.positional[1] || process.env.CLAUDE_TEMPO_ENSEMBLE || 'default';
+    const ensemble = args.positional[1] || process.env[config_1.ENV.ENSEMBLE] || 'default';
     switch (args.command) {
         case 'conduct':
             await (0, commands_1.start)({

package/dist/config.d.ts

@@ -1,3 +1,15 @@
+/** Environment variable name constants — use these instead of string literals. */
+export declare const ENV: {
+    readonly ENSEMBLE: "CLAUDE_TEMPO_ENSEMBLE";
+    readonly CONDUCTOR: "CLAUDE_TEMPO_CONDUCTOR";
+    readonly PLAYER_NAME: "CLAUDE_TEMPO_PLAYER_NAME";
+    readonly TASK_QUEUE: "CLAUDE_TEMPO_TASK_QUEUE";
+    readonly BRIDGE_NAME: "COPILOT_BRIDGE_NAME";
+    readonly BRIDGE_MODE: "CLAUDE_TEMPO_BRIDGE_MODE";
+    readonly BRIDGE_MODEL: "COPILOT_BRIDGE_MODEL";
+    readonly TEMPORAL_ADDRESS: "TEMPORAL_ADDRESS";
+    readonly TEMPORAL_NAMESPACE: "TEMPORAL_NAMESPACE";
+};
 export interface Config {
     temporalAddress: string;
     temporalNamespace: string;

package/dist/config.js

@@ -1,14 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV = void 0;
 exports.getConfig = getConfig;
 exports.sessionWorkflowId = sessionWorkflowId;
 exports.conductorWorkflowId = conductorWorkflowId;
+/** Environment variable name constants — use these instead of string literals. */
+exports.ENV = {
+    ENSEMBLE: 'CLAUDE_TEMPO_ENSEMBLE',
+    CONDUCTOR: 'CLAUDE_TEMPO_CONDUCTOR',
+    PLAYER_NAME: 'CLAUDE_TEMPO_PLAYER_NAME',
+    TASK_QUEUE: 'CLAUDE_TEMPO_TASK_QUEUE',
+    BRIDGE_NAME: 'COPILOT_BRIDGE_NAME',
+    BRIDGE_MODE: 'CLAUDE_TEMPO_BRIDGE_MODE',
+    BRIDGE_MODEL: 'COPILOT_BRIDGE_MODEL',
+    TEMPORAL_ADDRESS: 'TEMPORAL_ADDRESS',
+    TEMPORAL_NAMESPACE: 'TEMPORAL_NAMESPACE',
+};
 function getConfig() {
     return {
-        temporalAddress: process.env.TEMPORAL_ADDRESS ?? 'localhost:7233',
-        temporalNamespace: process.env.TEMPORAL_NAMESPACE ?? 'default',
-        taskQueue: process.env.CLAUDE_TEMPO_TASK_QUEUE ?? 'claude-tempo',
-        ensemble: process.env.CLAUDE_TEMPO_ENSEMBLE ?? 'default',
+        temporalAddress: process.env[exports.ENV.TEMPORAL_ADDRESS] ?? 'localhost:7233',
+        temporalNamespace: process.env[exports.ENV.TEMPORAL_NAMESPACE] ?? 'default',
+        taskQueue: process.env[exports.ENV.TASK_QUEUE] ?? 'claude-tempo',
+        ensemble: process.env[exports.ENV.ENSEMBLE] ?? 'default',
     };
 }
 /** Build a workflow ID for a player session: claude-session-{ensemble}-{playerId} */

package/dist/copilot-bridge.js

@@ -101,8 +101,8 @@ async function createSessionWithTimeout(copilotClient, sessionConfig, timeoutMs
 }
 async function main() {
     const config = (0, config_1.getConfig)();
-    const playerName = process.env.COPILOT_BRIDGE_NAME;
-    const model = process.env.COPILOT_BRIDGE_MODEL;
+    const playerName = process.env[config_1.ENV.BRIDGE_NAME];
+    const model = process.env[config_1.ENV.BRIDGE_MODEL];
     const workDir = process.cwd();
     log(`Starting Copilot bridge in ${workDir} (ensemble: ${config.ensemble})`);
     // Connect Temporal client (for polling only — the MCP server child process runs its own worker)
@@ -117,10 +117,10 @@ async function main() {
     // `claude-session-{ensemble}-{playerId}`, where playerId comes from
     // CLAUDE_TEMPO_PLAYER_NAME or a random hex. We pass CLAUDE_TEMPO_PLAYER_NAME
     // to the MCP server env so both sides agree on the ID.
-    const isConductor = !!process.env.CLAUDE_TEMPO_CONDUCTOR;
+    const isConductor = !!process.env[config_1.ENV.CONDUCTOR];
     const playerIdForWorkflow = isConductor
         ? 'conductor'
-        : (process.env.CLAUDE_TEMPO_PLAYER_NAME || playerName || `copilot-${Date.now()}`);
+        : (process.env[config_1.ENV.PLAYER_NAME] || playerName || `copilot-${Date.now()}`);
     const expectedWorkflowId = `claude-session-${config.ensemble}-${playerIdForWorkflow}`;
     // Build the MCP server command — always use the compiled dist/server.js
     // Run `npm run build` (or `pnpm build`) before using the bridge.
@@ -134,13 +134,13 @@ async function main() {
     const serverArgs = [serverJsPath];
     const mcpEnv = {
         ...cleanEnv(),
-        CLAUDE_TEMPO_ENSEMBLE: config.ensemble,
-        TEMPORAL_ADDRESS: config.temporalAddress,
-        TEMPORAL_NAMESPACE: config.temporalNamespace,
-        CLAUDE_TEMPO_TASK_QUEUE: config.taskQueue,
-        CLAUDE_TEMPO_CONDUCTOR: process.env.CLAUDE_TEMPO_CONDUCTOR || '',
-        CLAUDE_TEMPO_BRIDGE_MODE: '1', // disable MCP server's message poller — bridge handles delivery
-        CLAUDE_TEMPO_PLAYER_NAME: playerIdForWorkflow, // ensures MCP server uses same workflow ID
+        [config_1.ENV.ENSEMBLE]: config.ensemble,
+        [config_1.ENV.TEMPORAL_ADDRESS]: config.temporalAddress,
+        [config_1.ENV.TEMPORAL_NAMESPACE]: config.temporalNamespace,
+        [config_1.ENV.TASK_QUEUE]: config.taskQueue,
+        [config_1.ENV.CONDUCTOR]: process.env[config_1.ENV.CONDUCTOR] || '',
+        [config_1.ENV.BRIDGE_MODE]: '1', // disable MCP server's message poller — bridge handles delivery
+        [config_1.ENV.PLAYER_NAME]: playerIdForWorkflow, // ensures MCP server uses same workflow ID
     };
     // Spawn Copilot SDK client and session
     const copilotClient = new CopilotClient({

package/dist/server.js

@@ -79,8 +79,8 @@ function getGitInfo(workDir) {
 }
 async function main() {
     // Only activate when explicitly opted in via CLAUDE_TEMPO_ENSEMBLE
-    if (!process.env.CLAUDE_TEMPO_ENSEMBLE) {
-        log('CLAUDE_TEMPO_ENSEMBLE not set — MCP server idle (no workflow started)');
+    if (!process.env[config_1.ENV.ENSEMBLE]) {
+        log(`${config_1.ENV.ENSEMBLE} not set — MCP server idle (no workflow started)`);
         // Keep the process alive so Claude Code doesn't see a crash, but do nothing
         const transport = new stdio_js_1.StdioServerTransport();
         const idleServer = new mcp_js_1.McpServer({ name: 'claude-tempo', version: '0.1.0' });
@@ -88,8 +88,8 @@ async function main() {
         return;
     }
     const config = (0, config_1.getConfig)();
-    const isConductor = process.env.CLAUDE_TEMPO_CONDUCTOR === 'true';
-    let playerId = isConductor ? 'conductor' : (process.env.CLAUDE_TEMPO_PLAYER_NAME || crypto.randomBytes(4).toString('hex'));
+    const isConductor = process.env[config_1.ENV.CONDUCTOR] === 'true';
+    let playerId = isConductor ? 'conductor' : (process.env[config_1.ENV.PLAYER_NAME] || crypto.randomBytes(4).toString('hex'));
     const getPlayerId = () => playerId;
     const setPlayerId = (id) => { playerId = id; };
     const workDir = process.cwd();
@@ -185,7 +185,7 @@ async function main() {
     // Skip when running under the Copilot bridge: the bridge has its own poller that
     // injects messages via sendAndWait. If both pollers run, this one wins the race and
     // sends messages via notifications/claude/channel — which Copilot doesn't understand.
-    const isBridgeMode = process.env.CLAUDE_TEMPO_BRIDGE_MODE === '1';
+    const isBridgeMode = process.env[config_1.ENV.BRIDGE_MODE] === '1';
     const stopPoller = isBridgeMode
         ? () => { } // no-op — bridge handles message delivery
         : (0, channel_1.startMessagePoller)(handle, async (messages) => {

package/dist/spawn.d.ts

@@ -31,3 +31,22 @@ export declare function buildClaudeCommand(claudeBin: string, claudeArgs: string
 export declare function spawnInTerminal(claudeArgs: string[], workDir: string, envVars: Record<string, string>): {
     pid: number | undefined;
 };
+export interface CopilotBridgeOpts {
+    name: string;
+    ensemble: string;
+    temporalAddress: string;
+    isConductor?: boolean;
+    workDir: string;
+    /** Directory for log and PID files. Defaults to `logs/` inside workDir. */
+    logDir?: string;
+}
+export interface CopilotBridgeResult {
+    pid: number | undefined;
+    logPath: string;
+    pidPath: string;
+}
+/**
+ * Spawn a copilot bridge as a detached headless subprocess.
+ * Sets up log file, PID file, and all required env vars.
+ */
+export declare function spawnCopilotBridge(opts: CopilotBridgeOpts): CopilotBridgeResult;

package/dist/spawn.js

@@ -6,10 +6,12 @@ exports.detectMacTerminal = detectMacTerminal;
 exports.findLinuxTerminal = findLinuxTerminal;
 exports.buildClaudeCommand = buildClaudeCommand;
 exports.spawnInTerminal = spawnInTerminal;
+exports.spawnCopilotBridge = spawnCopilotBridge;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
+const config_1 = require("./config");
 const log = (...args) => console.error('[claude-tempo:spawn]', ...args);
 /** POSIX shell-safe single-quoting (works in bash, zsh, and fish) */
 function shellQuote(s) {
@@ -207,3 +209,51 @@ function spawnInTerminal(claudeArgs, workDir, envVars) {
     child.unref();
     return { pid: child.pid };
 }
+/**
+ * Resolve the path to the compiled copilot-bridge.js.
+ * In dev (ts-node), returns a ts-node command; in production, returns the dist path.
+ */
+function resolveBridgePath() {
+    const isDev = __filename.endsWith('.ts');
+    if (isDev) {
+        return { cmd: 'npx', args: ['ts-node', (0, path_1.resolve)(__dirname, 'copilot-bridge.ts')] };
+    }
+    return { cmd: 'node', args: [(0, path_1.resolve)(__dirname, 'copilot-bridge.js')] };
+}
+/**
+ * Spawn a copilot bridge as a detached headless subprocess.
+ * Sets up log file, PID file, and all required env vars.
+ */
+function spawnCopilotBridge(opts) {
+    const { cmd, args } = resolveBridgePath();
+    const logDirPath = opts.logDir || (0, path_1.join)(opts.workDir, 'logs');
+    const logName = opts.name || `copilot-${Date.now()}`;
+    const logPath = (0, path_1.join)(logDirPath, `${logName}.log`);
+    const pidPath = (0, path_1.join)(logDirPath, `${logName}.pid`);
+    (0, fs_1.mkdirSync)(logDirPath, { recursive: true });
+    const logFd = (0, fs_1.openSync)(logPath, 'a');
+    let child;
+    try {
+        child = (0, child_process_1.spawn)(cmd, args, {
+            cwd: opts.workDir,
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+            env: {
+                ...process.env,
+                [config_1.ENV.ENSEMBLE]: opts.ensemble,
+                [config_1.ENV.BRIDGE_NAME]: opts.name,
+                [config_1.ENV.TEMPORAL_ADDRESS]: opts.temporalAddress,
+                ...(opts.isConductor ? { [config_1.ENV.CONDUCTOR]: 'true' } : {}),
+            },
+        });
+        child.unref();
+    }
+    finally {
+        (0, fs_1.closeSync)(logFd);
+    }
+    if (child.pid != null) {
+        (0, fs_1.writeFileSync)(pidPath, String(child.pid));
+    }
+    log(`Spawned copilot-bridge (pid ${child.pid}) in ${opts.workDir} as "${opts.name}"`);
+    return { pid: child.pid, logPath, pidPath };
+}

package/dist/tools/recruit.js

@@ -1,42 +1,8 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerRecruitTool = registerRecruitTool;
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
 const zod_1 = require("zod");
+const config_1 = require("../config");
 const spawn_1 = require("../spawn");
 const resolve_1 = require("./resolve");
 const helpers_1 = require("./helpers");
@@ -84,25 +50,13 @@ function registerRecruitTool(server, client, config, getPlayerId) {
             }
             // Spawn the session using the selected backend
             if (agent === 'copilot') {
-                // Use ts-node in dev, compiled JS in production
-                const isDev = __filename.endsWith('.ts');
-                const cmd = isDev ? 'npx' : 'node';
-                const cmdArgs = isDev
-                    ? ['ts-node', path.resolve(__dirname, '..', 'src', 'copilot-bridge.ts')]
-                    : [path.resolve(__dirname, '..', 'copilot-bridge.js')];
-                const child = (0, child_process_1.spawn)(cmd, cmdArgs, {
-                    cwd: workDir,
-                    detached: true,
-                    stdio: 'ignore',
-                    env: {
-                        ...process.env,
-                        CLAUDE_TEMPO_ENSEMBLE: config.ensemble,
-                        COPILOT_BRIDGE_NAME: name,
-                        TEMPORAL_ADDRESS: config.temporalAddress,
-                    },
+                const { pid } = (0, spawn_1.spawnCopilotBridge)({
+                    name,
+                    ensemble: config.ensemble,
+                    temporalAddress: config.temporalAddress,
+                    workDir,
                 });
-                child.unref();
-                log(`Spawned copilot-bridge (pid ${child.pid}) in ${workDir} as "${name}"`);
+                log(`Spawned copilot-bridge (pid ${pid}) in ${workDir} as "${name}"`);
             }
             else {
                 const spawnArgs = [
@@ -111,8 +65,8 @@ function registerRecruitTool(server, client, config, getPlayerId) {
                     '-n', name,
                 ];
                 const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, workDir, {
-                    CLAUDE_TEMPO_ENSEMBLE: config.ensemble,
-                    CLAUDE_TEMPO_CONDUCTOR: '',
+                    [config_1.ENV.ENSEMBLE]: config.ensemble,
+                    [config_1.ENV.CONDUCTOR]: '',
                 });
                 log(`Spawned claude process (pid ${pid}) in ${workDir} as "${name}"`);
             }

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+export type AgentType = 'claude' | 'copilot';
 export interface SessionMetadata {
     playerId: string;
     ensemble: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-tempo",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "MCP server for multi-session Claude Code coordination via Temporal",
   "repository": {
     "type": "git",