claude-tempo 0.23.0 → 0.24.0

package/CLAUDE.md

@@ -78,6 +78,9 @@ src/
 │   ├── stage.ts       # Define a stage — fan-out/fan-in tracking for parallel tasks (conductor only)
 │   ├── stages.ts      # List stages and their status (conductor only)
 │   ├── cancel-stage.ts # Cancel an active stage (conductor only)
+│   ├── release.ts     # Release held players (unlock outbox + deliver deferred messages)
+│   ├── pause-ensemble.ts # Pause all sessions and the scheduler ensemble-wide
+│   ├── resume-ensemble.ts # Resume a paused ensemble
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
 ├── tui/
 │   ├── index.ts       # TUI entry point — connects to Temporal and renders the Ink app
@@ -173,9 +176,12 @@ npm test
 - **Quality Gate**: A named checklist of criteria a conductor tracks to verify a task is complete. Created via `quality_gate` (conductor only), evaluated via `evaluate_gate`, and listed via `gates`. Each criterion has a `pending` → `passed` | `failed` status; the gate's aggregate status is derived automatically (all passed → `passed`, any failed → `failed`, else `open`). Gates are stored in the conductor workflow and survive `continueAsNew`.
 - **Worktree**: A git worktree provisioned by the conductor for a player, giving them an isolated checkout on a separate branch. Managed via the `worktree` tool (conductor only): `create` provisions the worktree and notifies the player, `remove` cleans up after the task, `list` shows all active worktrees. Worktree assignments are stored in the conductor workflow (`WorktreeEntry` records: player, path, branch, gitRoot, createdAt, createdBy).
 - **Stage**: A fan-out/fan-in tracking primitive for the conductor. Created via `stage` (conductor only), listing via `stages`, cancelled via `cancel_stage`. Each stage tracks a set of players; when a tracked player sends a `report`, their stage status updates automatically (`waiting` → `reported` or `blocked`). When all players have reported, the conductor is notified that the stage is complete. If `failurePolicy` is `'halt'` (default), a blocker from any player fails the entire stage. Stages are stored in the conductor workflow and survive `continueAsNew`.
+- **Hold / Release**: Controlled ensemble startup mechanism. `load_lineup(hold: true)` spawns all players with locked outboxes and a standby message ("waiting for release") instead of their real task. When ready, the conductor calls `release` (MCP tool or `claude-tempo release` CLI) to unlock outboxes and deliver the actual task messages. Use case: pre-warm a full team before kicking off a long job.
+- **Pause / Resume**: Ensemble-wide mid-session flow control. `pause_ensemble` locks all session outboxes and signals the scheduler to skip fires; `resume_ensemble` reverses both. `stop` outbox entries bypass the pause lock and are always dispatched. Pause state is owned by the per-ensemble Maestro (`maestroSetPaused` signal) and synced to sessions and the scheduler.
+- **Outbox lock**: A workflow-level flag on each session that gates outbox dispatch independently of pause. Used by the hold mechanism (`outboxLocked` query, `releaseHeld` signal) and the pause mechanism (`setPaused` signal, `paused` query). The two flags are independent — a session can be held (locked) but not paused, or paused but not locked.
 - **Maestro**: Two Maestro workflow variants exist. The **per-ensemble** `claudeMaestroWorkflow` (ID: `claude-maestro-{ensemble}`) monitors a single ensemble — maintains a player snapshot, ring-buffer event log (max 200 entries), an aggregated ensemble chat cache (max 500 entries, refreshed every ~10s via `fetchEnsembleChat` activity), and queues commands for relay to the conductor via `maestroSendCommand`. The ensemble chat cache merges maestro + conductor traffic and is served via the `maestroEnsembleChat` query. The **global** `claudeGlobalMaestroWorkflow` (ID: `claude-maestro-global`) spans all ensembles — aggregates players by ensemble, maintains a cross-ensemble message ring buffer (max 500 entries), and exposes on-demand player/conductor history via `maestroFetchPlayerMessages` and `maestroFetchConductorHistory` updates. Both are implemented in `src/workflows/maestro.ts` with activities in `src/activities/maestro.ts`.
 - **TempoClient**: The API layer for querying ensemble state (`src/client/`). The interface and types live in `interface.ts`; the factory implementation lives in `index.ts`. Provides `discoverEnsembles`, `getPlayers`, `getMessages`, `getConductorHistory`, `sendMessage`, `sendCommand`, `getEnsembleChat`, `getGates`, `getStages`, `getWorktrees`, and `terminatePlayer`. Uses Global Maestro as the primary source with graceful fallback to per-ensemble Maestro and direct workflow list queries. `src/tui/client.ts` is a thin re-export shim for backward compatibility — new consumers should import from `src/client/` directly.
