claude-tempo 0.22.0-beta.1 → 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/ensemble/saver.d.ts

@@ -15,3 +15,10 @@ export declare function listLineups(): Array<{
  * Read a saved lineup by name from ~/.claude-tempo/ensembles/.
  */
 export declare function readSavedLineup(name: string): string | null;
+/**
+ * List all available lineups — saved (~/.claude-tempo/ensembles/) + shipped (examples/ensembles/).
+ */
+export declare function listAllLineups(): Array<{
+    name: string;
+    source: 'saved' | 'shipped';
+}>;

package/dist/ensemble/saver.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveLineup = saveLineup;
 exports.listLineups = listLineups;
 exports.readSavedLineup = readSavedLineup;
+exports.listAllLineups = listAllLineups;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const yaml_1 = require("yaml");
@@ -129,6 +130,40 @@ function readSavedLineup(name) {
     }
     return null;
 }
+/**
+ * Find the package root by walking up from a directory.
+ */
+function findPackageRoot(dir) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'package.json')))
+        return dir;
+    const parent = (0, path_1.resolve)(dir, '..');
+    return parent === dir ? dir : findPackageRoot(parent);
+}
+/**
+ * List all available lineups — saved (~/.claude-tempo/ensembles/) + shipped (examples/ensembles/).
+ */
+function listAllLineups() {
+    const results = [];
+    // Saved lineups
+    for (const l of listLineups()) {
+        results.push({ name: l.name, source: 'saved' });
+    }
+    // Shipped examples
+    const pkgRoot = findPackageRoot((0, path_1.resolve)(__dirname));
+    const shippedDir = (0, path_1.join)(pkgRoot, 'examples', 'ensembles');
+    if ((0, fs_1.existsSync)(shippedDir)) {
+        for (const f of (0, fs_1.readdirSync)(shippedDir)) {
+            if (f.endsWith('.yaml') || f.endsWith('.yml')) {
+                const name = f.replace(/\.ya?ml$/, '');
+                // Skip if already in saved (saved takes precedence)
+                if (!results.some(r => r.name === name)) {
+                    results.push({ name, source: 'shipped' });
+                }
+            }
+        }
+    }
+    return results;
+}
 function formatDurationMs(ms) {
     if (ms >= 86_400_000 && ms % 86_400_000 === 0)
         return `${ms / 86_400_000}d`;

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/App.js

@@ -222,6 +222,17 @@ function App({ api, ensemble, defaultAgent }) {
                     return;
                 }
             }
+            // Gates/stages — Enter shows detail for selected item
+            if ((s.overlay.type === 'gates' || s.overlay.type === 'stages') && key.return) {
+                const selected = s.overlay.items[s.overlay.selectedIndex];
+                if (selected) {
+                    const detail = selected.sublabel
+                        ? `\n  ${selected.label}\n\n  ${selected.sublabel.split('  ').join('\n  ')}`
+                        : `\n  ${selected.label}\n\n  No details available.`;
+                    dispatch({ type: 'SHOW_COMMAND_OVERLAY', title: selected.label.slice(0, 40), content: detail });
+                }
+                return;
+            }
             return; // Swallow all other input while overlay is active
         }
         // Player detail view — Escape goes back, ↑↓ scrolls messages
