agent-tempo 1.0.1

package/dist/copilot-bridge.js

@@ -0,0 +1,565 @@
+"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)
+ *   COPILOT_BRIDGE_SESSION_ID — deterministic session ID for resumable sessions (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");
+const connection_1 = require("./connection");
+// 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;
+/** Check workflow status every N polls (~30s at 2s interval). */
+const WORKFLOW_STATUS_CHECK_INTERVAL = 15;
+/** Proactively recreate the Copilot session after this idle period (ms). Default 60 min. */
+const SESSION_MAX_IDLE_MS = 60 * 60 * 1000;
+/** 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[config_1.ENV.BRIDGE_NAME];
+    const model = process.env[config_1.ENV.BRIDGE_MODEL];
+    const copilotSessionId = process.env[config_1.ENV.BRIDGE_SESSION_ID] || `tempo-${config.ensemble}-${playerName || 'unknown'}-${Date.now()}-${process.pid}`;
+    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 (0, connection_1.createTemporalConnection)(config);
+    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[config_1.ENV.CONDUCTOR] === 'true';
+    const requestedName = process.env[config_1.ENV.PLAYER_NAME] || playerName || '';
+    const playerIdForWorkflow = isConductor
+        ? 'conductor'
+        : (requestedName && requestedName !== 'conductor' ? requestedName : '') || `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(),
+        [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]: isConductor ? 'true' : '',
+        [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
+        ...(config.temporalApiKey ? { [config_1.ENV.TEMPORAL_API_KEY]: config.temporalApiKey } : {}),
+        ...(config.temporalTlsCertPath ? { [config_1.ENV.TEMPORAL_TLS_CERT_PATH]: config.temporalTlsCertPath } : {}),
+        ...(config.temporalTlsKeyPath ? { [config_1.ENV.TEMPORAL_TLS_KEY_PATH]: config.temporalTlsKeyPath } : {}),
+    };
+    // 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 = {
+        sessionId: copilotSessionId,
+        // 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 coordinated via Temporal. ` +
+                `You have MCP tools available — ALWAYS use these tools directly, NEVER try to run them as shell commands:\n` +
+                `- set_name: Set your player name (call this FIRST if instructed)\n` +
+                `- ensemble: List active sessions\n` +
+                `- cue: Send a message to another player\n` +
+                `- set_part: Update your status/description\n` +
+                `- listen: Check for pending messages\n` +
+                `- recruit: Spawn a new player session\n` +
+                `- report: Report to the conductor\n` +
+                `- stop: Stop a session\n\n` +
+                `When you receive a message from another session, treat it like a coworker asking for help — respond promptly using your MCP tools.`,
+        },
+        excludedTools: ['write_powershell', 'read_powershell', 'list_powershell'],
+        ...(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.info') {
+                log(`[session.info] ${JSON.stringify(event.data)}`);
+            }
+            else if (event.type === 'session.warning') {
+                log(`[session.warning] ${JSON.stringify(event.data)}`);
+            }
+            else if (event.type === 'session.mcp_servers_loaded') {
+                log(`[mcp_servers_loaded] ${JSON.stringify(event.data)}`);
+            }
+            else if (event.type === 'session.mcp_server_status_changed') {
+                log(`[mcp_server_status_changed] ${JSON.stringify(event.data)}`);
+            }
+            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));
+        // Dump available tools for diagnostics
+        try {
+            const toolList = await session.rpc.tools.list({});
+            log('Available tools:', JSON.stringify(toolList.tools?.map((t) => t.name || t.namespacedName)));
+        }
+        catch (toolErr) {
+            log('Failed to list tools:', toolErr?.message);
+        }
+    }
+    catch (err) {
+        log(`Initial prompt error after ${Date.now()}ms:`, err?.message, err?.stack?.substring(0, 300));
+    }
+    // PID file paths — computed early so early-exit paths can clean up
+    const pidDir = path.join(workDir, 'logs');
+    const pidFile = path.join(pidDir, `${playerName || playerIdForWorkflow}.pid`);
+    // 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...`);
+    let handle = client.workflow.getHandle(expectedWorkflowId);
+    let workflowReady = false;
+    let pinnedRunId;
+    for (let attempt = 0; attempt < 30; attempt++) {
+        try {
+            const desc = await handle.describe();
+            if (desc.status.name === 'RUNNING') {
+                workflowReady = true;
+                pinnedRunId = desc.runId;
+                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();
+        // Clean up PID file to avoid stale entries in `claude-tempo status`
+        try {
+            fs.unlinkSync(pidFile);
+        }
+        catch { /* may not exist yet */ }
+        process.exit(1);
+    }
+    // Pin all subsequent interactions to the runId we observed — prevents the
+    // zombie-resurrection hazard from #102. If this run completes (e.g. destroy),
+    // a later USE_EXISTING start would spawn a new run with the same workflow ID;
+    // an unpinned handle would silently attach to the new run, but a pinned handle
+    // returns WorkflowNotFound and lets the bridge exit cleanly.
+    handle = client.workflow.getHandle(expectedWorkflowId, pinnedRunId);
+    log(`Workflow ready: ${expectedWorkflowId} (pinned runId ${pinnedRunId})`);
+    // Store sessionId in workflow metadata for future encore/resume
+    try {
+        await handle.signal('updateMetadata', { sessionId: copilotSessionId });
+    }
+    catch { /* workflow may not be ready yet */ }
+    // 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`);
+    }
+    const MAESTRO_ACK = '\n\n[IMPORTANT: This message is from a human (Maestro). Immediately cue the sender back with a brief acknowledgment and your planned next step before doing the work.]';
+    // Write PID file so callers can find/kill orphaned bridge processes
+    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}`);
+    }
+    // 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;
+    let proactiveRecreations = 0;
+    let lastActivityTime = Date.now();
+    // interval declared here, assigned after poll is defined
+    let interval;
+    // Shared cleanup — disconnects session, removes PID file, stops client.
+    // `signalTermination` controls whether we also signal the workflow to terminate
+    // (skip if the workflow is already gone).
+    let shuttingDown = false;
+    const cleanup = async (signalTermination) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        polling = false;
+        clearInterval(interval);
+        if (signalTermination) {
+            try {
+                await handle.signal('updateMetadata', { status: 'terminated', terminatedBy: 'system' });
+            }
+            catch {
+                // workflow may already be gone
+            }
+        }
+        try {
+            await session.disconnect();
+        }
+        catch { /* already disconnected */ }
+        try {
+            fs.unlinkSync(pidFile);
+        }
+        catch { /* already gone */ }
+        await copilotClient.stop();
+    };
+    /** Attempt to recreate the Copilot session after repeated failures. */
+    async function recreateSession() {
+        // Fixes #102: before recreating, check whether the pinned-runId workflow has
+        // been destroyed. If so, the user explicitly stopped this session — do NOT
+        // bring it back as a zombie. This also covers WorkflowNotFound (the pinned
+        // run has completed/terminated) since the query throws cleanly.
+        try {
+            const isDestroyed = await handle.query('isDestroyed');
+            if (isDestroyed) {
+                log('Workflow is destroyed — not reconnecting (session was intentionally stopped)');
+                return false;
+            }
+        }
+        catch (err) {
+            const errName = err?.name || '';
+            const errMsg = err?.message || '';
+            if (errName.includes('WorkflowNotFound') || errMsg.includes('NOT_FOUND')) {
+                log('Workflow not found (likely terminated) — not reconnecting');
+                return false;
+            }
+            // Query failed for another reason — log and continue with recreation.
+            log(`isDestroyed query failed (${errMsg}), continuing with recreation`);
+        }
+        sessionRecreations++;
+        if (sessionRecreations > MAX_SESSION_RECREATIONS) {
+            log(`ERROR: Exceeded max session recreations (${MAX_SESSION_RECREATIONS}). Giving up.`);
+            return false;
+        }
+        log(`Attempting session recovery (${sessionRecreations}/${MAX_SESSION_RECREATIONS})...`);
+        try {
+            await session.disconnect().catch(() => { });
+            // Try resumeSession first to preserve conversation history
+            try {
+                const { sessionId: _discard, ...resumeConfig } = sessionConfig;
+                session = await copilotClient.resumeSession(copilotSessionId, resumeConfig);
+                attachEventLogger(session);
+                sessionAlive = true;
+                consecutiveFailures = 0;
+                lastActivityTime = Date.now();
+                log(`Session resumed successfully: ${session.sessionId}`);
+                return true;
+            }
+            catch (resumeErr) {
+                log(`resumeSession failed (${resumeErr?.message}), falling back to createSession`);
+                session = await createSessionWithTimeout(copilotClient, sessionConfig);
+                attachEventLogger(session);
+                sessionAlive = true;
+                consecutiveFailures = 0;
+                lastActivityTime = Date.now();
+                log(`Session recreated (fresh) successfully: ${session.sessionId}`);
+                return true;
+            }
+        }
+        catch (err) {
+            log(`Session recovery 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`);
+        }
+        // Periodic workflow status check — detect external termination/completion
+        if (pollCount % WORKFLOW_STATUS_CHECK_INTERVAL === 0) {
+            try {
+                const desc = await handle.describe();
+                const wfStatus = desc.status.name;
+                if (wfStatus !== 'RUNNING') {
+                    log(`Workflow status is ${wfStatus} — exiting cleanly`);
+                    await cleanup(false); // workflow already gone, don't signal
+                    process.exit(0);
+                }
+                // Also check the in-workflow destroy flag — the workflow may still be RUNNING
+                // (draining) but has been destroyed. Exit cleanly without attempting signals
+                // that would be rejected.
+                try {
+                    const isDestroyed = await handle.query('isDestroyed');
+                    if (isDestroyed) {
+                        log('Workflow destroyed — exiting cleanly');
+                        await cleanup(false);
+                        process.exit(0);
+                    }
+                }
+                catch { /* isDestroyed query unavailable pre-upgrade — safe to ignore */ }
+            }
+            catch (err) {
+                // If we can't describe (e.g., workflow not found), it was likely terminated
+                log(`Workflow describe failed: ${err?.message} — treating as terminated`);
+                await cleanup(false);
+                process.exit(0);
+            }
+        }
+        // Proactive stale-session detection — recreate before the SDK server GCs the session
+        const idleMs = Date.now() - lastActivityTime;
+        if (idleMs > SESSION_MAX_IDLE_MS && !processing) {
+            try {
+                processing = true; // guard against overlapping polls during async recreation
+                log(`Session idle for ${(idleMs / 1000 / 60).toFixed(0)}min — proactively recreating`);
+                proactiveRecreations++;
+                const recovered = await recreateSession();
+                if (recovered) {
+                    // Proactive recreation is lifecycle management, not failure recovery — restore failure budget
+                    // but don't reset to 0: use proactiveRecreations to cap total lifecycle recreations
+                    sessionRecreations = Math.max(0, sessionRecreations - 1);
+                }
+                else {
+                    // Session is almost certainly dead server-side — force immediate recovery on next message
+                    // Use MAX - 1 so the next poll error increments to the threshold and triggers recovery
+                    consecutiveFailures = MAX_CONSECUTIVE_FAILURES - 1;
+                    sessionAlive = false;
+                    log('ERROR: Proactive session recreation failed — will force recovery on next message');
+                }
+            }
+            finally {
+                processing = false;
+            }
+        }
+        try {
+            const messages = await handle.query('pendingMessages');
+            if (messages.length === 0)
+                return;
+            processing = true;
+            const ids = messages.map((m) => m.id);
+            // Format messages into a single prompt, appending ack instruction for Maestro messages
+            const prompt = messages
+                .map((m) => {
+                const line = `[Message from ${m.from}]: ${m.text}`;
+                return m.isMaestro ? line + MAESTRO_ACK : line;
+            })
+                .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');
+            }
+            // Fixes #99: mark these messages as in-flight before the blocking LLM call so
+            // the workflow's stale detection doesn't misclassify a long tool call as dead.
+            // Fire-and-logged — don't block sendAndWait on the update roundtrip.
+            const processingMarkerId = ids[0]; // representative for the batch
+            handle.executeUpdate('processingStart', { args: [{ messageId: processingMarkerId }] })
+                .catch((err) => log(`processingStart update failed (non-fatal): ${err?.message}`));
+            const t0 = Date.now();
+            let result;
+            try {
+                result = await session.sendAndWait({ prompt }, 300_000); // 5 min timeout
+            }
+            finally {
+                // Always release the in-flight marker — a thrown error from sendAndWait
+                // must not leave the workflow pinned as "processing".
+                handle.executeUpdate('processingEnd', { args: [{ messageId: processingMarkerId }] })
+                    .catch((err) => log(`processingEnd update failed (non-fatal): ${err?.message}`));
+            }
+            const elapsed = Date.now() - t0;
+            log(`sendAndWait completed in ${elapsed}ms`);
+            log(`Response: ${JSON.stringify(result)?.substring(0, 500)}`);
+            // Mark delivered only after successful send — failed messages stay in pending queue for retry
+            await handle.signal('markDelivered', ids);
+            // Success — reset failure tracking
+            consecutiveFailures = 0;
+            lastActivityTime = Date.now();
+            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.');
+                    await cleanup(true);
+                    process.exit(2);
+                }
+            }
+        }
+    };
+    interval = setInterval(poll, POLL_INTERVAL_MS);
+    log('Message poller started. Bridge is running.');
+    // Graceful shutdown on SIGINT/SIGTERM — signal the workflow before exiting
+    const shutdown = async () => {
+        log('Shutting down (signal received)...');
+        await cleanup(true);
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((err) => {
+    log('Fatal error:', err);
+    process.exit(1);
+});

package/dist/daemon-adapter-versions.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Test seam — production code passes nothing. Tests inject stubs to
+ * avoid spawning real processes / reading real package.json files.
+ */
+export interface ProbeAdapterVersionsDeps {
+    /**
+     * Run a CLI and return its stdout. Default: real `execFile` with a
+     * timeout. Tests pass a stub that returns canned output.
+     */
+    runCommand?: (cmd: string, args: string[]) => Promise<string>;
+    /**
+     * Resolve the Copilot SDK's package version. Default: dynamic
+     * `require('@github/copilot-sdk/package.json').version`. Tests stub
+     * to control "installed vs. not installed" + version values.
+     * Returns `undefined` when the dep isn't installed.
+     */
+    resolveCopilotSdkVersion?: () => Promise<string | undefined>;
+    /** Optional log sink. Tests pass a no-op to silence output. */
+    log?: (...args: unknown[]) => void;
+}
+/**
+ * Probe the upstream tool versions for every adapter this daemon ships.
+ *
+ * @returns A map keyed by adapter name. Adapters whose probe failed or
+ * whose output couldn't be parsed are omitted entirely. The map may be
+ * empty in environments without any of the supported adapters available.
+ */
+export declare function probeAdapterVersions(deps?: ProbeAdapterVersionsDeps): Promise<Record<string, string>>;
+/**
+ * Synchronous companion to {@link defaultResolveCopilotSdkVersion}.
+ * Returns the Copilot SDK's `package.json#version` if the optional
+ * dependency is installed, or `undefined` when the require fails.
+ *
+ * Exported for #532 PR-2 — `src/daemon.ts` `computeHostProfile()` is
+ * synchronous (matches the existing `claude-code-headless` block at
+ * `daemon.ts:278-288`, which uses synchronous probes from
+ * `src/adapters/claude-code-headless/pre-flight.ts`). Awaiting an
+ * async helper from a sync function isn't possible without cascading
+ * the change to all `computeHostProfile` call sites; instead, this
+ * sync helper is the single require-source-of-truth, and the async
+ * `defaultResolveCopilotSdkVersion` (kept for the
+ * `ProbeAdapterVersionsDeps['resolveCopilotSdkVersion']` contract)
+ * delegates to it.
+ *
+ * Tests stub this directly via the `resolveCopilotSdkVersionSync` dep
+ * on `computeHostProfile` (see `test/daemon-boot.test.ts`).
+ *
+ * Never throws — a `try/catch` swallows MODULE_NOT_FOUND and any
+ * other failure mode to `undefined`. A throw here would crash the
+ * daemon-boot critical path.
+ */
+export declare function resolveCopilotSdkVersionSync(): string | undefined;