-- **Wire protocol**: All Temporal signal, query, update, and workflow names are documented in [`docs/WIRE-PROTOCOL.md`](docs/WIRE-PROTOCOL.md). These names are stable as of v0.10 — renaming or removing any is a breaking change requiring a major version bump.
+- **Wire protocol**: All Temporal signal, query, update, and workflow names are documented in [`docs/WIRE-PROTOCOL.md`](docs/WIRE-PROTOCOL.md). These names are stable as of v0.10 — renaming or removing any is a breaking change requiring a major version bump. **Process**: when adding signals, queries, or updates to any workflow file (`signals.ts`, `scheduler-signals.ts`, `maestro-signals.ts`), update `docs/WIRE-PROTOCOL.md` in the same commit.
 - **Daemon**: A standalone background process (`src/daemon.ts`) that runs all Temporal workers. Auto-started by any claude-tempo command if not already running. PID stored at `~/.claude-tempo/daemon.pid`; logs at `~/.claude-tempo/daemon.log`. Sessions are now pure MCP clients — they no longer run in-process workers. Managed via `claude-tempo daemon start|stop|status|logs`.
 
 ## TUI Key Behaviors

package/README.md

@@ -36,6 +36,7 @@ Each session registers as a **player** in Temporal. Players discover each other
 | 🎭 **Player Types** | Reusable agent definitions with 8 shipped types and three-tier lookup |
 | 🖥️ **Terminal UI** | Chat-focused TUI with slash commands, overlays, and interactive wizards |
 | 🌐 **Cross-machine** | Any session that can reach your Temporal server can join the ensemble |
+| ⏸️ **Hold / Pause / Resume** | Pre-warm a full team before delivering tasks; pause and resume mid-session |
 | 🤖 **Copilot bridge** | Mix Claude Code and GitHub Copilot CLI sessions in the same ensemble |
 
 ## Installation
@@ -142,6 +143,9 @@ claude-tempo up [ensemble]      # first-time setup
 claude-tempo conduct [ensemble] # start a conductor
 claude-tempo start [ensemble]   # start a player
 claude-tempo status [ensemble]  # list active sessions
+claude-tempo release [ensemble] # release held players (unlock + deliver tasks)
+claude-tempo pause [ensemble]   # pause all sessions and the scheduler
+claude-tempo resume [ensemble]  # resume a paused ensemble
 claude-tempo tui                # open the terminal UI
 claude-tempo daemon <sub>       # manage the worker daemon
 claude-tempo upgrade            # update to latest
@@ -233,7 +237,7 @@ claude-tempo tui --ensemble my-ensemble   # direct ensemble mode
 The TUI provides a chat-focused shell for managing your ensemble:
 
 - **Ensemble chat feed** — live aggregated view of conductor + player traffic; type bare text to message the conductor, `@player message` to message directly
-- **Slash commands** — `/recruit`, `/status`, `/schedule`, `/gates`, `/stages`, `/worktree`, and more; type `/help` for the full list
+- **Slash commands** — `/recruit`, `/status`, `/schedule`, `/gates`, `/stages`, `/worktree`, `/go` (release held), `/pause`, `/resume`, and more; type `/help` for the full list
 - **Interactive overlays and wizards** — step-by-step flows for recruiting players, creating schedules, and managing ensembles
 
 📖 [TUI reference → docs/dashboard.md](docs/dashboard.md)

package/dist/activities/outbox.d.ts

