claude-tempo 0.1.3 → 0.2.0

package/CLAUDE.md

@@ -16,6 +16,7 @@ claude-tempo is an MCP server that enables multiple Claude Code sessions to coor
 ```
 src/
 ├── server.ts          # MCP server entry point
+├── copilot-bridge.ts  # Copilot SDK bridge for Copilot CLI players
 ├── worker.ts          # Temporal worker setup
 ├── workflows/
 │   ├── session.ts     # claude-session workflow

package/README.md

@@ -156,6 +156,7 @@ 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)
@@ -186,6 +187,7 @@ 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
 ```
@@ -393,9 +395,99 @@ 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
+## Copilot CLI integration (experimental)
 
-- **`recruit` requires manual acknowledgment**: Recruited 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.
+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
+
+The Copilot SDK is an optional dependency — install it only if you want Copilot support:
+
+```bash
+npm install @github/copilot-sdk
+```
+
+You also need:
+- [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) installed and authenticated
+- An active GitHub Copilot subscription
+
+### 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 CLI `--agent` flag and the `recruit` tool's `agent` parameter both accept `"claude"` (default) or `"copilot"`.
+
+### Shell shortcuts
+
+Add these functions to your shell profile to simplify launching Copilot bridge sessions:
+
+**Linux/macOS** — add to `~/.bashrc` or `~/.zshrc`:
+
+```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`:
+
+```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 = ""
+}
+```
+
+Usage:
+
+```bash
+copilot-tempo                        # join "default" ensemble, auto-generated name
+copilot-tempo my-project copilot-1   # join "my-project" ensemble as "copilot-1"
+```
+
+### How it works
+
+1. The bridge spawns a Copilot CLI session via the SDK with claude-tempo configured as an MCP server
+2. The MCP server registers the session as a Temporal workflow (same as Claude Code players)
+3. An initial prompt is sent to trigger MCP server initialization (the SDK lazily starts MCP servers)
+4. The bridge polls the workflow for pending messages every 2 seconds
+5. When messages arrive, they're injected as prompts via `session.sendAndWait()`
+6. The Copilot session can use all claude-tempo tools (`ensemble`, `cue`, `report`, etc.)
+
+### Environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `COPILOT_BRIDGE_NAME` | *(none)* | Player name (calls `set_name` automatically) |
+| `COPILOT_BRIDGE_MODEL` | *(Copilot default)* | Model override for the Copilot session |
+| `GITHUB_TOKEN` | *(logged-in user)* | GitHub auth token |
+
+### 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.
+- **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+.
 
 ## License
 

package/dist/cli/commands.d.ts

@@ -4,6 +4,7 @@ interface StartOpts {
     temporalAddress: string;
     name?: string;
     skipPreflight?: boolean;
+    agent: 'claude' | 'copilot';
 }
 export declare function start(opts: StartOpts): Promise<void>;
 interface StatusOpts {

package/dist/cli/commands.js

@@ -85,25 +85,61 @@ async function start(opts) {
             // No existing conductor — proceed normally
         }
     }
-    out.log(`Starting ${out.bold(role)} in ensemble ${out.cyan(opts.ensemble)}`);
-    const claudeArgs = [
-        '--dangerously-skip-permissions',
-        '--dangerously-load-development-channels', 'server:claude-tempo',
-    ];
-    if (opts.name) {
-        claudeArgs.push('-n', opts.name);
-    }
-    const envVars = {
-        CLAUDE_TEMPO_ENSEMBLE: opts.ensemble,
-    };
-    if (opts.conductor) {
-        envVars.CLAUDE_TEMPO_CONDUCTOR = 'true';
+    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'})`);
     }
