claude-tempo 0.11.0 → 0.11.1

package/CLAUDE.md

@@ -34,7 +34,7 @@ src/
 │   ├── scheduler-signals.ts # Scheduler signal/query type definitions
 │   └── signals.ts     # Session signal/query type definitions
 ├── activities/
-│   ├── outbox.ts      # Outbox delivery activities (cue, report, stop, recruit)
+│   ├── outbox.ts      # Outbox delivery activities (cue, report, stop, recruit, encore)
 │   └── schedule-fire.ts # Schedule fire activity
 ├── ensemble/
 │   ├── schema.ts      # Lineup type definitions
@@ -53,12 +53,17 @@ src/
 │   ├── recruit.ts     # Spawn new session (via outbox), supports `type` param
 │   ├── report.ts      # Report to conductor (via outbox)
 │   ├── stop.ts        # Stop a session (via outbox)
+│   ├── broadcast.ts   # Send message to all active players (via outbox fan-out)
+│   ├── encore.ts      # Revive a stale session (via outbox)
+│   ├── recall.ts      # Read own message history (received + sent)
 │   ├── load-lineup.ts # Load an ensemble lineup, recruit players
 │   ├── save-lineup.ts # Save current ensemble state as a lineup
 │   ├── schedule.ts    # Create one-shot or recurring schedules
 │   ├── unschedule.ts  # Cancel a named schedule
 │   ├── schedules.ts   # List active schedules
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
+├── utils/
+│   └── validation.ts  # Shared validation constants (name/message/path limits, encore defaults) and helpers
 ├── types.ts           # Shared type definitions
 ├── channel.ts         # Claude channel notification helper
 ├── git-info.ts        # Git repository detection helper
@@ -101,7 +106,10 @@ npm test
 - **Recruit**: Spawning a new Claude Code session as a player. The workflow is pre-created with the initial message before the process spawns, ensuring reliable delivery.
 - **set_name**: Players start with a random hex ID; `set_name` updates the `ClaudeTempoPlayerId` search attribute to a human-readable name
 - **Session status**: Each session has a status (`pending` → `active` → `stale`) tracked via `ClaudeTempoStatus` search attribute. Pre-created workflows start as `pending`, transition to `active` when the process connects, and become `stale` if messages go undelivered for 3+ minutes.
-- **Outbox**: Outbound requests (cue, report, stop, recruit) go through the session's own workflow outbox instead of directly signaling other workflows. The workflow's dispatch loop processes entries via activities, decoupling tools from cross-workflow signaling.
+- **Outbox**: Outbound requests (cue, report, stop, recruit, encore) go through the session's own workflow outbox instead of directly signaling other workflows. The workflow's dispatch loop processes entries via activities, decoupling tools from cross-workflow signaling.
+- **Encore**: Revives a `stale` player session by restarting the Claude process and reconnecting to the existing Temporal workflow, with recent message context restored. Cannot encore `active`, `pending`, or `terminated` sessions — use `cue`, wait, or `recruit` respectively.
+- **Broadcast**: Fan-out variant of `cue` — sends a message to all active players in the ensemble in a single call. Optionally filtered by player type. Skips the sender, pending sessions, and (by default) stale sessions.
+- **Recall**: Queries a session's own message history from the Temporal workflow. Shows received messages by default; pass `includeSent: true` to also see sent messages. Supports `limit`, `since`, and `from` filters.
 - **Per-host task queues**: Each host runs a `claude-tempo-{hostname}` activity worker for local-only operations (e.g., `spawnProcess`). This enables cross-machine recruiting — the `recruit` tool accepts an optional `host` parameter to route the spawn to a remote machine's task queue.
 - **Player types**: Reusable agent definitions in Claude Code's standard subagent format (`.md` files with YAML frontmatter). Ensemble lineups can reference types by name via a `type` field on players. Three-tier lookup: project `.claude/agents/` → user `~/.claude/agents/` → shipped `examples/agents/`. Players know their type via workflow metadata and the `who_am_i` tool.
 - **Agent type discovery**: The `agent_types` MCP tool and `claude-tempo agent-types` CLI command let conductors discover available player types. Shipped examples (tempo-conductor, tempo-composer, tempo-soloist, tempo-tuner, tempo-critic, tempo-roadie, tempo-improv, tempo-liner) work out of the box. Ensemble lineups: tempo-big-band (full lifecycle), tempo-dev-team (feature work), tempo-review-squad (parallel review), tempo-jam-session (exploration).
