claude-tempo 0.4.1 → 0.5.0

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>;

package/dist/tools/resolve.js

@@ -3,25 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSession = resolveSession;
 /**
  * Resolve a session by player name.
- * 1. Try search attribute query (fast, indexed — but eventually consistent)
- * 2. Fall back to listing all ensemble workflows and querying metadata (always current)
+ * 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.
  */
-function escapeQueryString(s) {
-    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-}
 async function resolveSession(client, ensemble, playerName) {
-    // Fast path: search attribute (may lag behind by a few seconds after rename)
-    const saQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${escapeQueryString(ensemble)}" AND ClaudeTempoPlayerId = "${escapeQueryString(playerName)}"`;
-    for await (const wf of client.workflow.list({ query: saQuery })) {
-        return client.workflow.getHandle(wf.workflowId);
-    }
-    // Fallback: list all ensemble workflows and check in-memory metadata
-    const fallbackQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${escapeQueryString(ensemble)}"`;
-    for await (const wf of client.workflow.list({ query: fallbackQuery })) {
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+    for await (const wf of client.workflow.list({ query })) {
         try {
             const handle = client.workflow.getHandle(wf.workflowId);
             const metadata = await handle.query('getMetadata');
-            if (metadata.playerId === playerName) {
+            if (metadata.ensemble === ensemble && metadata.playerId === playerName) {
                 return handle;
             }
         }

package/dist/tools/terminate.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerTerminateTool = registerTerminateTool;
 const zod_1 = require("zod");
+const signals_1 = require("../workflows/signals");
 const resolve_1 = require("./resolve");
 const helpers_1 = require("./helpers");
 function registerTerminateTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'terminate', 'Terminate a player session by name. Use this to clean up orphaned sessions.', {
+    (0, helpers_1.defineTool)(server, 'terminate', 'Terminate a player session by name. Sends a graceful shutdown signal so the session can clean up.', {
         playerId: zod_1.z.string().describe('The player name of the session to terminate'),
     }, async (args) => {
         const { playerId } = args;
@@ -23,19 +24,22 @@ function registerTerminateTool(server, client, config, getPlayerId) {
                     isError: true,
                 };
             }
-            // Warn the session before terminating
+            // Notify the session before shutting it down. The message poller
+            // delivers this to the Claude session so it knows why it lost its tools.
             try {
                 await handle.signal('receiveMessage', {
                     from: getPlayerId(),
-                    text: `Your session is being terminated by player ${getPlayerId()}. Please save your work and close this terminal.`,
+                    text: `Your session has been terminated by ${getPlayerId()}. Your claude-tempo tools will stop working shortly.`,
                 });
+                // Brief delay to let the poller deliver the message before shutdown
+                await new Promise(r => setTimeout(r, 1000));
             }
             catch {
-                // May fail if workflow is in a bad state — proceed with termination
+                // May fail if workflow is in a bad state — proceed with shutdown
             }
-            await handle.terminate(`Terminated by player ${getPlayerId()}`);
+            await handle.signal(signals_1.shutdownSignal);
             return {
-                content: [{ type: 'text', text: `Session **${playerId}** terminated. If the Claude Code terminal is still open, the user will need to close it manually.` }],
+                content: [{ type: 'text', text: `Shutdown signal sent to **${playerId}**. The workflow and MCP server will exit. The Claude Code terminal may remain open and will need to be closed manually.` }],
             };
         }
         catch (err) {

package/dist/types.d.ts

@@ -31,6 +31,8 @@ export interface Message {
     text: string;
     timestamp: string;
     delivered: boolean;
+    /** True when sent from the Maestro dashboard by a human. */
+    isMaestro?: boolean;
 }
 export interface SentMessage {
     id: string;

package/dist/workflows/session.js

@@ -6,6 +6,15 @@ const signals_1 = require("./signals");
 async function claudeSessionWorkflow(input) {
     const STALE_MESSAGE_MS = 3 * 60 * 1000; // 3 minutes
     const HEARTBEAT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+    // Ensure search attributes are always current — critical when reconnecting
+    // via WorkflowIdConflictPolicy.USE_EXISTING, which skips the attributes
+    // passed to client.workflow.start().
+    (0, workflow_1.upsertSearchAttributes)({
+        ClaudeTempoEnsemble: [input.metadata.ensemble],
+        ClaudeTempoPlayerId: [input.metadata.playerId],
+        ClaudeTempoHostname: [input.metadata.hostname],
+        ...(input.metadata.gitRoot ? { ClaudeTempoGitRoot: [input.metadata.gitRoot] } : {}),
+    });
     // State (carried across continue-as-new)
     let part = input.part ?? input.autoSummary ?? 'No description set';
     const messages = input.messages ?? [];
@@ -20,7 +29,9 @@ async function claudeSessionWorkflow(input) {
             text: msg.text,
             timestamp: new Date().toISOString(),
             delivered: false,
+            isMaestro: msg.isMaestro,
         });
+        lastActivityTime = Date.now();
     });
     (0, workflow_1.setHandler)(signals_1.setPartSignal, (newPart) => {
         part = newPart;