claude-tempo 0.4.0 → 0.5.0

package/README.md

@@ -32,7 +32,7 @@ This will:
 1. Check that Temporal CLI is installed
 2. Start the Temporal dev server (data persists in `~/.claude-tempo/`)
 3. Register required search attributes
-4. Create `.mcp.json` in your project
+4. Register the claude-tempo MCP server (globally by default)
 5. Launch a conductor session in a new terminal window
 
 Then add players:
@@ -52,7 +52,7 @@ For more control, run each step individually:
 # Start Temporal dev server (keep running)
 claude-tempo server
 
-# In your project directory, create .mcp.json
+# Register claude-tempo MCP server (globally by default)
 cd your-project
 claude-tempo init
 
@@ -352,6 +352,7 @@ export TEMPORAL_API_KEY=tcl_...
 | `CLAUDE_TEMPO_ENSEMBLE` | `default` | Ensemble name |
 | `CLAUDE_TEMPO_CONDUCTOR` | `false` | Enable conductor mode |
 | `CLAUDE_TEMPO_PLAYER_NAME` | *(random hex)* | Player name on startup |
+| `CLAUDE_TEMPO_DEFAULT_AGENT` | `claude` | Default agent type (`claude` or `copilot`) |
 
 ## Stale session cleanup
 
@@ -359,7 +360,7 @@ When a session crashes or closes without graceful shutdown, Temporal detects it
 
 - If a message to a dead session remains undelivered for **3 minutes**, the workflow self-completes
 - Before exiting, it notifies the conductor with the undelivered message so work can be reassigned
-- Idle sessions with no pending messages remain running until the 24-hour timeout
+- Idle sessions with no pending messages are probed after 1 hour of inactivity via a heartbeat ping; if the ping goes undelivered, the session self-completes
 
 No manual cleanup needed — `cue` a dead player and the system handles the rest.
 
@@ -367,52 +368,60 @@ No manual cleanup needed — `cue` a dead player and the system handles the rest
 
 > **Warning:** Copilot bridge support is experimental and subject to breaking changes.
 
-GitHub Copilot CLI sessions can join an ensemble via the Copilot bridge. Bridge sessions are headless — they require a Claude conductor or custom Temporal client to receive work via `cue`.
+GitHub Copilot CLI sessions can join an ensemble via the Copilot bridge. Bridge sessions are headless — they require a conductor or another player to receive work via `cue`.
 
 <details>
 <summary>Setup and usage</summary>
 
 ### Prerequisites
 
+- [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) installed and authenticated
+- An active GitHub Copilot subscription
+- Node.js 20+
+- Install the Copilot SDK: `npm install @github/copilot-sdk`
+
+### Starting Copilot sessions
+
+Use `--agent copilot` with any session-launching command:
+
 ```bash
-npm install @github/copilot-sdk    # optional dependency (~243MB)
+claude-tempo start myband --agent copilot -n copilot-1      # start a player
+claude-tempo conduct myband --agent copilot                  # start a conductor
+claude-tempo up myband --agent copilot                       # full setup
 ```
 
-Also requires [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) installed, authenticated, with an active subscription. Node 20+ required for Copilot features.
+Or recruit from within any active session:
 
-### Starting a Copilot player
+> "Recruit a copilot session named 'copilot-dev' in /repos/my-project with agent copilot"
 
-The easiest way is via `recruit` from any active session:
+### Setting a default agent
 
-> "Recruit a copilot session named 'copilot-dev' in /repos/my-project with agent copilot"
+To avoid passing `--agent copilot` every time:
+
+```bash
+claude-tempo config set default-agent copilot
+```
 
-Or start the bridge directly:
+Or via environment variable:
 
 ```bash
-CLAUDE_TEMPO_ENSEMBLE=default COPILOT_BRIDGE_NAME=copilot-dev npx ts-node src/copilot-bridge.ts
+export CLAUDE_TEMPO_DEFAULT_AGENT=copilot
 ```
 
-### How it works
+Resolution order: `--agent` flag → `CLAUDE_TEMPO_DEFAULT_AGENT` env → config file → `claude`.
 