@@ -33,6 +33,12 @@ export interface StartRecruitedSessionInput {
     allowedTools?: string[];
     /** Custom claude binary path (from config.claudeBin). */
     claudeBin?: string;
+    /** When true, spawn process but lock outbox and defer initial message until release (warm hold). */
+    held?: boolean;
+}
+export interface ReleasePlayerInput {
+    ensemble: string;
+    targetPlayerId: string;
 }
 export interface SpawnProcessInput {
     targetName: string;
@@ -92,6 +98,7 @@ export interface OutboxActivities {
     startRecruitedSession(input: StartRecruitedSessionInput): Promise<RecruitResult>;
     spawnProcess(input: SpawnProcessInput): Promise<OutboxActivityResult>;
     performEncore(input: PerformEncoreInput): Promise<EncoreResult>;
+    releasePlayer(input: ReleasePlayerInput): Promise<OutboxActivityResult>;
 }
 /**
  * Create outbox delivery activities bound to a Temporal client and config.

package/dist/activities/outbox.js

@@ -101,7 +101,7 @@ function createOutboxActivities(client, config) {
             return { success: true };
         },
         async startRecruitedSession(input) {
-            const { ensemble, targetName, workDir, isConductor, initialMessage, fromPlayerId, agent, systemPrompt, taskQueue, agentDefinition, agentDefinitionDescription } = input;
+            const { ensemble, targetName, workDir, isConductor, initialMessage, fromPlayerId, agent, systemPrompt, taskQueue, agentDefinition, agentDefinitionDescription, held } = input;
             try {
                 const workflowId = isConductor
                     ? (0, config_1.conductorWorkflowId)(ensemble)
@@ -109,6 +109,11 @@ function createOutboxActivities(client, config) {
                 const { gitRoot, gitBranch } = (0, git_info_1.getGitInfo)(workDir);
                 // Generate a UUID for the session — used for deterministic --resume on encore
                 const sessionId = crypto.randomUUID();
+                // Warm hold: process will spawn and go active, but outbox is locked and
+                // the initial message is deferred. A standby message is sent instead.
+                const standbyMessage = held
+                    ? 'You are on standby. Your ensemble is loading — other players are still connecting. Wait for your task assignment. Do not start work or send messages yet.'
+                    : undefined;
                 const sessionInput = {
                     metadata: {
                         playerId: targetName,
@@ -127,15 +132,23 @@ function createOutboxActivities(client, config) {
                     },
                     autoSummary: `Session in ${path.basename(workDir)}`,
                     disableStaleDetection: true,
-                    ...(initialMessage ? {
-                        messages: [{
+                    // When held: store the initial message for delivery on release, inject standby message instead
+                    ...(held ? { outboxLocked: true, heldMessage: initialMessage } : {}),
+                    messages: held
+                        ? [{
+                                id: crypto.randomUUID(),
+                                from: 'system',
+                                text: standbyMessage,
+                                timestamp: new Date().toISOString(),
+                                delivered: false,
+                            }]
+                        : (initialMessage ? [{
                                 id: crypto.randomUUID(),
                                 from: fromPlayerId,
                                 text: initialMessage,
                                 timestamp: new Date().toISOString(),
                                 delivered: false,
-                            }],
-                    } : {}),
+                            }] : undefined),
                 };
                 await client.workflow.start('claudeSessionWorkflow', {
                     workflowId,
@@ -149,7 +162,7 @@ function createOutboxActivities(client, config) {
                         ClaudeTempoPlayerId: [targetName],
                     },
                 });
-                log(`Pre-created workflow ${workflowId} for recruit "${targetName}" (sessionId=${sessionId})`);
+                log(`Pre-created workflow ${workflowId} for recruit "${targetName}" (sessionId=${sessionId}, held=${!!held})`);
                 return { success: true, sessionId };
             }
             catch (err) {
@@ -309,5 +322,28 @@ function createOutboxActivities(client, config) {
                 throw activity_1.ApplicationFailure.nonRetryable(`Encore failed for "${targetPlayerId}": ${err instanceof Error ? err.message : String(err)}`);
             }
         },
+        async releasePlayer(input) {
+            const { ensemble, targetPlayerId } = input;
+            try {
+                const handle = await (0, resolve_1.resolveSession)(client, ensemble, targetPlayerId);
+                if (!handle) {
+                    throw activity_1.ApplicationFailure.nonRetryable(`No session found for "${targetPlayerId}"`);
+                }
+                // Check if the session is actually held (outbox locked)
+                const isLocked = await handle.query('outboxLocked');
+                if (!isLocked) {
+                    throw activity_1.ApplicationFailure.nonRetryable(`Cannot release "${targetPlayerId}" — session is not held (outbox not locked).`);
+                }
+                // Signal the session to release — unlocks outbox and delivers held message
+                await handle.signal('releaseHeld');
+                log(`Released held session "${targetPlayerId}"`);
+                return { success: true };
+            }
+            catch (err) {
+                if (err instanceof activity_1.ApplicationFailure)
+                    throw err;
+                throw activity_1.ApplicationFailure.nonRetryable(`Release failed for "${targetPlayerId}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
     };
 }

package/dist/cli/commands.d.ts

@@ -77,6 +77,18 @@ interface DaemonOpts extends CliOverrides {
     subcommand?: string;
 }
 export declare function daemon(opts: DaemonOpts): Promise<void>;
+interface ReleaseOpts extends CliOverrides {
+    ensemble: string;
+}
+/** Release all held sessions in an ensemble (unlock outbox, deliver initial messages). */
+export declare function release(opts: ReleaseOpts): Promise<void>;
+interface PauseResumeOpts extends CliOverrides {
+    ensemble: string;
+}
+/** Pause an entire ensemble — sessions, scheduler, and maestro. */
+export declare function pause(opts: PauseResumeOpts): Promise<void>;
+/** Resume an entire ensemble — sessions, scheduler, and maestro. */
+export declare function resume(opts: PauseResumeOpts): Promise<void>;
 export declare function help(): void;
 export declare function version(): void;
 interface UpgradeOpts extends CliOverrides {

package/dist/cli/commands.js

@@ -45,6 +45,9 @@ exports.broadcast = broadcast;
 exports.encore = encore;
 exports.ensembleCommand = ensembleCommand;
 exports.daemon = daemon;
+exports.release = release;
+exports.pause = pause;
+exports.resume = resume;
 exports.help = help;
 exports.version = version;
 exports.upgrade = upgrade;
@@ -61,6 +64,7 @@ const git_info_1 = require("../git-info");
 const connection_1 = require("../connection");
 const signals_1 = require("../workflows/signals");
 const scheduler_signals_1 = require("../workflows/scheduler-signals");
+const maestro_signals_1 = require("../workflows/maestro-signals");
 const preflight_1 = require("./preflight");
 const mcp_1 = require("./mcp");
 const loader_1 = require("../ensemble/loader");
@@ -1943,6 +1947,123 @@ async function daemon(opts) {
             process.exit(1);
     }
 }
+/** Release all held sessions in an ensemble (unlock outbox, deliver initial messages). */
+async function release(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 query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${opts.ensemble.replace(/["\\\n\r]/g, '')}"`;
+    let released = 0;
+    for await (const wf of client.workflow.list({ query })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const locked = await handle.query(signals_1.outboxLockedQuery);
+            if (locked) {
+                await handle.signal(signals_1.releaseHeldSignal);
+                released++;
+                const sa = wf.searchAttributes || {};
+                const playerId = Array.isArray(sa.ClaudeTempoPlayerId) ? String(sa.ClaudeTempoPlayerId[0]) : wf.workflowId;
+                out.log(`  ${out.dim('released')} ${playerId}`);
+            }
+        }
+        catch {
+            // Skip failed queries (terminated workflows, etc.)
+        }
+    }
+    if (released > 0) {
+        out.success(`Released ${released} player${released !== 1 ? 's' : ''}`);
+    }
+    else {
+        out.log('No held players found.');
+    }
+    await connection.close();
+}
+/** Pause an entire ensemble — sessions, scheduler, and maestro. */
+async function pause(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 });
+    await setPausedState(client, opts.ensemble, true);
+    out.success(`Ensemble "${opts.ensemble}" paused`);
+    await connection.close();
+}
+/** Resume an entire ensemble — sessions, scheduler, and maestro. */
+async function resume(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 });
+    await setPausedState(client, opts.ensemble, false);
+    out.success(`Ensemble "${opts.ensemble}" resumed`);
+    await connection.close();
+}
+/** Shared logic: set paused state across all ensemble components. */
+async function setPausedState(client, ensemble, paused) {
+    // 1. Signal maestro hub
+    try {
+        const mh = client.workflow.getHandle((0, config_1.maestroWorkflowId)(ensemble));
+        await mh.signal(maestro_signals_1.maestroSetPausedSignal, paused);
+    }
+    catch {
+        // Maestro may not be running — non-critical
+    }
+    // 2. Signal all active sessions
+    const sanitized = ensemble.replace(/["\\\n\r]/g, '');
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${sanitized}"`;
+    let count = 0;
+    for await (const wf of client.workflow.list({ query })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            await handle.signal(signals_1.setPausedSignal, paused);
+            count++;
+        }
+        catch {
+            // Skip failed signals
+        }
+    }
+    out.log(`  ${out.dim(paused ? 'paused' : 'resumed')} ${count} session${count !== 1 ? 's' : ''}`);
+    // 3. Signal scheduler
+    try {
+        const sh = client.workflow.getHandle((0, config_1.schedulerWorkflowId)(ensemble));
+        await sh.signal(scheduler_signals_1.setSchedulerPausedSignal, paused);
+        out.log(`  ${out.dim(paused ? 'paused' : 'resumed')} scheduler`);
+    }
+    catch {
+        // Scheduler may not be running — non-critical
+    }
+}
 function help() {
     console.log(`
 ${out.bold('claude-tempo')} — Multi-session Claude Code coordination via Temporal
@@ -1964,6 +2085,9 @@ ${out.bold('Commands:')}
   ${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('release')} [ensemble]   Release all held players (unlock outbox, deliver messages)
+  ${out.cyan('pause')}   [ensemble]   Pause an ensemble (sessions, scheduler, maestro)
+  ${out.cyan('resume')}  [ensemble]   Resume a paused ensemble
   ${out.cyan('agent-types')} <sub>    Manage player type definitions (list/show/init)
   ${out.cyan('daemon')}    <sub>       Manage the worker daemon (start/stop/status/logs)
   ${out.cyan('upgrade')}  [version]    Upgrade claude-tempo to latest (or specific version)

package/dist/cli.js

@@ -260,6 +260,24 @@ async function main() {
             });
             break;
         }
+        case 'release':
+            await (0, commands_1.release)({
+                ensemble: args.ensemble || ensemble,
+                ...overrides,
+            });
+            break;
+        case 'pause':
+            await (0, commands_1.pause)({
+                ensemble: args.ensemble || ensemble,
+                ...overrides,
+            });
+            break;
+        case 'resume':
+            await (0, commands_1.resume)({
+                ensemble: args.ensemble || ensemble,
+                ...overrides,
+            });
+            break;
         case 'ensemble':
             await (0, commands_1.ensembleCommand)({
                 subcommand: args.positional[1],

package/dist/server.js

@@ -64,6 +64,9 @@ 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 release_1 = require("./tools/release");
+const pause_ensemble_1 = require("./tools/pause-ensemble");
+const resume_ensemble_1 = require("./tools/resume-ensemble");
 const quality_gate_1 = require("./tools/quality-gate");
 const evaluate_gate_1 = require("./tools/evaluate-gate");
 const gates_1 = require("./tools/gates");
@@ -233,6 +236,18 @@ async function main() {
             // No conductor running — that's fine
         }
     }
+    // If ensemble is paused, inherit the paused state
+    try {
+        const maestroHandle = client.workflow.getHandle((0, config_1.maestroWorkflowId)(config.ensemble));
+        const isPaused = await maestroHandle.query('maestroPaused');
+        if (isPaused) {
+            await handle.signal('setPaused', true);
+            log('Ensemble is paused — session started in paused state');
+        }
+    }
+    catch {
+        // Maestro may not be running — that's fine
+    }
     // Create MCP server
     const hasRequestedName = isConductor || Boolean(requestedName && requestedName !== 'conductor');
     const playerTypeLine = playerType
@@ -283,6 +298,9 @@ async function main() {
     (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);
+    (0, release_1.registerReleaseTool)(mcpServer, client, config, getPlayerId, handle);
+    (0, pause_ensemble_1.registerPauseEnsembleTool)(mcpServer, client, config, getPlayerId);
+    (0, resume_ensemble_1.registerResumeEnsembleTool)(mcpServer, client, config, getPlayerId);
     // Conductor-only tools
     if (isConductor) {
         (0, quality_gate_1.registerQualityGateTool)(mcpServer, handle, getPlayerId);

package/dist/tools/load-lineup.js

@@ -18,9 +18,11 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
     (0, helpers_1.defineTool)(server, 'load_lineup', 'Load an ensemble lineup — recruits players and creates schedules.', {
         name: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Name of a lineup — resolves saved lineups, then shipped examples (e.g. "tempo-dev-team")'),
         path: zod_1.z.string().max(validation_1.PATH_MAX).optional().describe('Explicit file path to a lineup YAML file'),
+        hold: zod_1.z.boolean().optional().describe('When true, create player workflows but do not spawn processes. Players stay in "held" status until explicitly released.'),
     }, async (args) => {
         const lineupName = args.name;
         const lineupPath = args.path;
+        const hold = args.hold === true;
         if (!lineupName && !lineupPath) {
             return (0, helpers_1.fail)('Provide either `name` (saved lineup) or `path` (file path). Exactly one is required.');
         }
@@ -106,6 +108,22 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                     }
                 }
             }
+            // When hold mode: tell conductor to wait for user direction.
+            // This runs regardless of whether the lineup has a `conductor:` section —
+            // what matters is that the caller IS the conductor and hold is active.
+            if (hold && isConductor && handle) {
+                try {
+                    await handle.signal('receiveMessage', {
+                        from: 'system',
+                        text: 'Ensemble is loading in hold mode — players are connecting but on standby. Wait for instructions from the user or maestro before directing the ensemble. When ready, use the `release` tool to deliver task assignments to all held players.',
+                        responseRequested: false,
+                    });
+                    conductorActions.push('hold mode standby');
+                }
+                catch (err) {
+                    failed.push(`conductor hold message: ${err}`);
+                }
+            }
             // Recruit players via outbox — no polling needed
             for (const player of lineup.players) {
                 const playerName = player.name;
@@ -157,6 +175,7 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                         nativeResolvable: resolvedType?.nativeResolvable,
                         allowedTools: player.allowedTools,
                         claudeBin: config.claudeBin,
+                        ...(hold ? { held: true } : {}),
                     };
                     await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
                     recruited.push(playerName);
@@ -265,7 +284,12 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                 lines.push(`Conductor: ${conductorActions.join(', ')}`);
             }
             if (recruited.length > 0) {
-                lines.push(`Recruited: ${recruited.join(', ')}`);
+                if (hold) {
+                    lines.push(`Held: ${recruited.join(', ')} — ${recruited.length} player(s) held. Use \`release\` to start them.`);
+                }
+                else {
+                    lines.push(`Recruited: ${recruited.join(', ')}`);
+                }
             }
             if (schedulesCreated.length > 0) {
                 lines.push(`Schedules created: ${schedulesCreated.join(', ')}`);

package/dist/tools/pause-ensemble.d.ts

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

package/dist/tools/pause-ensemble.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPauseEnsembleTool = registerPauseEnsembleTool;
+const config_1 = require("../config");
+const resolve_1 = require("../activities/resolve");
+const helpers_1 = require("./helpers");
+const log = (...args) => console.error('[claude-tempo:pause]', ...args);
+function registerPauseEnsembleTool(server, client, config, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'pause_ensemble', 'Pause all sessions in the ensemble — locks outbox dispatch and pauses the scheduler. Stop commands still go through. Use resume_ensemble to unpause.', {}, async () => {
+        try {
+            const results = [];
+            const errors = [];
+            // 1. Signal maestro with paused state (ground truth)
+            try {
+                const maestroId = (0, config_1.maestroWorkflowId)(config.ensemble);
+                const maestroHandle = client.workflow.getHandle(maestroId);
+                await maestroHandle.signal('maestroSetPaused', true);
+                results.push('maestro paused');
+            }
+            catch {
+                // Maestro may not be running
+            }
+            // 2. Signal all active sessions
+            const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
+            let sessionCount = 0;
+            for (const session of sessions) {
+                try {
+                    const sessionHandle = client.workflow.getHandle(session.workflowId);
+                    await sessionHandle.signal('setPaused', true);
+                    sessionCount++;
+                }
+                catch (err) {
+                    errors.push(`${session.playerId}: ${(0, helpers_1.formatError)(err)}`);
+                }
+            }
+            results.push(`${sessionCount} session(s) paused`);
+            // 3. Signal scheduler
+            try {
+                const schedulerId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+                const schedulerHandle = client.workflow.getHandle(schedulerId);
+                await schedulerHandle.signal('setSchedulerPaused', true);
+                results.push('scheduler paused');
+            }
+            catch {
+                // Scheduler may not be running
+            }
+            const lines = [`Ensemble **${config.ensemble}** paused.`, results.join(', ')];
+            if (errors.length > 0) {
+                lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+            }
+            log(`Paused ensemble "${config.ensemble}" by ${getPlayerId()}`);
+            return (0, helpers_1.ok)(lines.join('\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to pause ensemble: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/release.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 registerReleaseTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle): void;

package/dist/tools/release.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerReleaseTool = registerReleaseTool;
+const zod_1 = require("zod");
+const resolve_1 = require("../activities/resolve");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerReleaseTool(server, client, config, getPlayerId, handle) {
+    (0, helpers_1.defineTool)(server, 'release', 'Release held player sessions — unlocks their outboxes and delivers deferred task messages. Without a player name, releases all held sessions.', {
+        player: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional()
+            .describe('Name of a specific held player to release. Omit to release all held players.'),
+    }, async (args) => {
+        const { player } = args;
+        if (player) {
+            const nameError = (0, validation_1.validatePlayerName)(player);
+            if (nameError)
+                return (0, helpers_1.fail)(nameError);
+        }
+        try {
+            if (player) {
+                // Release a specific player
+                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
+                const target = sessions.find((s) => s.playerId === player);
+                if (!target) {
+                    return (0, helpers_1.fail)(`No session found with name "${player}".`);
+                }
+                // Check if the session's outbox is actually locked
+                const targetHandle = client.workflow.getHandle(target.workflowId);
+                let isLocked = false;
+                try {
+                    isLocked = await targetHandle.query(signals_1.outboxLockedQuery);
+                }
+                catch {
+                    // Query may fail for old workflows without the handler — not held
+                }
+                if (!isLocked) {
+                    return (0, helpers_1.fail)(`Session "${player}" is not held (outbox not locked). Only held sessions can be released.`);
+                }
+                const entry = {
+                    type: 'release',
+                    targetPlayerId: player,
+                };
+                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                return (0, helpers_1.ok)(`Release request submitted for **${player}**. Task assignment will be delivered shortly. (outbox: ${entryId})`);
+            }
+            else {
+                // Release all held players — scan ensemble and check outboxLocked on each
+                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
+                const heldSessions = [];
+                for (const session of sessions) {
+                    // Skip self and conductors (conductor outbox is never locked)
+                    if (session.playerId === getPlayerId())
+                        continue;
+                    try {
+                        const sessionHandle = client.workflow.getHandle(session.workflowId);
+                        const isLocked = await sessionHandle.query(signals_1.outboxLockedQuery);
+                        if (isLocked) {
+                            heldSessions.push(session);
+                        }
+                    }
+                    catch {
+                        // Skip sessions where query fails (old workflows, terminated, etc.)
+                    }
+                }
+                if (heldSessions.length === 0) {
+                    return (0, helpers_1.ok)('No held sessions found. Nothing to release.');
+                }
+                const released = [];
+                const errors = [];
+                for (const session of heldSessions) {
+                    try {
+                        const entry = {
+                            type: 'release',
+                            targetPlayerId: session.playerId,
+                        };
+                        await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                        released.push(session.playerId);
+                    }
+                    catch (err) {
+                        errors.push(`${session.playerId}: ${(0, helpers_1.formatError)(err)}`);
+                    }
+                }
+                const lines = [];
+                if (released.length > 0) {
+                    lines.push(`Released ${released.length} player(s): ${released.join(', ')}`);
+                }
+                if (errors.length > 0) {
+                    lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+                }
+                return (0, helpers_1.ok)(lines.join('\n'));
+            }
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to release: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/resume-ensemble.d.ts

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