@@ -703,7 +714,7 @@ function App({ api, ensemble, defaultAgent }) {
                 if (atMatch) {
                     // @player message → send directly to that player
                     const [, targetPlayer, message] = atMatch;
-                    dispatch({ type: 'APPEND_SENT_MESSAGE', to: targetPlayer, text: message });
+                    dispatch({ type: 'APPEND_SENT_MESSAGE', to: targetPlayer, text: `@${targetPlayer} ${message}` });
                     api.sendAsMaestro(s.activeEnsemble, targetPlayer, message).catch(err => dispatch({
                         type: 'COMMIT_STATIC',
                         item: { id: nextStaticId(), type: 'error', content: `\u2717 Failed to deliver to @${targetPlayer}: ${err}`, timestamp: Date.now() },
@@ -838,9 +849,11 @@ function App({ api, ensemble, defaultAgent }) {
                     }));
                     dispatch({ type: 'REFRESH_ENSEMBLE_DATA', players, messages: [], history: [], schedules });
                     // Skip redundant conversation dispatches when data hasn't changed
+                    // Always dispatch on first poll (conversation === null) to exit "Loading messages..."
                     const lastChatMsg = chatResult.messages[chatResult.messages.length - 1];
                     const newLastTs = lastChatMsg?.timestamp ?? '';
-                    if (chatResult.total !== lastChatRef.current.total || newLastTs !== lastChatRef.current.lastTs) {
+                    const isFirstLoad = stateRef.current.conversation === null;
+                    if (isFirstLoad || chatResult.total !== lastChatRef.current.total || newLastTs !== lastChatRef.current.lastTs) {
                         dispatch({ type: 'SET_CONVERSATION', conversation });
                         dispatch({ type: 'SET_ENSEMBLE_CHAT', chat: chatResult });
                         lastChatRef.current = { total: chatResult.total, lastTs: newLastTs };
@@ -1000,7 +1013,7 @@ function App({ api, ensemble, defaultAgent }) {
                 ? ['up', name, '--lineup', lineup]
                 : ['up', name];
             await new Promise((resolve, reject) => {
-                execFile('claude-tempo', args, { cwd: workDir, timeout: 60000 }, (err, _stdout, stderr) => {
+                execFile('claude-tempo', args, { cwd: workDir, timeout: 60000, shell: true }, (err, _stdout, stderr) => {
                     if (err)
                         reject(new Error(stderr?.trim() || err.message || 'Unknown error'));
                     else
@@ -1337,7 +1350,7 @@ function App({ api, ensemble, defaultAgent }) {
     react_1.default.createElement(PromptArea_1.PromptArea, {
         hints: promptHints,
         onSubmit: handleSubmit,
-        disabled: state.phase === 'error' || state.phase === 'recruit' || state.phase === 'schedule-create' || !!state.confirmingStop || !!state.confirmingDisband || !!state.confirmingLineup || state.pickerVisible || state.statusOverlay || !!state.overlay,
+        disabled: (state.phase !== 'main' && state.phase !== 'chat') || !!state.confirmingStop || !!state.confirmingDisband || !!state.confirmingLineup || state.pickerVisible || state.statusOverlay || !!state.overlay,
         commandNames: commandNamesList,
         playerNames: playerNamesList,
         initialHistory: cmdHistory,

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/tui/commands.js

@@ -14,6 +14,7 @@ exports.formatHelpSummary = formatHelpSummary;
  */
 const child_process_1 = require("child_process");
 const platform_1 = require("./utils/platform");
+const saver_1 = require("../ensemble/saver");
 // ── Parser ──
 /**
  * Parse raw input into a structured command.
@@ -358,7 +359,7 @@ async function handleGates(_args, dispatch, api, ctx) {
                     type: 'gates',
                     title: 'Quality Gates',
                     items: allItems,
-                    hint: 'esc=close',
+                    hint: '\u21B5=detail  esc=close',
                 },
             });
         }
@@ -414,7 +415,7 @@ async function handleStages(_args, dispatch, api, ctx) {
                     type: 'stages',
                     title: 'Stages',
                     items: allItems,
-                    hint: 'esc=close',
+                    hint: '\u21B5=detail  esc=close',
                 },
             });
         }
@@ -523,18 +524,26 @@ async function handleSearch(args, dispatch, api, ctx) {
             ? [{ name: ctx.activeEnsemble }]
             : await api.discoverEnsembles();
         const allResults = [];
+        const seen = new Set();
         for (const ens of ensembles) {
-            const messages = await api.getMessages(ens.name, 100);
-            for (const m of messages) {
+            // Fetch from both Maestro event log (100) and ensemble chat cache (500)
+            const [messages, chatResult] = await Promise.all([
+                api.getMessages(ens.name, 100),
+                api.getEnsembleChat(ens.name, 0, 500).catch(() => ({ messages: [] })),
+            ]);
+            // Merge both sources, dedup by from+to+timestamp prefix
+            const combined = [
+                ...messages.map(m => ({ from: m.from, to: m.to, text: m.text, timestamp: m.timestamp })),
+                ...chatResult.messages.map((m) => ({ from: m.from, to: m.to, text: m.text, timestamp: m.timestamp })),
+            ];
+            for (const m of combined) {
+                const dedupKey = `${m.from}:${m.to}:${m.text.slice(0, 60)}:${m.timestamp.slice(0, 19)}`;
+                if (seen.has(dedupKey))
+                    continue;
+                seen.add(dedupKey);
                 const haystack = `${m.from} ${m.to} ${m.text}`.toLowerCase();
                 if (haystack.includes(termLower)) {
-                    allResults.push({
-                        ensemble: ens.name,
-                        from: m.from,
-                        to: m.to,
-                        text: m.text,
-                        timestamp: m.timestamp,
-                    });
+                    allResults.push({ ensemble: ens.name, ...m });
                 }
             }
         }
@@ -543,14 +552,14 @@ async function handleSearch(args, dispatch, api, ctx) {
             return;
         }
         const lines = [`\n  ${allResults.length} result${allResults.length !== 1 ? 's' : ''} for "${term}":\n`];
-        for (const r of allResults.slice(-20)) {
+        for (const r of allResults.slice(-50)) {
             const time = formatTimestamp(r.timestamp);
             const text = r.text.replace(/\n/g, ' ');
             const truncated = text.length > 70 ? text.slice(0, 67) + '...' : text;
             lines.push(`  ${time}  ${r.from} \u2192 ${r.to}: ${truncated}`);
         }
-        if (allResults.length > 20) {
-            lines.push(`\n  ... and ${allResults.length - 20} more. Narrow your search for fewer results.`);
+        if (allResults.length > 50) {
+            lines.push(`\n  ... and ${allResults.length - 50} more. Narrow your search for fewer results.`);
         }
         dispatch({ type: 'SHOW_COMMAND_OVERLAY', title: `Search \u00B7 "${term}"`, content: lines.join('\n') });
     }
@@ -567,7 +576,8 @@ async function handleRecruitConductor(_args, dispatch, api, ctx) {
     }
     commitStatic(dispatch, 'info', '\u2026 Recruiting conductor (tempo-conductor)...');
     // Spawn the conductor directly via CLI — no conductor exists yet to receive commands
-    (0, child_process_1.execFile)('claude-tempo', ['conduct', ensemble], { timeout: 30000 }, (execErr) => {
+    // shell: true resolves .cmd wrappers on Windows
+    (0, child_process_1.execFile)('claude-tempo', ['conduct', ensemble], { timeout: 30000, shell: true }, (execErr) => {
         if (execErr) {
             commitStatic(dispatch, 'error', `\u2717 Failed to recruit conductor: ${execErr.message || execErr}`);
         }
@@ -585,7 +595,31 @@ async function handleLineup(args, dispatch, api, ctx) {
     const subcommand = args[0].toLowerCase();
     if (subcommand === 'load') {
         if (args.length < 2) {
-            commitStatic(dispatch, 'error', 'Usage: /lineup load <file.yml>');
+            // No file arg — show available lineups
+            try {
+                const lineups = (0, saver_1.listAllLineups)();
+                if (lineups.length === 0) {
+                    commitStatic(dispatch, 'info', 'No lineups available. Create one with /lineup save.');
+                    return;
+                }
+                const items = lineups.map(l => ({
+                    id: l.name,
+                    label: l.name,
+                    sublabel: l.source === 'saved' ? 'saved' : 'shipped example',
+                }));
+                dispatch({
+                    type: 'SHOW_OVERLAY',
+                    overlay: {
+                        type: 'lineups',
+                        title: 'Available Lineups',
+                        items,
+                        hint: 'Usage: /lineup load <name>  \u00B7  esc=close',
+                    },
+                });
+            }
+            catch {
+                commitStatic(dispatch, 'error', 'Usage: /lineup load <name>');
+            }
             return;
         }
         const filePath = args[1];

package/dist/tui/components/ConversationStream.js

@@ -57,9 +57,11 @@ function ConversationStream({ conversation, sentMessages, contentHeight, overflo
     const allConvoMsgs = [...conversation];
     for (const m of sentMessages) {
         const ts = new Date(m.timestamp).getTime();
+        // Strip @player prefix from sent text for comparison (server doesn't have it)
+        const sentBody = m.text.replace(/^@\S+\s+/, '');
         const alreadyOnServer = conversation.some(c => c.direction === 'out' &&
             Math.abs(new Date(c.timestamp).getTime() - ts) < 30000 &&
-            c.text.slice(0, 60) === m.text.slice(0, 60));
+            c.text.slice(0, 60) === sentBody.slice(0, 60));
         if (!alreadyOnServer) {
             allConvoMsgs.push({ id: `local-${m.timestamp}`, from: 'you', to: m.to, text: m.text, timestamp: m.timestamp, direction: 'out' });
         }