-1. Bridge spawns a Copilot CLI session via the SDK with claude-tempo as MCP server
-2. MCP server registers the session as a Temporal workflow
-3. Bridge polls for pending messages every 2 seconds
-4. Messages are injected as prompts via `session.sendAndWait()`
-5. The Copilot session can use all claude-tempo tools
+### Model override
 
-### Copilot environment variables
+Set `COPILOT_BRIDGE_MODEL` to use a specific model for Copilot sessions:
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `COPILOT_BRIDGE_NAME` | *(none)* | Player name |
-| `COPILOT_BRIDGE_MODEL` | *(Copilot default)* | Model override |
-| `GITHUB_TOKEN` | *(logged-in user)* | GitHub auth token |
+```bash
+COPILOT_BRIDGE_MODEL=gpt-4o claude-tempo start myband --agent copilot
+```
 
 ### Limitations
 
-- No interactive access — bridge sessions only respond to cues
-- 2-second polling latency (vs instant for Claude Code sessions)
-- Must be spawned via the bridge to participate
+- Headless only — bridge sessions respond to cues, no interactive terminal
+- ~2-second polling latency (vs instant for Claude Code sessions)
 - `@github/copilot-sdk` adds ~243MB to node_modules
 - Node 20+ required (rest of claude-tempo works on Node 18+)
 

package/dist/cli/commands.d.ts

