claude-tempo 0.16.2 → 0.16.3

package/dist/cli/commands.js

@@ -289,9 +289,12 @@ async function status(opts) {
             const agent = s.agentType === 'copilot' ? out.dim(' [copilot]') : '';
             const statusLabel = s.status === 'stale' ? out.yellow(' (stale)')
                 : s.status === 'pending' ? out.dim(' (pending)')
-                    : '';
+                    : s.status === 'blocked' ? out.yellow(' (blocked)')
+                        : '';
+            // Show PID info for copilot bridge sessions
+            const pidInfo = s.agentType === 'copilot' ? getBridgePidInfo(s.name) : '';
             const name = out.bold(s.name);
-            out.log(`  ${name}${role}${statusLabel}${agent}`);
+            out.log(`  ${name}${role}${statusLabel}${agent}${pidInfo}`);
             if (s.part)
                 out.log(`    ${out.dim(s.part)}`);
             const details = [s.workDir, s.branch, s.host].filter(Boolean).join('  ');
@@ -1129,6 +1132,31 @@ async function stopByName(client, name, config, ensemble) {
         process.exit(1);
     }
 }
+/**
+ * Read PID info for a copilot bridge session from its PID file.
+ * Returns a formatted string like " (pid 12345)" or "" if no PID file found.
+ */
+function getBridgePidInfo(name) {
+    const pidPath = (0, path_1.join)(process.cwd(), 'logs', `${name}.pid`);
+    if (!(0, fs_1.existsSync)(pidPath))
+        return '';
+    try {
+        const pid = parseInt((0, fs_1.readFileSync)(pidPath, 'utf8').trim(), 10);
+        if (isNaN(pid))
+            return '';
+        // Check if process is still alive
+        try {
+            process.kill(pid, 0); // signal 0 = existence check, doesn't kill
+            return out.dim(` (pid ${pid})`);
+        }
+        catch {
+            return out.dim(` (pid ${pid}, dead)`);
+        }
+    }
+    catch {
+        return '';
+    }
+}
 /**
  * Kill a bridge process by reading its PID file from logs/.
  * Cleans up the PID file after.

package/dist/copilot-bridge.js

@@ -84,6 +84,8 @@ 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;
 /** 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;
@@ -252,6 +254,9 @@ async function main() {
     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.
@@ -277,6 +282,11 @@ async function main() {
         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);
     }
     log(`Workflow ready: ${expectedWorkflowId}`);
@@ -288,6 +298,15 @@ async function main() {
         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;
@@ -295,6 +314,36 @@ async function main() {
     let pollCount = 0;
     let consecutiveFailures = 0;
     let sessionRecreations = 0;
+    // 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() {
         sessionRecreations++;
@@ -326,6 +375,24 @@ async function main() {
             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);
+                }
+            }
+            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);
+            }
+        }
         try {
             const messages = await handle.query('pendingMessages');
             if (messages.length === 0)
@@ -365,49 +432,18 @@ async function main() {
                 const recovered = await recreateSession();
                 if (!recovered) {
                     log('ERROR: Session recovery failed. Shutting down bridge.');
-                    polling = false;
-                    clearInterval(interval);
+                    await cleanup(true);
                     process.exit(2);
                 }
             }
         }
     };
-    const interval = setInterval(poll, POLL_INTERVAL_MS);
+    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
+    // Graceful shutdown on SIGINT/SIGTERM — signal the workflow before exiting
     const shutdown = async () => {
-        log('Shutting down...');
-        polling = false;
-        clearInterval(interval);
-        try {
-            await handle.signal('updateMetadata', { status: 'terminated', terminatedBy: 'system' });
-        }
-        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();
+        log('Shutting down (signal received)...');
+        await cleanup(true);
         process.exit(0);
     };
     process.on('SIGINT', shutdown);

package/package.json

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