-    if (opts.name) {
-        envVars.CLAUDE_TEMPO_PLAYER_NAME = opts.name;
+    else {
+        const claudeArgs = [
+            '--dangerously-skip-permissions',
+            '--dangerously-load-development-channels', 'server:claude-tempo',
+        ];
+        if (opts.name) {
+            claudeArgs.push('-n', opts.name);
+        }
+        const envVars = {
+            CLAUDE_TEMPO_ENSEMBLE: opts.ensemble,
+        };
+        if (opts.conductor) {
+            envVars.CLAUDE_TEMPO_CONDUCTOR = 'true';
+        }
+        if (opts.name) {
+            envVars.CLAUDE_TEMPO_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'})`);
     }
-    const { pid } = (0, spawn_1.spawnInTerminal)(claudeArgs, workDir, envVars);
-    out.success(`Launched ${role} session${opts.name ? ` "${opts.name}"` : ''} (pid ${pid ?? 'unknown'})`);
     out.log(`  Ensemble: ${opts.ensemble}`);
     out.log(`  Directory: ${workDir}`);
     out.log(`\nCheck status: ${out.dim('claude-tempo status ' + opts.ensemble)}`);
@@ -541,6 +577,7 @@ ${out.bold('Commands:')}
 ${out.bold('Options:')}
   --temporal-address <addr>   Temporal server address (default: localhost:7233)
   -n, --name <name>           Set the session window name (start/conduct/up only)
+  --agent <claude|copilot>    Agent type to spawn (default: claude; 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)
@@ -554,6 +591,7 @@ ${out.bold('Typical workflow:')}
   ${out.dim('claude-tempo server')}               Start Temporal (once, keep running)
   ${out.dim('claude-tempo conduct myband')}       Start a conductor
   ${out.dim('claude-tempo start myband')}         Add player sessions
+  ${out.dim('claude-tempo start myband --agent copilot -n copilot-1')}   Add a Copilot player
   ${out.dim('claude-tempo status myband')}        Check who's active
 
 ${out.bold('Environment:')}

package/dist/cli.js

@@ -68,6 +68,14 @@ function parseArgs(argv) {
         else if (arg === '--keep-mcp') {
             result.keepMcp = true;
         }
+        else if (arg === '--agent' && i + 1 < argv.length) {
+            const val = argv[++i];
+            if (val !== 'claude' && val !== 'copilot') {
+                out.error(`Invalid agent type: "${val}". Must be "claude" or "copilot".`);
+                process.exit(1);
+            }
+            result.agent = val;
+        }
         else if (arg === '--help' || arg === '-h') {
             result.command = 'help';
         }
@@ -100,6 +108,7 @@ async function main() {
                 temporalAddress: args.temporalAddress,
                 name: args.name,
                 skipPreflight: args.skipPreflight,
+                agent: args.agent ?? 'claude',
             });
             break;
         case 'start':
@@ -109,6 +118,7 @@ async function main() {
                 temporalAddress: args.temporalAddress,
                 name: args.name,
                 skipPreflight: args.skipPreflight,
+                agent: args.agent ?? 'claude',
             });
             break;
         case 'status':

package/dist/copilot-bridge.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copilot Bridge — allows GitHub Copilot CLI sessions to participate
+ * as players in a claude-tempo ensemble.
+ *
+ * The bridge:
+ * 1. Spawns a Copilot CLI session via the Copilot SDK
+ * 2. Configures it with claude-tempo as an MCP server (so it gets all tools)
+ * 3. Polls the Temporal workflow for pending messages
+ * 4. Injects messages as prompts via the SDK
+ *
+ * Usage:
+ *   npx ts-node src/copilot-bridge.ts
+ *
+ * Environment variables:
+ *   CLAUDE_TEMPO_ENSEMBLE     — ensemble name (default: "default")
+ *   CLAUDE_TEMPO_PLAYER_NAME  — player ID for workflow registration (set by spawner for deterministic workflow IDs)
+ *   COPILOT_BRIDGE_NAME       — player name for set_name (optional)
+ *   COPILOT_BRIDGE_MODEL      — model to use (optional)
+ *   GITHUB_TOKEN              — GitHub auth token (optional, uses logged-in user by default)
+ */
+export {};

package/dist/copilot-bridge.js

@@ -0,0 +1,388 @@
+"use strict";
+/**
+ * Copilot Bridge — allows GitHub Copilot CLI sessions to participate
+ * as players in a claude-tempo ensemble.
+ *
+ * The bridge:
+ * 1. Spawns a Copilot CLI session via the Copilot SDK
+ * 2. Configures it with claude-tempo as an MCP server (so it gets all tools)
+ * 3. Polls the Temporal workflow for pending messages
+ * 4. Injects messages as prompts via the SDK
+ *
+ * Usage:
+ *   npx ts-node src/copilot-bridge.ts
+ *
+ * Environment variables:
+ *   CLAUDE_TEMPO_ENSEMBLE     — ensemble name (default: "default")
+ *   CLAUDE_TEMPO_PLAYER_NAME  — player ID for workflow registration (set by spawner for deterministic workflow IDs)
+ *   COPILOT_BRIDGE_NAME       — player name for set_name (optional)
+ *   COPILOT_BRIDGE_MODEL      — model to use (optional)
+ *   GITHUB_TOKEN              — GitHub auth token (optional, uses logged-in user by default)
+ */
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const client_1 = require("@temporalio/client");
+const config_1 = require("./config");
+// Optional dependency — must be installed separately: npm install @github/copilot-sdk
+let CopilotClient;
+let approveAll;
+try {
+    const sdk = require('@github/copilot-sdk');
+    CopilotClient = sdk.CopilotClient;
+    approveAll = sdk.approveAll;
+}
+catch {
+    console.error('Error: @github/copilot-sdk is not installed.\n' +
+        'Install it with: npm install @github/copilot-sdk\n' +
+        'See the Copilot CLI integration section in the README.');
+    process.exit(1);
+}
+// Unbuffered logging — fs.writeSync(2, ...) bypasses Node.js stream buffering,
+// ensuring log output appears immediately even when stderr is redirected to a file.
+const log = (...args) => {
+    const msg = `[copilot-bridge] ${args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')}\n`;
+    fs.writeSync(2, msg);
+};
+/** Filter process.env to exclude undefined values (safe to spread as Record<string, string>). */
+const cleanEnv = () => Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined));
+const POLL_INTERVAL_MS = 2000;
+const CREATE_SESSION_TIMEOUT_MS = 45_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const MAX_SESSION_RECREATIONS = 2;
+/** Wrap createSession with a timeout so auth/network hangs don't block forever. */
+async function createSessionWithTimeout(copilotClient, sessionConfig, timeoutMs = CREATE_SESSION_TIMEOUT_MS) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`createSession timed out after ${timeoutMs / 1000}s — check Copilot auth and network connectivity`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([
+            copilotClient.createSession(sessionConfig),
+            timeout,
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function main() {
+    const config = (0, config_1.getConfig)();
+    const playerName = process.env.COPILOT_BRIDGE_NAME;
+    const model = process.env.COPILOT_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)
+    const connection = await client_1.Connection.connect({
+        address: config.temporalAddress,
+    });
+    const client = new client_1.Client({
+        connection,
+        namespace: config.temporalNamespace,
+    });
+    // Determine the expected workflow ID. The MCP server uses the pattern
+    // `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 playerIdForWorkflow = isConductor
+        ? 'conductor'
+        : (process.env.CLAUDE_TEMPO_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.
+    const serverJsPath = path.resolve(__dirname, '..', 'dist', 'server.js');
+    if (!fs.existsSync(serverJsPath)) {
+        log(`ERROR: ${serverJsPath} not found. Run 'pnpm build' first.`);
+        process.exit(1);
+    }
+    log(`MCP server path: ${serverJsPath}`);
+    const serverCommand = 'node';
+    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
+    };
+    // Spawn Copilot SDK client and session
+    const copilotClient = new CopilotClient({
+        logLevel: 'debug',
+        env: {
+            ...cleanEnv(),
+            ...(process.env.GITHUB_TOKEN ? { GITHUB_TOKEN: process.env.GITHUB_TOKEN } : {}),
+        },
+    });
+    const sessionConfig = {
+        // approveAll is intentional: Copilot bridge sessions run headless with no
+        // interactive terminal, so there is no way to prompt for permission approval.
+        // All tool calls are auto-approved by design — the bridge operator accepts
+        // this when launching the bridge process.
+        onPermissionRequest: approveAll,
+        workingDirectory: workDir,
+        mcpServers: {
+            'claude-tempo': {
+                command: serverCommand,
+                args: serverArgs,
+                env: mcpEnv,
+                tools: ['*'],
+            },
+        },
+        systemMessage: {
+            mode: 'append',
+            content: `You are part of the "${config.ensemble}" ensemble of Claude Code sessions coordinated via Temporal. ` +
+                `IMPORTANT: If you receive a message instructing you to call \`set_name\`, do so immediately before anything else. ` +
+                `When you receive a message from another session, treat it like a coworker asking for help — respond promptly, then resume your work. ` +
+                `Use \`set_name\` to give yourself a human-readable name. ` +
+                `Use \`ensemble\` to see who else is active. ` +
+                `Use \`cue\` to reply directly to the player who messaged you, or to ask others for help. ` +
+                `Use \`recruit\` if you need a session in a directory where none exists. ` +
+                `Use \`report\` to notify the conductor of task completion, blockers, or questions — always report when you finish a recruited task.`,
+        },
+        ...(model ? { model } : {}),
+    };
+    log('Creating Copilot session...');
+    let session = await createSessionWithTimeout(copilotClient, sessionConfig);
+    log(`Copilot session created: ${session.sessionId}`);
+    // Track session health — resets to true on any successful interaction
+    let sessionAlive = true;
+    let lastEventTime = Date.now();
+    let lastEventType = 'session.created';
+    function attachEventLogger(s) {
+        s.on((event) => {
+            lastEventTime = Date.now();
+            lastEventType = event.type;
+            // Log tool calls and completions fully, truncate verbose events
+            if (event.type === 'tool.execution_start' || event.type === 'tool.execution_complete') {
+                log(`[event:${event.type}]`, JSON.stringify(event.data ?? event).substring(0, 800));
+            }
+            else if (event.type === 'assistant.message') {
+                const data = event.data ?? event;
+                const tools = data.toolRequests?.map((t) => t.name).join(', ') || 'none';
+                log(`[event:${event.type}] content="${(data.content || '').substring(0, 200)}" tools=[${tools}]`);
+            }
+            else if (event.type === 'session.idle') {
+                log(`[event:session.idle] Session is idle`);
+            }
+            else if (event.type?.includes('error') || event.type?.includes('disconnect')) {
+                log(`[event:${event.type}]`, JSON.stringify(event.data ?? event).substring(0, 500));
+                sessionAlive = false;
+            }
+            else {
+                log(`[event:${event.type}]`);
+            }
+        });
+    }
+    attachEventLogger(session);
+    // Send an initial prompt to trigger MCP server initialization.
+    // The Copilot SDK doesn't start MCP server subprocesses until the session
+    // processes a message that could use tools. We await this so the workflow
+    // registers before we try to find it, and so subsequent sendAndWait calls
+    // don't collide with this one.
+    log('Sending initial prompt to trigger MCP server startup...');
+    try {
+        const t0 = Date.now();
+        const initResult = await session.sendAndWait({ prompt: 'Call the ensemble tool to list active sessions. Respond in one short sentence.' }, 120_000);
+        log(`Initial prompt completed in ${Date.now() - t0}ms, result:`, JSON.stringify(initResult)?.substring(0, 300));
+    }
+    catch (err) {
+        log(`Initial prompt error after ${Date.now()}ms:`, err?.message, err?.stack?.substring(0, 300));
+    }
+    // Wait for the MCP server's workflow to register in Temporal.
+    // We know the exact workflow ID because we pass CLAUDE_TEMPO_PLAYER_NAME to the
+    // MCP server — no need for a time-window heuristic that could misidentify workflows.
+    log(`Waiting for workflow ${expectedWorkflowId} to register...`);
+    const handle = client.workflow.getHandle(expectedWorkflowId);
+    let workflowReady = false;
+    for (let attempt = 0; attempt < 30; attempt++) {
+        try {
+            const desc = await handle.describe();
+            if (desc.status.name === 'RUNNING') {
+                workflowReady = true;
+                break;
+            }
+        }
+        catch {
+            // Workflow not yet started
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+        if (attempt % 5 === 4)
+            log(`Still waiting... attempt ${attempt + 1}/30`);
+    }
+    if (!workflowReady) {
+        log(`ERROR: Workflow ${expectedWorkflowId} did not register within 30 seconds`);
+        await session.disconnect();
+        await copilotClient.stop();
+        process.exit(1);
+    }
+    log(`Workflow ready: ${expectedWorkflowId}`);
+    // If a name was requested, send the set_name instruction
+    if (playerName) {
+        log(`Sending set_name instruction for "${playerName}"...`);
+        const t0 = Date.now();
+        await session.sendAndWait({ prompt: `Call set_name("${playerName}") immediately. Respond in one short sentence.` }, 120_000);
+        log(`set_name completed in ${Date.now() - t0}ms`);
+    }
+    // Start message poller — inject messages into the Copilot session.
+    // Tracks consecutive failures and attempts session recreation before giving up.
+    let polling = true;
+    let processing = false;
+    let pollCount = 0;
+    let consecutiveFailures = 0;
+    let sessionRecreations = 0;
+    /** Attempt to recreate the Copilot session after repeated failures. */
+    async function recreateSession() {
+        sessionRecreations++;
+        if (sessionRecreations > MAX_SESSION_RECREATIONS) {
+            log(`ERROR: Exceeded max session recreations (${MAX_SESSION_RECREATIONS}). Giving up.`);
+            return false;
+        }
+        log(`Attempting session recreation (${sessionRecreations}/${MAX_SESSION_RECREATIONS})...`);
+        try {
+            await session.disconnect().catch(() => { });
+            session = await createSessionWithTimeout(copilotClient, sessionConfig);
+            attachEventLogger(session);
+            sessionAlive = true;
+            consecutiveFailures = 0;
+            log(`Session recreated successfully: ${session.sessionId}`);
+            return true;
+        }
+        catch (err) {
+            log(`Session recreation failed: ${err?.message}`);
+            return false;
+        }
+    }
+    const poll = async () => {
+        if (!polling || processing)
+            return;
+        pollCount++;
+        // Periodic health check
+        if (pollCount % 30 === 0) { // every ~60 seconds
+            const silenceSec = ((Date.now() - lastEventTime) / 1000).toFixed(0);
+            log(`[health] poll #${pollCount}, sessionAlive=${sessionAlive}, lastEvent=${lastEventType} ${silenceSec}s ago`);
+        }
+        try {
+            const messages = await handle.query('pendingMessages');
+            if (messages.length === 0)
+                return;
+            processing = true;
+            const ids = messages.map((m) => m.id);
+            await handle.signal('markDelivered', ids);
+            // Format messages into a single prompt
+            const prompt = messages
+                .map((m) => `[Message from ${m.from}]: ${m.text}`)
+                .join('\n\n');
+            log(`Injecting ${messages.length} message(s) into Copilot session`);
+            log(`Prompt: ${prompt.substring(0, 300)}`);
+            if (!sessionAlive) {
+                log('WARNING: session appears dead, sendAndWait may hang');
+            }
+            const t0 = Date.now();
+            const result = await session.sendAndWait({ prompt }, 300_000); // 5 min timeout
+            const elapsed = Date.now() - t0;
+            log(`sendAndWait completed in ${elapsed}ms`);
+            log(`Response: ${JSON.stringify(result)?.substring(0, 500)}`);
+            // Success — reset failure tracking
+            consecutiveFailures = 0;
+            sessionAlive = true;
+            processing = false;
+        }
+        catch (err) {
+            processing = false;
+            consecutiveFailures++;
+            log(`Poll error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${err?.message}`);
+            log(`Error stack: ${err?.stack?.substring(0, 300)}`);
+            if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                log('Consecutive failure threshold reached — attempting session recovery');
+                const recovered = await recreateSession();
+                if (!recovered) {
+                    log('ERROR: Session recovery failed. Shutting down bridge.');
+                    polling = false;
+                    clearInterval(interval);
+                    process.exit(2);
+                }
+            }
+        }
+    };
+    const interval = setInterval(poll, POLL_INTERVAL_MS);
+    log('Message poller started. Bridge is running.');
+    // Write PID file so callers can find/kill orphaned bridge processes
+    const pidDir = path.join(workDir, 'logs');
+    const pidFile = path.join(pidDir, `${playerName || playerIdForWorkflow}.pid`);
+    try {
+        fs.mkdirSync(pidDir, { recursive: true });
+        fs.writeFileSync(pidFile, String(process.pid));
+        log(`PID file written: ${pidFile}`);
+    }
+    catch (err) {
+        log(`Warning: could not write PID file: ${err?.message}`);
+    }
+    // Graceful shutdown
+    const shutdown = async () => {
+        log('Shutting down...');
+        polling = false;
+        clearInterval(interval);
+        try {
+            await handle.signal('shutdown');
+        }
+        catch {
+            // workflow may already be gone
+        }
+        try {
+            await session.disconnect();
+        }
+        catch {
+            // session may already be disconnected
+        }
+        // Clean up PID file
+        try {
+            fs.unlinkSync(pidFile);
+        }
+        catch { /* may already be gone */ }
+        await copilotClient.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((err) => {
+    log('Fatal error:', err);
+    process.exit(1);
+});

package/dist/server.js

@@ -181,27 +181,33 @@ async function main() {
     (0, recruit_1.registerRecruitTool)(mcpServer, client, config, getPlayerId);
     (0, report_1.registerReportTool)(mcpServer, client, config, getPlayerId);
     (0, terminate_1.registerTerminateTool)(mcpServer, client, config, getPlayerId);
-    // Start message poller — push messages into Claude Code via channel notifications
-    const stopPoller = (0, channel_1.startMessagePoller)(handle, async (messages) => {
-        for (const msg of messages) {
-            log(`Message from ${msg.from}: ${msg.text}`);
-            try {
-                await mcpServer.server.notification({
-                    method: 'notifications/claude/channel',
-                    params: {
-                        content: msg.text,
-                        meta: {
-                            from_player: msg.from,
-                            sent_at: msg.timestamp,
+    // Start message poller — push messages into Claude Code via channel notifications.
+    // 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 stopPoller = isBridgeMode
+        ? () => { } // no-op — bridge handles message delivery
+        : (0, channel_1.startMessagePoller)(handle, async (messages) => {
+            for (const msg of messages) {
+                log(`Message from ${msg.from}: ${msg.text}`);
+                try {
+                    await mcpServer.server.notification({
+                        method: 'notifications/claude/channel',
+                        params: {
+                            content: msg.text,
+                            meta: {
+                                from_player: msg.from,
+                                sent_at: msg.timestamp,
+                            },
                         },
-                    },
-                });
-            }
-            catch (err) {
-                log('Channel notification error:', err);
+                    });
+                }
+                catch (err) {
+                    log('Channel notification error:', err);
+                }
             }
-        }
-    });
+        });
     // Connect MCP transport
     const transport = new stdio_js_1.StdioServerTransport();
     await mcpServer.connect(transport);

package/dist/tools/recruit.js

@@ -1,6 +1,41 @@
 "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 spawn_1 = require("../spawn");
 const resolve_1 = require("./resolve");
@@ -10,13 +45,15 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function registerRecruitTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'recruit', 'Start a new named Claude Code session in a directory. Rejects if the name is already active.', {
+    (0, helpers_1.defineTool)(server, 'recruit', 'Start a new named session in a directory. Rejects if the name is already active. Supports Claude Code or Copilot CLI agents.', {
         workDir: zod_1.z.string().describe('The working directory for the new session'),
         name: zod_1.z.string().describe('Name for the new session'),
         initialMessage: zod_1.z.string().optional()
             .describe('Optional task or message for the new session (sent after it sets its name)'),
+        agent: zod_1.z.enum(['claude', 'copilot']).default('claude')
+            .describe('Which agent to use: "claude" (default) or "copilot" (GitHub Copilot CLI via SDK)'),
     }, async (args) => {
-        const { workDir, name, initialMessage } = args;
+        const { workDir, name, initialMessage, agent } = args;
         // Validate name to prevent search attribute query injection
         if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
             return {
@@ -45,17 +82,40 @@ function registerRecruitTool(server, client, config, getPlayerId) {
             for await (const wf of client.workflow.list({ query: listQuery })) {
                 existingIds.add(wf.workflowId);
             }
-            // Spawn a new Claude Code session in a visible terminal
-            const spawnArgs = [
-                '--dangerously-skip-permissions',
-                '--dangerously-load-development-channels', 'server:claude-tempo',
-                '-n', name,
-            ];
-            const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, workDir, {
-                CLAUDE_TEMPO_ENSEMBLE: config.ensemble,
-                CLAUDE_TEMPO_CONDUCTOR: '',
-            });
-            log(`Spawned claude process (pid ${pid}) in ${workDir} as "${name}"`);
+            // 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,
+                    },
+                });
+                child.unref();
+                log(`Spawned copilot-bridge (pid ${child.pid}) in ${workDir} as "${name}"`);
+            }
+            else {
+                const spawnArgs = [
+                    '--dangerously-skip-permissions',
+                    '--dangerously-load-development-channels', 'server:claude-tempo',
+                    '-n', name,
+                ];
+                const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, workDir, {
+                    CLAUDE_TEMPO_ENSEMBLE: config.ensemble,
+                    CLAUDE_TEMPO_CONDUCTOR: '',
+                });
+                log(`Spawned claude process (pid ${pid}) in ${workDir} as "${name}"`);
+            }
             // Poll for the new workflow to appear (up to ~15s)
             let newWorkflowId = null;
             for (let attempt = 0; attempt < 30; attempt++) {
@@ -77,16 +137,26 @@ function registerRecruitTool(server, client, config, getPlayerId) {
                         }],
                 };
             }
-            // Send it a message instructing it to set its name
             const newHandle = client.workflow.getHandle(newWorkflowId);
-            const nameInstruction = `You have been recruited as "${name}". Call set_name("${name}") immediately.`;
-            const fullMessage = initialMessage
-                ? `${nameInstruction}\n\nThen: ${initialMessage}`
-                : nameInstruction;
-            await newHandle.signal('receiveMessage', {
-                from: getPlayerId(),
-                text: fullMessage,
-            });
+            // For copilot agent, the bridge handles set_name automatically.
+            // For claude agent, send a message instructing it to set its name.
+            if (agent === 'claude') {
+                const nameInstruction = `You have been recruited as "${name}". Call set_name("${name}") immediately.`;
+                const fullMessage = initialMessage
+                    ? `${nameInstruction}\n\nThen: ${initialMessage}`
+                    : nameInstruction;
+                await newHandle.signal('receiveMessage', {
+                    from: getPlayerId(),
+                    text: fullMessage,
+                });
+            }
+            else if (initialMessage) {
+                // For copilot, just send the initial task (name is set by the bridge)
+                await newHandle.signal('receiveMessage', {
+                    from: getPlayerId(),
+                    text: initialMessage,
+                });
+            }
             return {
                 content: [{
                         type: 'text',

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "claude-tempo",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "MCP server for multi-session Claude Code coordination via Temporal",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vinceblank/claude-tempo.git"
+  },
   "type": "commonjs",
   "main": "dist/server.js",
   "exports": {
@@ -30,8 +34,12 @@
   "scripts": {
     "build": "tsc && node -e \"const{bundleWorkflowCode}=require('@temporalio/worker');const path=require('path');const fs=require('fs');bundleWorkflowCode({workflowsPath:path.resolve('dist/workflows/session.js')}).then(b=>{fs.writeFileSync('workflow-bundle.js',b.code);console.log('Workflow bundle created')})\"",
     "dev": "ts-node src/server.ts",
+    "copilot-bridge": "ts-node src/copilot-bridge.ts",
     "test": "echo \"No tests yet\" && exit 0"
   },
+  "optionalDependencies": {
+    "@github/copilot-sdk": "^0.2.0"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.28.0",
     "@temporalio/activity": "~1.11.7",
@@ -59,6 +67,9 @@
     "CLAUDE.md",
     "README.md"
   ],
+  "engines": {
+    "node": ">=18"
+  },
   "license": "MIT",
   "trustedDependencies": [
     "@swc/core",