@@ -3,6 +3,8 @@ import { AgentType } from '../types';
 interface StartOpts extends CliOverrides {
     ensemble: string;
     conductor: boolean;
+    replace?: boolean;
+    resume?: boolean;
     name?: string;
     skipPreflight?: boolean;
     agent: AgentType;

package/dist/cli/commands.js

@@ -76,12 +76,42 @@ async function start(opts) {
     if (opts.conductor) {
         try {
             const connection = await (0, connection_1.createTemporalConnection)(config);
-            const client = new client_1.Client({ connection });
+            const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
             const conductorWfId = (0, config_1.conductorWorkflowId)(opts.ensemble);
             const handle = client.workflow.getHandle(conductorWfId);
             const desc = await handle.describe();
             if (desc.status.name === 'RUNNING') {
-                out.warn(`A conductor workflow already exists for ensemble "${opts.ensemble}". Reconnecting...`);
+                if (opts.replace) {
+                    out.log(`Stopping existing conductor for ensemble "${opts.ensemble}"...`);
+                    try {
+                        await handle.signal(signals_1.shutdownSignal);
+                        // Wait briefly for graceful shutdown
+                        for (let i = 0; i < 10; i++) {
+                            await new Promise(r => setTimeout(r, 500));
+                            const check = await handle.describe();
+                            if (check.status.name !== 'RUNNING')
+                                break;
+                        }
+                    }
+                    catch {
+                        // Force cancel if signal fails
+                        try {
+                            await handle.cancel();
+                        }
+                        catch { /* already gone */ }
+                    }
+                    out.success('Existing conductor stopped');
+                }
+                else if (opts.resume) {
+                    out.log(`Resuming conductor for ensemble "${opts.ensemble}" — reconnecting to existing workflow state.\n`);
+                }
+                else {
+                    out.error(`A conductor is already running for ensemble "${opts.ensemble}".`);
+                    out.log(`  ${out.dim('claude-tempo conduct --resume')}    Reconnect a new session to the existing workflow`);
+                    out.log(`  ${out.dim('claude-tempo conduct --replace')}   Stop the existing conductor and start fresh`);
+                    await connection.close();
+                    process.exit(1);
+                }
             }
             await connection.close();
         }
@@ -117,25 +147,27 @@ async function start(opts) {
         out.success(`Launched copilot bridge${opts.name ? ` "${opts.name}"` : ''} (pid ${pid ?? 'unknown'})`);
     }
     else {
+        // Default conductor name to "conductor" so the Claude Code session name matches
+        const sessionName = opts.name || (opts.conductor ? 'conductor' : undefined);
         const claudeArgs = [
             '--dangerously-skip-permissions',
             '--dangerously-load-development-channels', 'server:claude-tempo',
         ];
-        if (opts.name) {
-            claudeArgs.push('-n', opts.name);
+        if (opts.resume && sessionName) {
+            // Resume the previous Claude Code conversation by name
+            claudeArgs.push('--resume', sessionName);
+        }
+        else if (sessionName) {
+            claudeArgs.push('-n', sessionName);
         }
         const envVars = {
             ...temporalEnvVars,
             [config_1.ENV.ENSEMBLE]: opts.ensemble,
+            [config_1.ENV.CONDUCTOR]: opts.conductor ? 'true' : '',
+            [config_1.ENV.PLAYER_NAME]: sessionName || '',
         };
-        if (opts.conductor) {
-            envVars[config_1.ENV.CONDUCTOR] = 'true';
-        }
-        if (opts.name) {
-            envVars[config_1.ENV.PLAYER_NAME] = opts.name;
-        }
         const { pid } = (0, spawn_1.spawnInTerminal)(claudeArgs, workDir, envVars);
-        out.success(`Launched ${role} session${opts.name ? ` "${opts.name}"` : ''} (pid ${pid ?? 'unknown'})`);
+        out.success(`Launched ${role} session${sessionName ? ` "${sessionName}"` : ''} (pid ${pid ?? 'unknown'})`);
     }
     out.log(`  Ensemble: ${opts.ensemble}`);
     out.log(`  Directory: ${workDir}`);
@@ -157,11 +189,9 @@ async function status(opts) {
         return; // unreachable, helps TS
     }
     const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
-    // Build query
-    let query = 'WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"';
-    if (opts.ensemble) {
-        query += ` AND ClaudeTempoEnsemble = "${opts.ensemble}"`;
-    }
+    // List all running session workflows, filter by ensemble using metadata queries.
+    // This avoids depending on custom search attributes which are eventually consistent.
+    const query = 'WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"';
     const sessions = [];
     for await (const wf of client.workflow.list({ query })) {
         try {
@@ -171,11 +201,15 @@ async function status(opts) {
                 handle.query('getPart').catch(() => ''),
             ]);
             const meta = metadata;
+            const ensemble = meta.ensemble || '?';
+            // Filter by ensemble if specified
+            if (opts.ensemble && ensemble !== opts.ensemble)
+                continue;
             sessions.push({
                 id: wf.workflowId,
                 name: meta.playerId || wf.workflowId.split('-').pop() || '?',
                 part: part || '',
-                ensemble: meta.ensemble || '?',
+                ensemble,
                 workDir: meta.workDir || '?',
                 branch: meta.gitBranch || '',
                 host: meta.hostname || '',
@@ -494,16 +528,18 @@ async function up(opts) {
         }));
     }
     else {
+        // Default conductor name so the Claude Code session name matches the ensemble role
+        const sessionName = opts.name || 'conductor';
         const claudeArgs = [
             '--dangerously-skip-permissions',
             '--dangerously-load-development-channels', 'server:claude-tempo',
+            '-n', sessionName,
         ];
-        if (opts.name)
-            claudeArgs.push('-n', opts.name);
         ({ pid } = (0, spawn_1.spawnInTerminal)(claudeArgs, process.cwd(), {
             ...temporalEnvVars,
             [config_1.ENV.ENSEMBLE]: opts.ensemble,
             [config_1.ENV.CONDUCTOR]: 'true',
+            [config_1.ENV.PLAYER_NAME]: sessionName,
         }));
     }
     console.log();
@@ -635,14 +671,22 @@ async function stop(opts) {
     }
     else {
         // Stop multiple sessions (--ensemble or --all)
-        let query = 'WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"';
-        if (opts.ensemble) {
-            query += ` AND ClaudeTempoEnsemble = "${opts.ensemble}"`;
-        }
+        const query = 'WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"';
         let stopped = 0;
         for await (const wf of client.workflow.list({ query })) {
             try {
                 const handle = client.workflow.getHandle(wf.workflowId);
+                // Filter by ensemble using metadata if specified
+                if (opts.ensemble) {
+                    try {
+                        const meta = (await handle.query('getMetadata'));
+                        if (meta.ensemble !== opts.ensemble)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
                 await handle.signal(signals_1.shutdownSignal);
                 stopped++;
                 out.log(`  ${out.dim('stopped')} ${wf.workflowId}`);
@@ -667,39 +711,41 @@ async function stop(opts) {
     await connection.close();
 }
 async function stopByName(client, name, config, ensemble) {
-    // Find the workflow by player name via search attribute
-    let query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoPlayerId = "${name}"`;
-    if (ensemble) {
-        query += ` AND ClaudeTempoEnsemble = "${ensemble}"`;
-    }
+    // Find the workflow by player name using metadata queries (not search attributes).
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
     let found = false;
     for await (const wf of client.workflow.list({ query })) {
-        found = true;
         const handle = client.workflow.getHandle(wf.workflowId);
-        // Check if this is a conductor — warn about it
+        // Check metadata to match by name and ensemble
+        let metadata;
         try {
-            const metadata = (await handle.query('getMetadata'));
-            if (metadata.isConductor) {
-                out.warn(`"${name}" is a conductor session`);
-            }
-            // Notify the conductor that this session was stopped (if it's not the conductor itself)
-            if (!metadata.isConductor && metadata.ensemble) {
-                try {
-                    const conductorWfId = (0, config_1.conductorWorkflowId)(metadata.ensemble);
-                    const conductorHandle = client.workflow.getHandle(conductorWfId);
-                    await conductorHandle.signal(signals_1.playerReportSignal, {
-                        playerId: name,
-                        text: 'Session stopped by CLI',
-                        type: 'result',
-                    });
-                }
-                catch {
-                    // No conductor or conductor not running — fine
-                }
-            }
+            metadata = (await handle.query('getMetadata'));
+            if (metadata.playerId !== name)
+                continue;
+            if (ensemble && metadata.ensemble !== ensemble)
+                continue;
         }
         catch {
-            // Query failed — proceed with shutdown anyway
+            continue;
+        }
+        found = true;
+        if (metadata.isConductor) {
+            out.warn(`"${name}" is a conductor session`);
+        }
+        // Notify the conductor that this session was stopped (if it's not the conductor itself)
+        if (!metadata.isConductor && metadata.ensemble) {
+            try {
+                const conductorWfId = (0, config_1.conductorWorkflowId)(metadata.ensemble);
+                const conductorHandle = client.workflow.getHandle(conductorWfId);
+                await conductorHandle.signal(signals_1.playerReportSignal, {
+                    playerId: name,
+                    text: 'Session stopped by CLI',
+                    type: 'result',
+                });
+            }
+            catch {
+                // No conductor or conductor not running — fine
+            }
         }
         // Send shutdown signal (graceful)
         try {
@@ -790,7 +836,7 @@ ${out.bold('Commands:')}
   ${out.cyan('up')}      [ensemble]    First-time setup: start Temporal, configure MCP, launch conductor
   ${out.cyan('down')}                  Stop Temporal, terminate sessions, remove MCP config
   ${out.cyan('server')}                Start the Temporal dev server and register search attributes
-  ${out.cyan('conduct')} [ensemble]    Start a conductor session (one per ensemble)
+  ${out.cyan('conduct')} [ensemble]    Start a conductor session (resumes existing, --replace to restart)
   ${out.cyan('start')}   [ensemble]    Start a player session
   ${out.cyan('stop')}    [ensemble]    Stop sessions (-n <name> for one, or --all)
   ${out.cyan('status')}  [ensemble]    Show active sessions and Temporal health

package/dist/cli/mcp.js

@@ -14,7 +14,7 @@ function isGlobalMcpRegistered() {
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
         });
-        return output.includes('claude-tempo');
+        return /\bclaude-tempo\b/.test(output);
     }
     catch {
         return false;

package/dist/cli.js

@@ -49,6 +49,8 @@ function parseArgs(argv) {
         keepMcp: false,
         all: false,
         project: false,
+        replace: false,
+        resume: false,
     };
     let i = 0;
     while (i < argv.length) {
@@ -89,6 +91,12 @@ function parseArgs(argv) {
         else if (arg === '--project') {
             result.project = true;
         }
+        else if (arg === '--replace') {
+            result.replace = true;
+        }
+        else if (arg === '--resume') {
+            result.resume = true;
+        }
         else if (arg === '--ensemble' && i + 1 < argv.length) {
             result.ensemble = argv[++i];
         }
@@ -142,6 +150,8 @@ async function main() {
             await (0, commands_1.start)({
                 ensemble,
                 conductor: true,
+                replace: args.replace,
+                resume: args.resume,
                 name: args.name,
                 skipPreflight: args.skipPreflight,
                 agent: resolvedAgent(),

package/dist/config.js

@@ -12,6 +12,10 @@ exports.conductorWorkflowId = conductorWorkflowId;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
+const VALID_AGENTS = ['claude', 'copilot'];
+function validAgent(value) {
+    return VALID_AGENTS.includes(value) ? value : 'claude';
+}
 /** Environment variable name constants — use these instead of string literals. */
 exports.ENV = {
     ENSEMBLE: 'CLAUDE_TEMPO_ENSEMBLE',
@@ -180,10 +184,9 @@ function getConfig(overrides = {}) {
         temporalApiKey: resolveOpt(overrides.temporalApiKey, exports.ENV.TEMPORAL_API_KEY, configFile.temporalApiKey, temporalCli.temporalApiKey),
         temporalTlsCertPath: resolveOpt(overrides.temporalTlsCertPath, exports.ENV.TEMPORAL_TLS_CERT_PATH, configFile.temporalTlsCertPath, temporalCli.temporalTlsCertPath),
         temporalTlsKeyPath: resolveOpt(overrides.temporalTlsKeyPath, exports.ENV.TEMPORAL_TLS_KEY_PATH, configFile.temporalTlsKeyPath, temporalCli.temporalTlsKeyPath),
-        defaultAgent: (overrides.defaultAgent
+        defaultAgent: validAgent(overrides.defaultAgent
             || process.env[exports.ENV.DEFAULT_AGENT]
-            || configFile.defaultAgent
-            || 'claude'),
+            || configFile.defaultAgent),
         taskQueue: process.env[exports.ENV.TASK_QUEUE] ?? 'claude-tempo',
         ensemble: process.env[exports.ENV.ENSEMBLE] ?? 'default',
     };
@@ -221,7 +224,7 @@ function getConfigWithSources(overrides = {}) {
             temporalApiKey: apiKey.value,
             temporalTlsCertPath: tlsCert.value,
             temporalTlsKeyPath: tlsKey.value,
-            defaultAgent: (defaultAgent.value || 'claude'),
+            defaultAgent: validAgent(defaultAgent.value),
             taskQueue: process.env[exports.ENV.TASK_QUEUE] ?? 'claude-tempo',
             ensemble: process.env[exports.ENV.ENSEMBLE] ?? 'default',
         },

package/dist/copilot-bridge.js

@@ -116,10 +116,11 @@ async function main() {
     // `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];
+    const isConductor = process.env[config_1.ENV.CONDUCTOR] === 'true';
+    const requestedName = process.env[config_1.ENV.PLAYER_NAME] || playerName || '';
     const playerIdForWorkflow = isConductor
         ? 'conductor'
-        : (process.env[config_1.ENV.PLAYER_NAME] || playerName || `copilot-${Date.now()}`);
+        : (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.
@@ -137,7 +138,7 @@ async function main() {
         [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]: process.env[config_1.ENV.CONDUCTOR] || '',
+        [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 } : {}),
@@ -286,6 +287,7 @@ async function main() {
         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.]';
     // Start message poller — inject messages into the Copilot session.
     // Tracks consecutive failures and attempts session recreation before giving up.
     let polling = true;
@@ -331,9 +333,12 @@ async function main() {
             processing = true;
             const ids = messages.map((m) => m.id);
             await handle.signal('markDelivered', ids);
-            // Format messages into a single prompt
+            // Format messages into a single prompt, appending ack instruction for Maestro messages
             const prompt = messages
-                .map((m) => `[Message from ${m.from}]: ${m.text}`)
+                .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)}`);

package/dist/server.js

@@ -90,7 +90,12 @@ async function main() {
     }
     const config = (0, config_1.getConfig)();
     const isConductor = process.env[config_1.ENV.CONDUCTOR] === 'true';
-    let playerId = isConductor ? 'conductor' : (process.env[config_1.ENV.PLAYER_NAME] || crypto.randomBytes(4).toString('hex'));
+    const requestedName = process.env[config_1.ENV.PLAYER_NAME] || '';
+    // Prevent non-conductor sessions from using "conductor" as a name,
+    // which would collide with the conductor's deterministic workflow ID.
+    let playerId = isConductor
+        ? 'conductor'
+        : (requestedName && requestedName !== 'conductor' ? requestedName : '') || crypto.randomBytes(4).toString('hex');
     const getPlayerId = () => playerId;
     const setPlayerId = (id) => { playerId = id; };
     const workDir = process.cwd();
@@ -182,6 +187,7 @@ async function main() {
     (0, recruit_1.registerRecruitTool)(mcpServer, client, config, getPlayerId, isBridgeMode ? 'copilot' : 'claude');
     (0, report_1.registerReportTool)(mcpServer, client, config, getPlayerId);
     (0, terminate_1.registerTerminateTool)(mcpServer, client, config, getPlayerId);
+    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.]';
     // Start message poller — push messages into Claude Code via channel notifications.
     // Skip when running under the Copilot bridge: the bridge has its own poller that
     // injects messages via sendAndWait. If both pollers run, this one wins the race and
@@ -191,11 +197,12 @@ async function main() {
         : (0, channel_1.startMessagePoller)(handle, async (messages) => {
             for (const msg of messages) {
                 log(`Message from ${msg.from}: ${msg.text}`);
+                const content = msg.isMaestro ? msg.text + MAESTRO_ACK : msg.text;
                 try {
                     await mcpServer.server.notification({
                         method: 'notifications/claude/channel',
                         params: {
-                            content: msg.text,
+                            content,
                             meta: {
                                 from_player: msg.from,
                                 sent_at: msg.timestamp,

package/dist/tools/ensemble.js

@@ -42,23 +42,29 @@ function registerEnsembleTool(server, client, config, getPlayerId, ownWorkflowId
         scope: zod_1.z.string().optional().describe('Filter scope: "machine" (same hostname), "repo" (same git root), "all" (default). All scopes are within the current ensemble.'),
     }, async (args) => {
         const scope = (args.scope ?? 'all');
-        let query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${config.ensemble}"`;
-        if (scope === 'machine') {
-            query += ` AND ClaudeTempoHostname = "${os.hostname()}"`;
-        }
+        // List all running session workflows, then filter by ensemble using
+        // in-memory metadata queries. This avoids depending on custom search
+        // attributes which are eventually consistent and may be missing/stale.
+        const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
         const players = [];
         try {
             for await (const workflow of client.workflow.list({ query })) {
                 try {
                     const handle = client.workflow.getHandle(workflow.workflowId);
                     const metadata = await handle.query('getMetadata');
-                    const part = await handle.query('getPart');
+                    // Filter by ensemble
+                    if (metadata.ensemble !== config.ensemble)
+                        continue;
+                    // Filter by scope
+                    if (scope === 'machine' && metadata.hostname !== os.hostname())
+                        continue;
                     if (scope === 'repo') {
                         const ownHandle = client.workflow.getHandle(ownWorkflowId);
                         const ownMeta = await ownHandle.query('getMetadata');
                         if (metadata.gitRoot !== ownMeta.gitRoot)
                             continue;
                     }
+                    const part = await handle.query('getPart');
                     players.push({
                         playerId: metadata.playerId,
                         part,

package/dist/tools/recruit.js

@@ -14,14 +14,17 @@ function registerRecruitTool(server, client, config, getPlayerId, ownAgentType =
     (0, helpers_1.defineTool)(server, 'recruit', `Start a new named session in a directory. Rejects if the name is already active. Supports Claude Code or Copilot CLI agents. Defaults to "${ownAgentType}" (same as this session).`, {
         workDir: zod_1.z.string().describe('The working directory for the new session'),
         name: zod_1.z.string().describe('Name for the new session'),
+        conductor: zod_1.z.boolean().optional()
+            .describe('Whether this session is a conductor (default: false)'),
         initialMessage: zod_1.z.string().optional()
             .describe('Optional task or message for the new session (sent after it sets its name)'),
         agent: zod_1.z.enum(['claude', 'copilot']).optional()
             .describe(`Which agent to use (default: "${ownAgentType}", same as this session)`),
     }, async (args) => {
         const { workDir, name, initialMessage } = args;
+        const isConductor = args.conductor === true;
         const agent = args.agent || ownAgentType;
-        // Validate name to prevent search attribute query injection
+        // Validate name
         if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
             return {
                 content: [{
@@ -31,7 +34,36 @@ function registerRecruitTool(server, client, config, getPlayerId, ownAgentType =
                 isError: true,
             };
         }
+        if (name === 'conductor' && !isConductor) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `The name "conductor" is reserved for conductor sessions. Use a different name, or set conductor: true.`,
+                    }],
+                isError: true,
+            };
+        }
         try {
+            // Check if a conductor already exists when recruiting a conductor
+            if (isConductor) {
+                try {
+                    const conductorWfId = (0, config_1.conductorWorkflowId)(config.ensemble);
+                    const conductorHandle = client.workflow.getHandle(conductorWfId);
+                    const desc = await conductorHandle.describe();
+                    if (desc.status.name === 'RUNNING') {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `A conductor is already running in ensemble "${config.ensemble}". Use \`claude-tempo conduct --replace\` from the CLI to replace it, or \`terminate\` it first.`,
+                                }],
+                            isError: true,
+                        };
+                    }
+                }
+                catch {
+                    // No existing conductor — proceed
+                }
+            }
             // Check if a session with this name is already active
             const existing = await (0, resolve_1.resolveSession)(client, config.ensemble, name);
             if (existing) {
@@ -45,7 +77,7 @@ function registerRecruitTool(server, client, config, getPlayerId, ownAgentType =
             }
             // Record existing workflows so we can find the new one
             const existingIds = new Set();
-            const listQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${config.ensemble}"`;
+            const listQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
             for await (const wf of client.workflow.list({ query: listQuery })) {
                 existingIds.add(wf.workflowId);
             }
@@ -59,6 +91,7 @@ function registerRecruitTool(server, client, config, getPlayerId, ownAgentType =
                     temporalApiKey: config.temporalApiKey,
                     temporalTlsCertPath: config.temporalTlsCertPath,
                     temporalTlsKeyPath: config.temporalTlsKeyPath,
+                    isConductor,
                     workDir,
                 });
                 log(`Spawned copilot-bridge (pid ${pid}) in ${workDir} as "${name}"`);
@@ -71,7 +104,8 @@ function registerRecruitTool(server, client, config, getPlayerId, ownAgentType =
                 ];
                 const envVars = {
                     [config_1.ENV.ENSEMBLE]: config.ensemble,
-                    [config_1.ENV.CONDUCTOR]: '',
+                    [config_1.ENV.CONDUCTOR]: isConductor ? 'true' : '',
+                    [config_1.ENV.PLAYER_NAME]: name,
                     [config_1.ENV.TEMPORAL_ADDRESS]: config.temporalAddress,
                     [config_1.ENV.TEMPORAL_NAMESPACE]: config.temporalNamespace,
                 };

package/dist/tools/resolve.d.ts

@@ -1,2 +1,8 @@
 import { Client, WorkflowHandle } from '@temporalio/client';
+/**
+ * Resolve a session by player name.
+ * Lists all running session workflows and queries each for metadata.
+ * This avoids depending on custom search attributes which are eventually
+ * consistent and may be missing or stale.
+ */
 export declare function resolveSession(client: Client, ensemble: string, playerName: string): Promise<WorkflowHandle | null>;