claude-tempo 0.4.1 → 0.6.0

package/README.md

@@ -94,7 +94,7 @@ claude-tempo <command> [options]
 | `up [ensemble]` | First-time setup: start Temporal, configure MCP, launch conductor |
 | `down` | Stop Temporal, terminate sessions, remove MCP config |
 | `server` | Start the Temporal dev server and register search attributes |
-| `conduct [ensemble]` | Start a conductor session (one per ensemble) |
+| `conduct [ensemble]` | Start a conductor session (one per ensemble). Use `--resume` or `--replace` if one exists. |
 | `start [ensemble]` | Start a player session |
 | `status [ensemble]` | Show active sessions and Temporal health |
 | `config` | Configure Temporal connection settings (interactive or `set`/`show`) |
@@ -115,6 +115,8 @@ claude-tempo <command> [options]
 --skip-preflight              Skip preflight checks (start/conduct)
 -d, --dir <path>              Target directory (default: cwd)
 --background                  Run Temporal in background (server only)
+--resume                      Resume an existing conductor session (conduct only)
+--replace                     Stop existing conductor and start fresh (conduct only)
 ```
 
 ### `claude-tempo up`
@@ -173,6 +175,9 @@ Ensemble: myband
   bob
     Working on the dashboard
     /Users/me/projects/app  feat/ui  my-machine.local
+
+  1 active schedule
+  deploy-watch → ops | every 1h | next: 3:00:00 PM
 ```
 
 ### `claude-tempo preflight`
@@ -201,9 +206,43 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `set_name` | Set a human-readable name for this session. |
 | `set_part` | Describe what you're working on. Visible to others via `ensemble`. |
 | `listen` | Manually check for pending messages. |
-| `recruit` | Spawn a new Claude Code session in a directory. Opens a new terminal window. |
+| `recruit` | Spawn a new Claude Code session in a directory. Can recruit a conductor with `conductor: true`. |
 | `report` | Send updates to the conductor. No-op if no conductor exists. |
 | `terminate` | Terminate a player session by name. |
+| `schedule` | Create a one-shot or recurring schedule to cue a player. |
+| `unschedule` | Cancel a named schedule. |
+| `schedules` | List all active schedules. |
+
+## Scheduling
+
+Players can set up schedules to send messages on timers — useful for periodic checks, reminders, and recurring coordination.
+
+Three tools are available:
+- **`schedule`** — Create a named schedule (one-shot or recurring)
+- **`unschedule`** — Remove a schedule by name
+- **`schedules`** — List all active schedules
+
+### Examples
+
+Tell your session things like:
+
+- *"Schedule a check every hour called 'deploy-watch' — cue ops to check deployment status"*
+- *"Remind me in 30 minutes to review PR #42"*
+- *"Every 5 minutes for the next hour, ping frontend to check their progress"*
+- *"Set up a daily standup reminder at 9am UTC for the conductor"*
+- *"Cancel the deploy-watch schedule"*
+- *"Show me all active schedules"*
+
+Schedules support one-shot delays, fixed times, and recurring intervals with optional bounds (max count or end time).
+
+### How it works
+
+- Scheduled messages arrive with a `[scheduled: name]` prefix so recipients can distinguish them from direct cues
+- The `from` field is set to the schedule creator, so replies go to the right person
+- If the target player is gone when a schedule fires, the creator is notified so they can re-recruit if needed. Falls back to notifying the conductor if the creator is also unavailable
+- Messages include `isScheduled` metadata for dashboard integrations
+- `claude-tempo status` shows active schedules alongside sessions
+- A single durable scheduler workflow per ensemble manages all schedules using Temporal timers
 
 ## Conductors
 
@@ -274,11 +313,12 @@ Inside a session, try:
 
 Sessions start with a random 8-character hex ID. Set a name at launch with `-n` or use `set_name` inside a session.
 
-- Names are stored as Temporal search attributes (`ClaudeTempoPlayerId`)
+- Names are stored in workflow metadata and discoverable via metadata queries. Search attributes are also set for Temporal UI visibility.
 - Other players use names to send messages via `cue`
 - `recruit` automatically tells new sessions to set their name
 - Names must be unique within an ensemble
 - Names must contain only letters, numbers, hyphens, and underscores