@@ -123,3 +131,14 @@ Examples:
 - `feat(tools): add ensemble discovery tool`
 - `fix(workflow): handle signal delivery edge case`
 - `docs: update getting started guide`
+
+## Release Process
+
+**Correct order — never deviate:**
+
+1. Merge the feature PR into `main` (squash merge)
+2. Bump `version` in `package.json` and add a `## [x.y.z]` entry in `CHANGELOG.md` on `main`
+3. Commit: `chore: bump version to vX.Y.Z`
+4. Tag the bump commit: `git tag vX.Y.Z && git push origin vX.Y.Z`
+
+The release workflow triggers on `v*` tag pushes and publishes to npm. **Never tag before the version bump commit exists on main, and never tag a commit that doesn't match the version in `package.json`.** Tagging prematurely (e.g., before a feature PR merges) publishes the old version to npm and forces a patch bump to recover.

package/README.md

@@ -130,6 +130,9 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `agent_types` | List available player types with name, description, and source. |
 | `save_lineup` | Save the current ensemble as a YAML lineup (conductor only). |
 | `load_lineup` | Load a lineup to recruit players and create schedules. |
+| `broadcast` | Send a message to all active players. Optional `type` filter limits to a specific player type. |
+| `encore` | Revive a stale player session — restarts the process and reconnects to the existing workflow with context restored. |
+| `recall` | Read your own message history. Shows received messages by default; pass `includeSent: true` for the full timeline. |
 
 ## Scheduling
 

package/dist/activities/outbox.d.ts

