claude-tempo 0.22.0-beta.2 → 0.22.0

package/dist/activities/outbox.d.ts

@@ -48,8 +48,8 @@ export interface SpawnProcessInput {
     nativeResolvable?: boolean;
     /** When true, use --resume instead of -n (reconnect to existing session). */
     resume?: boolean;
-    /** Claude Code session UUID for --session-id (new sessions) or --resume (encore). */
-    claudeSessionId?: string;
+    /** Session UUID — used for Copilot SDK sessionId and Claude Code --resume/--session-id. */
+    sessionId?: string;
     /** Tool restrictions from the agent definition frontmatter. */
     allowedTools?: string[];
     /** Custom claude binary path (from config.claudeBin). */
@@ -70,8 +70,8 @@ export interface EncoreResult {
     agentDefinitionPath?: string;
     nativeResolvable?: boolean;
     allowedTools?: string[];
-    /** Claude Code session UUID for deterministic --resume. */
-    claudeSessionId?: string;
+    /** Session UUID — used for Copilot SDK sessionId and Claude Code --resume/--session-id. */
+    sessionId?: string;
     temporalAddress: string;
     temporalNamespace: string;
     /** Custom claude binary path (from config.claudeBin). */
@@ -82,8 +82,8 @@ export interface OutboxActivityResult {
     error?: string;
 }
 export interface RecruitResult extends OutboxActivityResult {
-    /** Claude Code session UUID assigned at recruit time. */
-    claudeSessionId?: string;
+    /** Session UUID assigned at recruit time. */
+    sessionId?: string;
 }
 export interface OutboxActivities {
     deliverCue(input: DeliverCueInput): Promise<OutboxActivityResult>;

package/dist/activities/outbox.js

@@ -107,8 +107,8 @@ function createOutboxActivities(client, config) {
                     ? (0, config_1.conductorWorkflowId)(ensemble)
                     : (0, config_1.sessionWorkflowId)(ensemble, targetName);
                 const { gitRoot, gitBranch } = (0, git_info_1.getGitInfo)(workDir);
-                // Generate a UUID for the Claude Code session — used for deterministic --resume on encore
-                const claudeSessionId = crypto.randomUUID();
+                // Generate a UUID for the session — used for deterministic --resume on encore
+                const sessionId = crypto.randomUUID();
                 const sessionInput = {
                     metadata: {
                         playerId: targetName,
@@ -120,7 +120,7 @@ function createOutboxActivities(client, config) {
                         isConductor,
                         agentType: agent,
                         status: 'pending',
-                        claudeSessionId,
+                        sessionId,
                         ...(agentDefinition ? { playerType: agentDefinition } : {}),
                         ...(agentDefinitionDescription ? { playerTypeDescription: agentDefinitionDescription } : {}),
                         recruitedBy: fromPlayerId,
@@ -149,15 +149,15 @@ function createOutboxActivities(client, config) {
                         ClaudeTempoPlayerId: [targetName],
                     },
                 });
-                log(`Pre-created workflow ${workflowId} for recruit "${targetName}" (sessionId=${claudeSessionId})`);
-                return { success: true, claudeSessionId };
+                log(`Pre-created workflow ${workflowId} for recruit "${targetName}" (sessionId=${sessionId})`);
+                return { success: true, sessionId };
             }
             catch (err) {
                 throw activity_1.ApplicationFailure.nonRetryable(`Failed to start recruited session "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
             }
         },
         async spawnProcess(input) {
-            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume, claudeSessionId, allowedTools, claudeBin } = input;
+            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume, sessionId, allowedTools, claudeBin } = input;
             // Read secrets from the worker's config closure — never from workflow state
             const { temporalApiKey, temporalTlsCertPath, temporalTlsKeyPath } = config;
             try {
@@ -175,6 +175,7 @@ function createOutboxActivities(client, config) {
                         temporalTlsKeyPath,
                         isConductor,
                         workDir,
+                        sessionId,
                     });
                     log(`Spawned copilot-bridge (pid ${pid}) in ${workDir} as "${targetName}"`);
                 }
@@ -194,8 +195,8 @@ function createOutboxActivities(client, config) {
                     // For encore: use UUID for deterministic --resume (no interactive picker).
                     // For new sessions: use --session-id to track the UUID for future encores.
                     const nameArgs = resume
-                        ? ['--resume', claudeSessionId || targetName]
-                        : ['-n', targetName, ...(claudeSessionId ? ['--session-id', claudeSessionId] : [])];
+                        ? ['--resume', sessionId || targetName]
+                        : ['-n', targetName, ...(sessionId ? ['--session-id', sessionId] : [])];
                     // Build --allowedTools flag from agent definition frontmatter
                     const allowedToolsFlags = allowedTools && allowedTools.length > 0
                         ? ['--allowedTools', ...allowedTools]
@@ -296,7 +297,7 @@ function createOutboxActivities(client, config) {
                     agentDefinitionPath,
                     nativeResolvable,
                     allowedTools,
-                    claudeSessionId: metadata.claudeSessionId || undefined,
+                    sessionId: metadata.sessionId || undefined,
                     temporalAddress: config.temporalAddress,
                     temporalNamespace: config.temporalNamespace,
                     claudeBin: config.claudeBin,

package/dist/cli/commands.js

@@ -438,10 +438,25 @@ const SEARCH_ATTRIBUTES = [
     { name: 'ClaudeTempoStatus', type: 'Keyword' },
     { name: 'ClaudeTempoPlayerType', type: 'Keyword' },
 ];
-function isTemporalReachable(config) {
-    return (0, connection_1.createTemporalConnection)(config)
-        .then(conn => { conn.close(); return true; })
-        .catch(() => false);
+async function isTemporalReachable(config) {
+    try {
+        const conn = await (0, connection_1.createTemporalConnection)(config);
+        try {
+            // Verify namespace is ready — a gRPC connection alone doesn't guarantee the server can serve requests
+            const client = new client_1.Client({ connection: conn, namespace: config.temporalNamespace || 'default' });
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            for await (const _ of client.workflow.list({ query: 'WorkflowId = "__readiness_probe__"' })) {
+                break;
+            }
+        }
+        finally {
+            await conn.close();
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 function temporalCliExists() {
     const cmd = process.platform === 'win32' ? 'where' : 'which';
@@ -777,7 +792,7 @@ async function up(opts) {
             isConductor: true,
             agentType: conductorAgent,
             status: 'pending',
-            claudeSessionId: conductorSessionId,
+            sessionId: conductorSessionId,
             ...(resolvedConductorType ? { playerType: resolvedConductorType.name, playerTypeDescription: resolvedConductorType.description || '' } : {}),
         },
         autoSummary: `Conductor session`,
@@ -858,7 +873,7 @@ async function up(opts) {
             console.log();
             out.log(`Recruiting ${lineup.players.length} player${lineup.players.length !== 1 ? 's' : ''} from lineup...`);
             for (const player of lineup.players) {
-                const playerAgent = player.agent === 'copilot' ? 'copilot' : 'claude';
+                const playerAgent = player.agent === 'copilot' ? 'copilot' : (player.agent === 'claude' ? 'claude' : opts.agent);
                 const playerWorkDir = player.workDir || process.cwd();
                 const playerTypeName = player.type;
                 const resolvedPlayerType = playerTypeName ? (0, agent_types_1.resolveAgentType)(playerTypeName) : null;
@@ -877,7 +892,7 @@ async function up(opts) {
                         isConductor: false,
                         agentType: playerAgent,
                         status: 'pending',
-                        claudeSessionId: playerSessionId,
+                        sessionId: playerSessionId,
                         recruitedBy: sessionName,
                         ...(resolvedPlayerType ? { playerType: resolvedPlayerType.name, playerTypeDescription: resolvedPlayerType.description || '' } : {}),
                     },
@@ -965,8 +980,23 @@ async function up(opts) {
                 try {
                     const entry = lineupScheduleToEntry(sched);
                     const schedulerWfId = (0, config_1.schedulerWorkflowId)(opts.ensemble);
-                    const handle = client.workflow.getHandle(schedulerWfId);
-                    await handle.signal(scheduler_signals_1.addScheduleSignal, entry);
+                    // Try to signal existing scheduler; if not running, start it with this schedule as seed
+                    try {
+                        const handle = client.workflow.getHandle(schedulerWfId);
+                        await handle.describe();
+                        await handle.signal(scheduler_signals_1.addScheduleSignal, entry);
+                    }
+                    catch {
+                        await client.workflow.start('claudeSchedulerWorkflow', {
+                            workflowId: schedulerWfId,
+                            taskQueue: config.taskQueue,
+                            args: [{ ensemble: opts.ensemble, entries: [entry] }],
+                            workflowIdConflictPolicy: client_1.WorkflowIdConflictPolicy.USE_EXISTING,
+                            searchAttributes: {
+                                ClaudeTempoEnsemble: [opts.ensemble],
+                            },
+                        });
+                    }
                     out.check(sched.name, true, `→ ${sched.target}`);
                 }
                 catch (err) {

package/dist/config.d.ts

@@ -8,6 +8,7 @@ export declare const ENV: {
     readonly BRIDGE_NAME: "COPILOT_BRIDGE_NAME";
     readonly BRIDGE_MODE: "CLAUDE_TEMPO_BRIDGE_MODE";
     readonly BRIDGE_MODEL: "COPILOT_BRIDGE_MODEL";
+    readonly BRIDGE_SESSION_ID: "COPILOT_BRIDGE_SESSION_ID";
     readonly TEMPORAL_ADDRESS: "TEMPORAL_ADDRESS";
     readonly TEMPORAL_NAMESPACE: "TEMPORAL_NAMESPACE";
     readonly TEMPORAL_API_KEY: "TEMPORAL_API_KEY";

package/dist/config.js

@@ -29,6 +29,7 @@ exports.ENV = {
     BRIDGE_NAME: 'COPILOT_BRIDGE_NAME',
     BRIDGE_MODE: 'CLAUDE_TEMPO_BRIDGE_MODE',
     BRIDGE_MODEL: 'COPILOT_BRIDGE_MODEL',
+    BRIDGE_SESSION_ID: 'COPILOT_BRIDGE_SESSION_ID',
     TEMPORAL_ADDRESS: 'TEMPORAL_ADDRESS',
     TEMPORAL_NAMESPACE: 'TEMPORAL_NAMESPACE',
     TEMPORAL_API_KEY: 'TEMPORAL_API_KEY',

package/dist/copilot-bridge.d.ts

@@ -16,6 +16,7 @@
  *   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)
  */
 export {};

package/dist/copilot-bridge.js

@@ -17,6 +17,7 @@
  *   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) {
@@ -86,6 +87,8 @@ 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;
@@ -106,6 +109,7 @@ 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)
@@ -156,6 +160,7 @@ async function main() {
         },
     });
     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
@@ -290,6 +295,11 @@ async function main() {
         process.exit(1);
     }
     log(`Workflow ready: ${expectedWorkflowId}`);
+    // 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}"...`);
@@ -314,6 +324,8 @@ async function main() {
     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.
@@ -351,18 +363,33 @@ async function main() {
             log(`ERROR: Exceeded max session recreations (${MAX_SESSION_RECREATIONS}). Giving up.`);
             return false;
         }
-        log(`Attempting session recreation (${sessionRecreations}/${MAX_SESSION_RECREATIONS})...`);
+        log(`Attempting session recovery (${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;
+            // 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 recreation failed: ${err?.message}`);
+            log(`Session recovery failed: ${err?.message}`);
             return false;
         }
     }
@@ -393,13 +420,37 @@ async function main() {
                 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);
-            await handle.signal('markDelivered', ids);
             // Format messages into a single prompt, appending ack instruction for Maestro messages
             const prompt = messages
                 .map((m) => {
@@ -417,8 +468,11 @@ async function main() {
             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;
         }

package/dist/spawn.d.ts

@@ -64,6 +64,8 @@ export interface CopilotBridgeOpts {
     workDir: string;
     /** Directory for log and PID files. Defaults to `logs/` inside workDir. */
     logDir?: string;
+    /** Copilot SDK session ID for resumable sessions. */
+    sessionId?: string;
 }
 export interface CopilotBridgeResult {
     pid: number | undefined;

package/dist/spawn.js

@@ -427,6 +427,7 @@ function spawnCopilotBridge(opts) {
                 ...(opts.temporalApiKey ? { [config_1.ENV.TEMPORAL_API_KEY]: opts.temporalApiKey } : {}),
                 ...(opts.temporalTlsCertPath ? { [config_1.ENV.TEMPORAL_TLS_CERT_PATH]: opts.temporalTlsCertPath } : {}),
                 ...(opts.temporalTlsKeyPath ? { [config_1.ENV.TEMPORAL_TLS_KEY_PATH]: opts.temporalTlsKeyPath } : {}),
+                ...(opts.sessionId ? { [config_1.ENV.BRIDGE_SESSION_ID]: opts.sessionId } : {}),
             },
         });
         child.unref();

package/dist/tui/client.js

@@ -29,7 +29,7 @@ function createTempoClient(client) {
             try {
                 const h = handle(globalMaestroId);
                 const byEnsemble = await h.query('maestroPlayersByEnsemble');
-                return Object.entries(byEnsemble).map(([name, players]) => {
+                const results = Object.entries(byEnsemble).map(([name, players]) => {
                     const conductor = players.find(p => p.isConductor);
                     return {
                         name,
@@ -38,6 +38,10 @@ function createTempoClient(client) {
                         conductorStatus: conductor?.status,
                     };
                 });
+                // Only trust Maestro if it has discovered ensembles; fall through to
+                // Strategy 2 when empty — the Maestro may not have refreshed yet.
+                if (results.length > 0)
+                    return results;
             }
             catch {
                 // Global Maestro not available — fall through

package/dist/types.d.ts

@@ -18,8 +18,8 @@ export interface SessionMetadata {
     recruitedBy?: string;
     /** Worktree path if this session was spawned in an isolated worktree. */
     worktreePath?: string;
-    /** Claude Code session UUID — used for deterministic --resume on encore. */
-    claudeSessionId?: string;
+    /** Session UUID — used for Copilot SDK sessionId and Claude Code --resume/--session-id. */
+    sessionId?: string;
 }
 export interface AgentTypeInfo {
     name: string;

package/dist/workflows/session.js

@@ -132,8 +132,9 @@ async function claudeSessionWorkflow(input) {
             input.metadata.playerTypeDescription = update.playerTypeDescription;
         if (update.worktreePath != null)
             input.metadata.worktreePath = update.worktreePath;
-        if (update.claudeSessionId != null)
-            input.metadata.claudeSessionId = update.claudeSessionId;
+        if (update.sessionId != null || update.claudeSessionId != null) {
+            input.metadata.sessionId = update.sessionId ?? update.claudeSessionId;
+        }
         if (update.status != null) {
             input.metadata.status = update.status;
             // Re-enable stale detection only when explicitly requested (server.ts sets this)
@@ -468,7 +469,7 @@ async function claudeSessionWorkflow(input) {
                             agentDefinition: entry.agentDefinition,
                             agentDefinitionPath: entry.agentDefinitionPath,
                             nativeResolvable: entry.nativeResolvable,
-                            claudeSessionId: recruitResult.claudeSessionId,
+                            sessionId: recruitResult.sessionId,
                             allowedTools: entry.allowedTools,
                             claudeBin: entry.claudeBin,
                         });
@@ -496,7 +497,7 @@ async function claudeSessionWorkflow(input) {
                                 agentDefinitionPath: encoreResult.agentDefinitionPath,
                                 nativeResolvable: encoreResult.nativeResolvable,
                                 allowedTools: encoreResult.allowedTools,
-                                claudeSessionId: encoreResult.claudeSessionId,
+                                sessionId: encoreResult.sessionId,
                                 resume: true,
                                 claudeBin: entry.claudeBin || encoreResult.claudeBin,
                             });

package/dist/workflows/signals.d.ts

@@ -23,7 +23,7 @@ export declare const updateMetadataSignal: import("@temporalio/workflow").Signal
     playerType?: string;
     playerTypeDescription?: string;
     worktreePath?: string;
-    claudeSessionId?: string;
+    sessionId?: string;
 }], string>;
 export declare const getPartQuery: import("@temporalio/workflow").QueryDefinition<string, [], string>;
 export declare const getMetadataQuery: import("@temporalio/workflow").QueryDefinition<SessionMetadata, [], string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-tempo",
-  "version": "0.22.0-beta.2",
+  "version": "0.22.0",
   "description": "MCP server for multi-session Claude Code coordination via Temporal",
   "keywords": [
     "mcp",