+- The name "conductor" is reserved for conductor sessions
 
 ### Terminal support
 

package/dist/activities/schedule-fire.d.ts

@@ -0,0 +1,21 @@
+import { Client } from '@temporalio/client';
+export interface FireScheduleInput {
+    ensemble: string;
+    scheduleName: string;
+    message: string;
+    target: string;
+    createdBy: string;
+}
+export interface FireScheduleResult {
+    success: boolean;
+    error?: string;
+}
+/** Activity interface — used by proxyActivities in the scheduler workflow. */
+export interface ScheduleActivities {
+    fireSchedule(input: FireScheduleInput): Promise<FireScheduleResult>;
+}
+/**
+ * Create the schedule-fire activity bound to a Temporal client.
+ * The returned object is registered with the worker as activities.
+ */
+export declare function createScheduleActivities(client: Client): ScheduleActivities;

package/dist/activities/schedule-fire.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScheduleActivities = createScheduleActivities;
+/**
+ * Create the schedule-fire activity bound to a Temporal client.
+ * The returned object is registered with the worker as activities.
+ */
+function createScheduleActivities(client) {
+    return {
+        async fireSchedule(input) {
+            const { ensemble, scheduleName, message, target, createdBy } = input;
+            try {
+                // Resolve target player by querying running session workflows
+                const handle = await resolveSession(client, ensemble, target);
+                if (!handle) {
+                    // Notify the creator (or conductor as fallback) about the failure
+                    await notifyFailure(client, ensemble, createdBy, scheduleName, target, `Player "${target}" not found — session may have been terminated.`);
+                    return { success: false, error: `No active session found for "${target}"` };
+                }
+                // Send cue signal with from set to the original creator's name
+                const text = `[scheduled: ${scheduleName}] ${message}`;
+                await handle.signal('receiveMessage', {
+                    from: createdBy,
+                    text,
+                    isScheduled: true,
+                    scheduleName,
+                });
+                return { success: true };
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                return { success: false, error: errorMsg };
+            }
+        },
+    };
+}
+/**
+ * Notify the schedule creator (or conductor as fallback) that delivery failed.
+ * This lets the creator's AI session decide whether to re-recruit the target.
+ */
+async function notifyFailure(client, ensemble, createdBy, scheduleName, target, reason) {
+    const failureText = `[scheduled: ${scheduleName}] Delivery to "${target}" failed — ${reason}`;
+    // Try the creator first
+    const creatorHandle = await resolveSession(client, ensemble, createdBy);
+    if (creatorHandle) {
+        try {
+            await creatorHandle.signal('receiveMessage', {
+                from: 'scheduler',
+                text: failureText,
+                isScheduled: true,
+                scheduleName,
+            });
+            return;
+        }
+        catch {
+            // creator signal failed, fall through to conductor
+        }
+    }
+    // Fallback: notify the conductor
+    try {
+        const conductorId = `claude-session-${ensemble}-conductor`;
+        const conductorHandle = client.workflow.getHandle(conductorId);
+        await conductorHandle.signal('receiveMessage', {
+            from: 'scheduler',
+            text: failureText,
+            isScheduled: true,
+            scheduleName,
+        });
+    }
+    catch {
+        // Nobody available to notify — logged by the workflow
+    }
+}
+/**
+ * Resolve a session by player name — mirrors src/tools/resolve.ts logic.
+ * We duplicate here because activities run in Node.js and need their own copy.
+ */
+async function resolveSession(client, ensemble, playerName) {
+    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.ensemble === ensemble && metadata.playerId === playerName) {
+                return handle;
+            }
+        }
+        catch {
+            // Workflow may have just completed — skip
+        }
+    }
+    return null;
+}

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

@@ -55,6 +55,15 @@ const mcp_1 = require("./mcp");
 const out = __importStar(require("./output"));
 /** Package root is two levels up from dist/cli/ */
 const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