@@ -43,6 +43,25 @@ export interface SpawnProcessInput {
     agentDefinition?: string;
     agentDefinitionPath?: string;
     nativeResolvable?: boolean;
+    /** When true, use --resume instead of -n (reconnect to existing session). */
+    resume?: boolean;
+}
+export interface PerformEncoreInput {
+    ensemble: string;
+    targetPlayerId: string;
+    fromPlayerId: string;
+    contextMessageCount?: number;
+}
+export interface EncoreResult {
+    workDir: string;
+    hostname: string;
+    isConductor: boolean;
+    agent: AgentType;
+    agentDefinition?: string;
+    agentDefinitionPath?: string;
+    nativeResolvable?: boolean;
+    temporalAddress: string;
+    temporalNamespace: string;
 }
 export interface OutboxActivityResult {
     success: boolean;
@@ -54,6 +73,7 @@ export interface OutboxActivities {
     terminateSession(input: TerminateSessionInput): Promise<OutboxActivityResult>;
     startRecruitedSession(input: StartRecruitedSessionInput): Promise<OutboxActivityResult>;
     spawnProcess(input: SpawnProcessInput): Promise<OutboxActivityResult>;
+    performEncore(input: PerformEncoreInput): Promise<EncoreResult>;
 }
 /**
  * Create outbox delivery activities bound to a Temporal client and config.

package/dist/activities/outbox.js

@@ -40,10 +40,12 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
 const config_1 = require("../config");
+const validation_1 = require("../utils/validation");
 const git_info_1 = require("../git-info");
 const spawn_1 = require("../spawn");
 const config_2 = require("../config");
 const resolve_1 = require("./resolve");
+const agent_types_1 = require("../ensemble/agent-types");
 const log = (...args) => console.error('[claude-tempo:outbox]', ...args);
 /**
  * Create outbox delivery activities bound to a Temporal client and config.
@@ -143,7 +145,7 @@ function createOutboxActivities(client, config) {
             }
         },
         async spawnProcess(input) {
-            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable } = input;
+            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume } = input;
             // Read secrets from the worker's config closure — never from workflow state
             const { temporalApiKey, temporalTlsCertPath, temporalTlsKeyPath } = config;
             try {
@@ -173,10 +175,12 @@ function createOutboxActivities(client, config) {
                     else if (systemPrompt) {
                         agentFlags = ['--system-prompt', systemPrompt];
                     }
+                    // Use --resume for encore (reconnect to existing session) or -n for new sessions
+                    const nameArgs = resume ? ['--resume', targetName] : ['-n', targetName];
                     const spawnArgs = [
                         '--dangerously-skip-permissions',
                         '--dangerously-load-development-channels', 'server:claude-tempo',
-                        '-n', targetName,
+                        ...nameArgs,
                         ...agentFlags,
                     ];
                     const envVars = {
@@ -195,7 +199,7 @@ function createOutboxActivities(client, config) {
                     if (temporalTlsKeyPath)
                         envVars[config_2.ENV.TEMPORAL_TLS_KEY_PATH] = temporalTlsKeyPath;
                     const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, workDir, envVars);
-                    log(`Spawned claude process (pid ${pid}) in ${workDir} as "${targetName}"`);
+                    log(`Spawned claude process (pid ${pid}) in ${workDir} as "${targetName}" (resume=${!!resume})`);
                 }
                 return { success: true };
             }
@@ -203,5 +207,77 @@ function createOutboxActivities(client, config) {
                 throw activity_1.ApplicationFailure.nonRetryable(`Failed to spawn process for "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
             }
         },
+        async performEncore(input) {
+            const { ensemble, targetPlayerId, fromPlayerId, contextMessageCount = validation_1.ENCORE_DEFAULT_CONTEXT_MESSAGES } = input;
+            try {
+                const handle = await (0, resolve_1.resolveSession)(client, ensemble, targetPlayerId);
+                if (!handle) {
+                    throw activity_1.ApplicationFailure.nonRetryable(`No session found for "${targetPlayerId}"`);
+                }
+                // Atomically transition status from 'stale' to 'pending' — prevents double-spawn races
+                const transitioned = await handle.executeUpdate('checkAndSetStatus', {
+                    args: [{ expectedStatus: 'stale', newStatus: 'pending' }],
+                });
+                if (!transitioned) {
+                    // Read current status for a useful error message
+                    const metadata = await handle.query('getMetadata');
+                    const status = metadata.status;
+                    throw activity_1.ApplicationFailure.nonRetryable(`Cannot encore "${targetPlayerId}" — status is "${status}" (must be "stale"). Another encore may already be in progress.`);
+                }
+                // Query context (status is now locked to 'pending', safe from races)
+                const metadata = await handle.query('getMetadata');
+                const part = await handle.query('getPart');
+                const allMessages = await handle.query('allMessages');
+                // Build context message from recent messages
+                const recentMessages = allMessages.slice(-contextMessageCount);
+                const msgSummary = recentMessages.length > 0
+                    ? recentMessages.map(m => `[${m.from}] ${m.text.slice(0, validation_1.PREVIEW_MAX_LENGTH)}`).join('\n')
+                    : '(no recent messages)';
+                const contextMessage = [
+                    `🎵 **Encore** — you've been revived by ${fromPlayerId}.`,
+                    part ? `Your last status: ${part}` : '',
+                    `Recent messages (last ${recentMessages.length}):`,
+                    msgSummary,
+                    '',
+                    'Resume where you left off. Use `ensemble` to see who is active.',
+                ].filter(Boolean).join('\n');
+                // Inject context message (status already set to pending atomically above)
+                await handle.signal('receiveMessage', { from: fromPlayerId, text: contextMessage });
+                log(`Encore prepared for "${targetPlayerId}" — status reset to pending, context injected`);
+                // Return spawn parameters from the target's metadata
+                const agentType = metadata.agentType || 'claude';
+                const playerType = metadata.playerType;
+                let agentDefinitionPath;
+                let nativeResolvable;
+                if (playerType) {
+                    try {
+                        const info = (0, agent_types_1.resolveAgentType)(playerType);
+                        if (info) {
+                            agentDefinitionPath = info.path;
+                            nativeResolvable = info.nativeResolvable;
+                        }
+                    }
+                    catch {
+                        // Agent type resolution failure is non-fatal
+                    }
+                }
+                return {
+                    workDir: metadata.workDir,
+                    hostname: metadata.hostname,
+                    isConductor: metadata.isConductor,
+                    agent: agentType === 'copilot' ? 'copilot' : 'claude',
+                    agentDefinition: playerType,
+                    agentDefinitionPath,
+                    nativeResolvable,
+                    temporalAddress: config.temporalAddress,
+                    temporalNamespace: config.temporalNamespace,
+                };
+            }
+            catch (err) {
+                if (err instanceof activity_1.ApplicationFailure)
+                    throw err;
+                throw activity_1.ApplicationFailure.nonRetryable(`Encore failed for "${targetPlayerId}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
     };
 }

package/dist/cli/commands.d.ts

@@ -50,6 +50,19 @@ interface AgentTypesCommandOpts {
     name?: string;
 }
 export declare function agentTypesCommand(opts: AgentTypesCommandOpts): Promise<void>;
+interface BroadcastOpts extends CliOverrides {
+    ensemble?: string;
+    message: string;
+    type?: string;
+    includeStale?: boolean;
+}
+export declare function broadcast(opts: BroadcastOpts): Promise<void>;
+interface EncoreOpts extends CliOverrides {
+    name: string;
+    ensemble?: string;
+    host?: string;
+}
+export declare function encore(opts: EncoreOpts): Promise<void>;
 interface EnsembleCommandOpts extends CliOverrides {
     subcommand?: string;
     name?: string;

package/dist/cli/commands.js

@@ -41,6 +41,8 @@ exports.up = up;
 exports.down = down;
 exports.stop = stop;
 exports.agentTypesCommand = agentTypesCommand;
+exports.broadcast = broadcast;
+exports.encore = encore;
 exports.ensembleCommand = ensembleCommand;
 exports.help = help;
 exports.version = version;
@@ -59,6 +61,7 @@ const mcp_1 = require("./mcp");
 const loader_1 = require("../ensemble/loader");
 const saver_1 = require("../ensemble/saver");
 const agent_types_1 = require("../ensemble/agent-types");
+const validation_1 = require("../utils/validation");
 const out = __importStar(require("./output"));
 /** Package root is two levels up from dist/cli/ */
 const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
@@ -1227,6 +1230,178 @@ async function agentTypesCommand(opts) {
             process.exit(1);
     }
 }