+function formatDurationMs(ms) {
+    if (ms >= 86_400_000)
+        return `${ms / 86_400_000}d`;
+    if (ms >= 3_600_000)
+        return `${ms / 3_600_000}h`;
+    if (ms >= 60_000)
+        return `${ms / 60_000}m`;
+    return `${ms / 1000}s`;
+}
 async function start(opts) {
     const config = (0, config_1.getConfig)(opts);
     const workDir = opts.dir || process.cwd();
@@ -76,12 +85,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 +156,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 +198,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 +210,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 || '',
@@ -187,8 +230,27 @@ async function status(opts) {
             // workflow may have closed between list and query
         }
     }
+    // Query scheduler workflows for active schedules
+    const schedulesByEnsemble = new Map();
+    const schedulerQuery = 'WorkflowType = "claudeSchedulerWorkflow" AND ExecutionStatus = "Running"';
+    for await (const wf of client.workflow.list({ query: schedulerQuery })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const entries = await handle.query('getSchedules');
+            if (entries.length > 0) {
+                // Extract ensemble from workflow ID: claude-scheduler-{ensemble}
+                const ensemble = wf.workflowId.replace('claude-scheduler-', '');
+                if (opts.ensemble && ensemble !== opts.ensemble)
+                    continue;
+                schedulesByEnsemble.set(ensemble, entries);
+            }
+        }
+        catch {
+            // scheduler may have just completed
+        }
+    }
     await connection.close();
-    if (sessions.length === 0) {
+    if (sessions.length === 0 && schedulesByEnsemble.size === 0) {
         out.log(opts.ensemble
             ? `No active sessions in ensemble "${opts.ensemble}".`
             : 'No active sessions found.');
@@ -222,6 +284,23 @@ async function status(opts) {
             if (details)
                 out.log(`    ${out.dim(details)}`);
         }
+        // Show schedules for this ensemble
+        const ensembleSchedules = schedulesByEnsemble.get(ensemble);
+        if (ensembleSchedules && ensembleSchedules.length > 0) {
+            console.log();
+            out.log(`  ${out.dim(`${ensembleSchedules.length} active schedule${ensembleSchedules.length !== 1 ? 's' : ''}`)}`);
+            for (const sched of ensembleSchedules) {
+                const recur = sched.interval
+                    ? `every ${formatDurationMs(sched.interval)}`
+                    : 'one-shot';
+                const next = new Date(sched.nextFireAt).toLocaleTimeString();
+                const bounds = [];
+                if (sched.remainingCount != null)
+                    bounds.push(`${sched.firedCount}/${sched.firedCount + sched.remainingCount} fired`);
+                const boundsStr = bounds.length ? ` (${bounds.join(', ')})` : '';
+                out.log(`  ${out.bold(sched.name)} → ${sched.target} | ${recur}${boundsStr} | next: ${next}`);
+            }
+        }
     }
     console.log();
 }
@@ -494,16 +573,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 +716,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 +756,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 +881,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.d.ts

@@ -89,3 +89,5 @@ export declare function getConfigWithSources(overrides?: CliOverrides): ConfigWi
 export declare function sessionWorkflowId(ensemble: string, playerId: string): string;
 /** Build a workflow ID for a conductor: claude-session-{ensemble}-conductor */
 export declare function conductorWorkflowId(ensemble: string): string;
+/** Build a workflow ID for the scheduler: claude-scheduler-{ensemble} */
+export declare function schedulerWorkflowId(ensemble: string): string;

package/dist/config.js

@@ -9,9 +9,14 @@ exports.getConfig = getConfig;
 exports.getConfigWithSources = getConfigWithSources;
 exports.sessionWorkflowId = sessionWorkflowId;
 exports.conductorWorkflowId = conductorWorkflowId;
+exports.schedulerWorkflowId = schedulerWorkflowId;
 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 +185,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 +225,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',
         },
@@ -243,3 +247,7 @@ function sessionWorkflowId(ensemble, playerId) {
 function conductorWorkflowId(ensemble) {
     return `claude-session-${ensemble}-conductor`;
 }
+/** Build a workflow ID for the scheduler: claude-scheduler-{ensemble} */
+function schedulerWorkflowId(ensemble) {
+    return `claude-scheduler-${ensemble}`;
+}

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)}`);