+async function broadcast(opts) {
+    const config = (0, config_1.getConfig)(opts);
+    let connection;
+    try {
+        connection = await Promise.race([
+            (0, connection_1.createTemporalConnection)(config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+        ]);
+    }
+    catch {
+        out.error(`Cannot connect to Temporal at ${config.temporalAddress}`);
+        process.exit(1);
+        return;
+    }
+    const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+    const ensemble = opts.ensemble || config.ensemble;
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+    const targets = [];
+    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)
+                continue;
+            // Filter by status
+            if (!(0, validation_1.shouldIncludeInBroadcast)(metadata.status, !!opts.includeStale))
+                continue;
+            // Filter by player type if specified
+            if (opts.type && metadata.playerType !== opts.type)
+                continue;
+            targets.push({ playerId: metadata.playerId, workflowId: wf.workflowId });
+        }
+        catch {
+            // Workflow may have just completed — skip it
+        }
+    }
+    if (targets.length === 0) {
+        out.warn('No active players matched the broadcast filter.');
+        await connection.close();
+        return;
+    }
+    // Signal each target directly (CLI bypasses outbox)
+    let sent = 0;
+    for (const target of targets) {
+        try {
+            const handle = client.workflow.getHandle(target.workflowId);
+            await handle.signal('receiveMessage', {
+                from: 'cli',
+                text: opts.message,
+            });
+            sent++;
+            out.log(`  ${out.green('✓')} ${target.playerId}`);
+        }
+        catch (err) {
+            out.warn(`  ${target.playerId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    out.success(`Broadcast sent to ${sent}/${targets.length} player${targets.length === 1 ? '' : 's'}`);
+    await connection.close();
+}
+async function encore(opts) {
+    if (opts.host) {
+        out.error('Cross-machine encore is not supported via the CLI. Use the MCP `encore` tool with --host instead (it routes through the outbox and per-host task queues).');
+        process.exit(1);
+        return;
+    }
+    const config = (0, config_1.getConfig)(opts);
+    let connection;
+    try {
+        connection = await Promise.race([
+            (0, connection_1.createTemporalConnection)(config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+        ]);
+    }
+    catch {
+        out.error(`Cannot connect to Temporal at ${config.temporalAddress}`);
+        process.exit(1);
+        return;
+    }
+    const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+    const ensemble = opts.ensemble || config.ensemble;
+    // Resolve the target session
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+    let targetHandle = null;
+    let targetMeta = null;
+    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 === opts.name) {
+                targetHandle = handle;
+                targetMeta = metadata;
+                break;
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    if (!targetHandle || !targetMeta) {
+        out.error(`No session found with name "${opts.name}" in ensemble "${ensemble}".`);
+        await connection.close();
+        process.exit(1);
+        return;
+    }
+    const status = targetMeta.status || 'active';
+    if (status !== 'stale') {
+        out.error(`Session "${opts.name}" is ${status}, not stale. Encore only works on stale sessions.`);
+        await connection.close();
+        process.exit(1);
+        return;
+    }
+    // Query context
+    const part = await targetHandle.query('getPart');
+    const allMessages = await targetHandle.query('allMessages');
+    const recentMessages = allMessages.slice(-validation_1.ENCORE_DEFAULT_CONTEXT_MESSAGES);
+    const msgSummary = recentMessages.length > 0
+        ? recentMessages.map(m => `[${m.from}] ${m.text.slice(0, validation_1.PREVIEW_MAX_LENGTH)}`).join('\n')
+        : '(no recent messages)';
+    const contextMessage = [
+        `🎵 **Encore** — you've been revived via CLI.`,
+        part ? `Your last status: ${part}` : '',
+        `Recent messages (last ${recentMessages.length}):`,
+        msgSummary,
+        '',
+        'Resume where you left off. Use `ensemble` to see who is active.',
+    ].filter(Boolean).join('\n');
+    // Reset status and inject context message
+    await targetHandle.signal('updateMetadata', { status: 'pending' });
+    await targetHandle.signal('receiveMessage', { from: 'system', text: contextMessage });
+    out.log(`Reviving "${opts.name}" in ${targetMeta.workDir}...`);
+    // Resolve agent flags
+    let agentFlags = [];
+    if (targetMeta.playerType) {
+        try {
+            const info = (0, agent_types_1.resolveAgentType)(targetMeta.playerType);
+            if (info?.nativeResolvable) {
+                agentFlags = ['--agent', targetMeta.playerType];
+            }
+            else if (info?.path) {
+                agentFlags = ['--system-prompt', info.path];
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    const spawnArgs = [
+        '--dangerously-skip-permissions',
+        '--dangerously-load-development-channels', 'server:claude-tempo',
+        '--resume', opts.name,
+        ...agentFlags,
+    ];
+    const envVars = {
+        [config_1.ENV.ENSEMBLE]: ensemble,
+        [config_1.ENV.CONDUCTOR]: targetMeta.isConductor ? 'true' : '',
+        [config_1.ENV.PLAYER_NAME]: opts.name,
+        [config_1.ENV.TEMPORAL_ADDRESS]: config.temporalAddress,
+        [config_1.ENV.TEMPORAL_NAMESPACE]: config.temporalNamespace,
+    };
+    if (targetMeta.playerType)
+        envVars[config_1.ENV.PLAYER_TYPE] = targetMeta.playerType;
+    if (config.temporalApiKey)
+        envVars[config_1.ENV.TEMPORAL_API_KEY] = config.temporalApiKey;
+    if (config.temporalTlsCertPath)
+        envVars[config_1.ENV.TEMPORAL_TLS_CERT_PATH] = config.temporalTlsCertPath;
+    if (config.temporalTlsKeyPath)
+        envVars[config_1.ENV.TEMPORAL_TLS_KEY_PATH] = config.temporalTlsKeyPath;
+    const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, targetMeta.workDir, envVars);
+    out.success(`Encore! "${opts.name}" revived (pid ${pid})`);
+    await connection.close();
+}
 async function ensembleCommand(opts) {
     switch (opts.subcommand) {
         case 'save': {
@@ -1297,6 +1472,8 @@ ${out.bold('Commands:')}
   ${out.cyan('stop')}    [ensemble]    Stop sessions (-n <name> for one, or --all)
   ${out.cyan('status')}  [ensemble]    Show active sessions and Temporal health
   ${out.cyan('ensemble')} <sub>       Manage saved ensemble lineups (save/list/show)
+  ${out.cyan('broadcast')} <message>   Send a message to all active players
+  ${out.cyan('encore')}   <name>      Revive a stale player session (reconnect with context)
   ${out.cyan('agent-types')} <sub>    Manage player type definitions (list/show/init)
   ${out.cyan('config')}                Configure Temporal connection settings
   ${out.cyan('init')}                  Register MCP server globally (or --project for .mcp.json)

package/dist/cli.js

@@ -51,6 +51,7 @@ function parseArgs(argv) {
         project: false,
         replace: false,
         resume: false,
+        includeStale: false,
     };
     let i = 0;
     while (i < argv.length) {
@@ -103,6 +104,15 @@ function parseArgs(argv) {
         else if (arg === '--ensemble' && i + 1 < argv.length) {
             result.ensemble = argv[++i];
         }
+        else if (arg === '--type' && i + 1 < argv.length) {
+            result.type = argv[++i];
+        }
+        else if (arg === '--include-stale') {
+            result.includeStale = true;
+        }
+        else if (arg === '--host' && i + 1 < argv.length) {
+            result.host = argv[++i];
+        }
         else if (arg === '--agent' && i + 1 < argv.length) {
             const val = argv[++i];
             if (val !== 'claude' && val !== 'copilot') {
@@ -209,6 +219,35 @@ async function main() {
                 ...overrides,
             });
             break;
+        case 'broadcast': {
+            const msg = args.positional.slice(1).join(' ');
+            if (!msg) {
+                out.error('Usage: claude-tempo broadcast <message> [--ensemble <name>] [--type <player-type>] [--include-stale]');
+                process.exit(1);
+            }
+            await (0, commands_1.broadcast)({
+                message: msg,
+                ensemble: args.ensemble || ensemble,
+                type: args.type,
+                includeStale: args.includeStale,
+                ...overrides,
+            });
+            break;
+        }
+        case 'encore': {
+            const encoreName = args.positional[1] || args.name;
+            if (!encoreName) {
+                out.error('Usage: claude-tempo encore <name> [--ensemble <name>] [--host <hostname>]');
+                process.exit(1);
+            }
+            await (0, commands_1.encore)({
+                name: encoreName,
+                ensemble: args.ensemble || ensemble,
+                host: args.host,
+                ...overrides,
+            });
+            break;
+        }
         case 'ensemble':
             await (0, commands_1.ensembleCommand)({
                 subcommand: args.positional[1],

package/dist/server.js

@@ -61,6 +61,9 @@ const save_lineup_1 = require("./tools/save-lineup");
 const load_lineup_1 = require("./tools/load-lineup");
 const agent_types_1 = require("./tools/agent-types");
 const who_am_i_1 = require("./tools/who-am-i");
+const broadcast_1 = require("./tools/broadcast");
+const recall_1 = require("./tools/recall");
+const encore_1 = require("./tools/encore");
 const channel_1 = require("./channel");
 const agent_types_2 = require("./ensemble/agent-types");
 const log = (...args) => console.error('[claude-tempo]', ...args);
@@ -273,6 +276,9 @@ async function main() {
     (0, load_lineup_1.registerLoadLineupTool)(mcpServer, client, config, getPlayerId, isBridgeMode ? 'copilot' : 'claude');
     (0, agent_types_1.registerAgentTypesTool)(mcpServer);
     (0, who_am_i_1.registerWhoAmITool)(mcpServer, handle, getPlayerId);
+    (0, broadcast_1.registerBroadcastTool)(mcpServer, client, config, getPlayerId, handle);
+    (0, recall_1.registerRecallTool)(mcpServer, handle, getPlayerId);
+    (0, encore_1.registerEncoreTool)(mcpServer, client, config, getPlayerId, handle);
     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

package/dist/tools/broadcast.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client, WorkflowHandle } from '@temporalio/client';
+import { Config } from '../config';
+export declare function registerBroadcastTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle): void;

package/dist/tools/broadcast.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBroadcastTool = registerBroadcastTool;
+const zod_1 = require("zod");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerBroadcastTool(server, client, config, getPlayerId, handle) {
+    (0, helpers_1.defineTool)(server, 'broadcast', 'Send a message to all active players in the ensemble. Optionally filter by player type.', {
+        message: zod_1.z.string().max(validation_1.MESSAGE_MAX).describe('The message to broadcast'),
+        type: zod_1.z.string().optional().describe('Only send to players of this type (e.g., "tempo-soloist")'),
+        includeStale: zod_1.z.boolean().optional().describe('Include stale sessions (default: false)'),
+    }, async (args) => {
+        const { message, type: playerType, includeStale: rawIncludeStale } = args;
+        const includeStale = rawIncludeStale === true;
+        try {
+            const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+            const targets = [];
+            for await (const workflow of client.workflow.list({ query })) {
+                try {
+                    const wfHandle = client.workflow.getHandle(workflow.workflowId);
+                    const metadata = await wfHandle.query('getMetadata');
+                    // Filter by ensemble
+                    if (metadata.ensemble !== config.ensemble)
+                        continue;
+                    // Exclude sender
+                    if (metadata.playerId === getPlayerId())
+                        continue;
+                    // Filter by status
+                    if (!(0, validation_1.shouldIncludeInBroadcast)(metadata.status, includeStale))
+                        continue;
+                    // Filter by player type if specified
+                    if (playerType && metadata.playerType !== playerType)
+                        continue;
+                    targets.push({
+                        playerId: metadata.playerId,
+                        playerType: metadata.playerType,
+                    });
+                }
+                catch {
+                    // Workflow may have just completed — skip it
+                }
+            }
+            if (targets.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'No active players matched the broadcast filter.',
+                        }],
+                };
+            }
+            // Fan out cue outbox entries for each target
+            const entryIds = [];
+            for (const target of targets) {
+                const entry = {
+                    type: 'cue',
+                    targetPlayerId: target.playerId,
+                    message,
+                };
+                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                entryIds.push(entryId);
+            }
+            const names = targets.map((t) => t.playerId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Broadcast sent to ${targets.length} player${targets.length === 1 ? '' : 's'}: ${names.join(', ')}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to broadcast: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/encore.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client, WorkflowHandle } from '@temporalio/client';
+import { Config } from '../config';
+export declare function registerEncoreTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle): void;