claude-tempo 0.6.0 → 0.8.0

package/CLAUDE.md

@@ -30,10 +30,11 @@ src/
 │   ├── listen.ts      # Manual message check
 │   ├── recruit.ts     # Spawn new session
 │   ├── report.ts      # Report to conductor
-│   ├── terminate.ts   # Terminate a session
+│   ├── stop.ts        # Stop a session
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
 ├── types.ts           # Shared type definitions
 ├── channel.ts         # Claude channel notification helper
+├── git-info.ts        # Git repository detection helper
 └── config.ts          # Env var handling
 ```
 
@@ -66,8 +67,9 @@ npm test
 - **Ensemble**: The set of all active players, namespaced by `CLAUDE_TEMPO_ENSEMBLE`
 - **Cue**: A message sent to a player by name via Temporal signal
 - **Part**: A player's description of what it's working on
-- **Recruit**: Spawning a new Claude Code session as a player
+- **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.
 
 ## Dashboard
 

package/README.md

@@ -1,6 +1,13 @@
-# claude-tempo
-
-Multi-session [Claude Code](https://claude.ai/code) coordination via [Temporal](https://temporal.io).
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="assets/logo-light.svg">
+    <img alt="claude-tempo" src="assets/logo-light.svg" height="140">
+  </picture>
+</p>
+<p align="center">
+  Multi-session <a href="https://claude.ai/code">Claude Code</a> coordination via <a href="https://temporal.io">Temporal</a>.
+</p>
 
 Multiple Claude Code sessions discover each other, exchange messages in real time, and coordinate work — across machines, not just localhost.
 
@@ -91,7 +98,7 @@ claude-tempo <command> [options]
 
 | Command | Description |
 |---------|-------------|
-| `up [ensemble]` | First-time setup: start Temporal, configure MCP, launch conductor |
+| `up [ensemble]` | First-time setup: start Temporal, configure MCP, launch conductor. Use `--from` to load a blueprint. |
 | `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). Use `--resume` or `--replace` if one exists. |
@@ -101,6 +108,7 @@ claude-tempo <command> [options]
 | `stop [ensemble]` | Stop sessions (`-n <name>` for one, `--all` for everything) |
 | `init` | Register claude-tempo MCP server globally (`--project` for per-directory) |
 | `preflight` | Run environment checks |
+| `ensemble <sub>` | Manage saved blueprints (`save`, `list`, `show`) |
 | `help` | Show usage info |
 
 ### Global options
@@ -115,6 +123,7 @@ 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)
+--from <file>                 Load an ensemble blueprint on startup (up only)
 --resume                      Resume an existing conductor session (conduct only)
 --replace                     Stop existing conductor and start fresh (conduct only)
 ```
@@ -172,7 +181,7 @@ Ensemble: myband
     Building the REST endpoints
     /Users/me/projects/app  feat/api  my-machine.local
 
-  bob
+  bob (pending)
     Working on the dashboard
     /Users/me/projects/app  feat/ui  my-machine.local
 
@@ -208,10 +217,12 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `listen` | Manually check for pending messages. |
 | `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. |
+| `stop` | Stop 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. |
+| `save_ensemble` | Save the current ensemble as a YAML blueprint (conductor only). |
+| `load_ensemble` | Load a blueprint to recruit players and create schedules. |
 
 ## Scheduling
 
@@ -244,6 +255,80 @@ Schedules support one-shot delays, fixed times, and recurring intervals with opt
 - `claude-tempo status` shows active schedules alongside sessions
 - A single durable scheduler workflow per ensemble manages all schedules using Temporal timers
 
+## Ensemble Blueprints
+
+Define reusable ensemble configurations as YAML files. A blueprint specifies which players to recruit, what instructions to give them, what schedules to create, and optionally which custom agent files to use.
+
+### Example blueprint
+
+```yaml
+name: my-project
+conductor:
+  instructions: "Coordinate the frontend and backend teams"
+players:
+  - name: frontend
+    workDir: /repos/my-app
+    instructions: "Build the React dashboard in src/components"
+  - name: backend
+    workDir: /repos/my-api
+    instructions: "Implement the REST endpoints in src/routes"
+  - name: ops
+    workDir: /repos/infra
+    agent: agents/ops-agent.md
+    instructions: "Monitor deployments and run health checks"
+schedules:
+  - name: status-check
+    message: "Report your current progress and any blockers"
+    target: all
+    every: 30m
+  - name: deploy-reminder
+    message: "Check if the staging deploy succeeded"
+    target: ops
+    delay: 10m
+```
+
+### Three ways to use blueprints
+
+1. **From the CLI** — load a blueprint when starting an ensemble:
+
+   ```bash
+   claude-tempo up --from my-blueprint.yaml
+   ```
+
+2. **From inside a session** — use the `load_ensemble` tool:
+
+   *"Load the blueprint from ~/.claude-tempo/ensembles/my-project.yaml"*
+
+3. **Save the current state** — snapshot a running ensemble as a blueprint (conductor only):
+
+   *"Save this ensemble as a blueprint called my-project"*
+
+### Natural language examples
+
+Tell your session things like:
+
+- *"Load the my-project blueprint"*
+- *"Save this ensemble as a blueprint"*
+- *"Load the blueprint from /repos/configs/team.yaml"*
+
+### Fan-out schedules
+
+Use `target: "all"` in a schedule to deliver a message to every active player (excluding the conductor). This is useful for periodic status checks or broadcast announcements:
+
+- *"Schedule a message every 30 minutes to all players asking for a progress update"*
+
+### Custom agents
+
+The `agent` field on a player can be a path to a `.md` file that will be used as the session's system prompt via `--system-prompt`. This lets you create specialized agents with domain-specific instructions:
+
+```yaml
+players:
+  - name: security-reviewer
+    workDir: /repos/my-app
+    agent: agents/security-review.md
+    instructions: "Review the latest PR for security issues"
+```
+
 ## Conductors
 
 A **conductor** is an optional special player that acts as an orchestration hub. Use one when you want:
@@ -320,6 +405,23 @@ Sessions start with a random 8-character hex ID. Set a name at launch with `-n`
 - Names must contain only letters, numbers, hyphens, and underscores
 - The name "conductor" is reserved for conductor sessions
 
+### Session status lifecycle
+
+Each session has a status that tracks its connection state:
+
+| Status | Meaning |
+|--------|---------|
+| `pending` | Workflow created by `recruit`, but the Claude Code process hasn't connected yet |
+| `active` | Session is running and responsive |
+| `stale` | Messages have gone undelivered for 3+ minutes — the session is likely disconnected |
+
+Status transitions:
+- **`pending` → `active`** — when the spawned session connects and sends its `updateMetadata` signal
+- **`active` → `stale`** — when undelivered messages exceed the stale threshold (3 minutes)
+- Any status → **terminated** — on graceful shutdown or `stop`
+
+`claude-tempo status` shows `(pending)` and `(stale)` indicators next to player names. The `ClaudeTempoStatus` search attribute is also set, so you can filter sessions by status in the Temporal UI (e.g., `ClaudeTempoStatus = "stale"`).
+
 ### Terminal support
 
 `recruit` and the CLI detect your terminal automatically:
@@ -331,10 +433,13 @@ Sessions start with a random 8-character hex ID. Set a name at launch with `-n`
 | Terminal.app | ✓ | — | — |
 | gnome-terminal | — | ✓ | — |
 | konsole / xterm | — | ✓ | — |
+| Windows Terminal | — | — | ✓ (tabs) |
 | cmd.exe / PowerShell | — | — | ✓ |
 
 macOS terminals preserve the full shell environment (fish, zsh, bash) including node version managers (fnm, nvm).
 
+Windows Terminal is detected automatically via the `WT_SESSION` environment variable. When running inside Windows Terminal, recruited sessions open as new tabs (with the player name as the tab title) instead of separate cmd.exe windows.
+
 ## Configuration
 
 Run `claude-tempo config` to save Temporal connection settings so you don't need flags or env vars every time:

package/dist/activities/schedule-fire.js

@@ -10,7 +10,43 @@ function createScheduleActivities(client) {
         async fireSchedule(input) {
             const { ensemble, scheduleName, message, target, createdBy } = input;
             try {
-                // Resolve target player by querying running session workflows
+                const text = `[scheduled: ${scheduleName}] ${message}`;
+                // Handle target "all" — deliver to every active player except the conductor
+                if (target === 'all') {
+                    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+                    const failures = [];
+                    let delivered = 0;
+                    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;
+                            if (metadata.isConductor)
+                                continue; // skip conductor
+                            await handle.signal('receiveMessage', {
+                                from: createdBy,
+                                text,
+                                isScheduled: true,
+                                scheduleName,
+                            });
+                            delivered++;
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            failures.push(`${wf.workflowId}: ${msg}`);
+                        }
+                    }
+                    if (delivered === 0 && failures.length === 0) {
+                        await notifyFailure(client, ensemble, createdBy, scheduleName, target, 'No active players found in the ensemble.');
+                        return { success: false, error: 'No active players found' };
+                    }
+                    return {
+                        success: failures.length === 0,
+                        error: failures.length > 0 ? `Delivered to ${delivered} players, ${failures.length} failed: ${failures.join('; ')}` : undefined,
+                    };
+                }
+                // Resolve single 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
@@ -18,7 +54,6 @@ function createScheduleActivities(client) {
                     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,

package/dist/cli/commands.d.ts

@@ -27,6 +27,7 @@ export declare function server(opts: ServerOpts): Promise<void>;
 interface UpOpts extends CliOverrides {
     ensemble: string;
     name?: string;
+    from?: string;
     agent: AgentType;
 }
 export declare function up(opts: UpOpts): Promise<void>;
@@ -44,6 +45,11 @@ interface StopOpts extends CliOverrides {
     all?: boolean;
 }
 export declare function stop(opts: StopOpts): Promise<void>;
+interface EnsembleCommandOpts extends CliOverrides {
+    subcommand?: string;
+    name?: string;
+}
+export declare function ensembleCommand(opts: EnsembleCommandOpts): Promise<void>;
 export declare function help(): void;
 export declare function version(): void;
 export {};

package/dist/cli/commands.js

@@ -40,6 +40,7 @@ exports.server = server;
 exports.up = up;
 exports.down = down;
 exports.stop = stop;
+exports.ensembleCommand = ensembleCommand;
 exports.help = help;
 exports.version = version;
 const fs_1 = require("fs");
@@ -50,8 +51,11 @@ const spawn_1 = require("../spawn");
 const config_1 = require("../config");
 const connection_1 = require("../connection");
 const signals_1 = require("../workflows/signals");
+const scheduler_signals_1 = require("../workflows/scheduler-signals");
 const preflight_1 = require("./preflight");
 const mcp_1 = require("./mcp");
+const loader_1 = require("../ensemble/loader");
+const saver_1 = require("../ensemble/saver");
 const out = __importStar(require("./output"));
 /** Package root is two levels up from dist/cli/ */
 const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
@@ -93,7 +97,7 @@ async function start(opts) {
                 if (opts.replace) {
                     out.log(`Stopping existing conductor for ensemble "${opts.ensemble}"...`);
                     try {
-                        await handle.signal(signals_1.shutdownSignal);
+                        await handle.signal(signals_1.updateMetadataSignal, { status: 'terminated' });
                         // Wait briefly for graceful shutdown
                         for (let i = 0; i < 10; i++) {
                             await new Promise(r => setTimeout(r, 500));
@@ -224,6 +228,7 @@ async function status(opts) {
                 host: meta.hostname || '',
                 conductor: meta.isConductor || false,
                 agentType: meta.agentType || 'claude',
+                status: meta.status || 'active',
             });
         }
         catch {
@@ -276,8 +281,11 @@ async function status(opts) {
         for (const s of members) {
             const role = s.conductor ? out.yellow(' (conductor)') : '';
             const agent = s.agentType === 'copilot' ? out.dim(' [copilot]') : '';
+            const statusLabel = s.status === 'stale' ? out.yellow(' (stale)')
+                : s.status === 'pending' ? out.dim(' (pending)')
+                    : '';
             const name = out.bold(s.name);
-            out.log(`  ${name}${role}${agent}`);
+            out.log(`  ${name}${role}${statusLabel}${agent}`);
             if (s.part)
                 out.log(`    ${out.dim(s.part)}`);
             const details = [s.workDir, s.branch, s.host].filter(Boolean).join('  ');
@@ -378,6 +386,7 @@ const SEARCH_ATTRIBUTES = [
     { name: 'ClaudeTempoGitRoot', type: 'Keyword' },
     { name: 'ClaudeTempoEnsemble', type: 'Keyword' },
     { name: 'ClaudeTempoPlayerId', type: 'Keyword' },
+    { name: 'ClaudeTempoStatus', type: 'Keyword' },
 ];
 function isTemporalReachable(config) {
     return (0, connection_1.createTemporalConnection)(config)
@@ -555,11 +564,18 @@ async function up(opts) {
         temporalEnvVars[config_1.ENV.TEMPORAL_TLS_CERT_PATH] = config.temporalTlsCertPath;
     if (config.temporalTlsKeyPath)
         temporalEnvVars[config_1.ENV.TEMPORAL_TLS_KEY_PATH] = config.temporalTlsKeyPath;
+    // Load blueprint if --from is provided
+    const blueprint = opts.from ? (0, loader_1.loadBlueprint)((0, path_1.resolve)(opts.from)) : undefined;
+    if (blueprint) {
+        out.check('Blueprint loaded', true, blueprint.name);
+    }
+    // Resolve conductor agent from blueprint or CLI flags
+    const conductorAgent = blueprint?.conductor?.agent === 'copilot' ? 'copilot' : opts.agent;
     // Step 5: Launch conductor
     console.log();
-    out.log(`Launching conductor in ensemble ${out.cyan(opts.ensemble)}${opts.agent === 'copilot' ? out.dim(' (copilot)') : ''}...`);
+    out.log(`Launching conductor in ensemble ${out.cyan(opts.ensemble)}${conductorAgent === 'copilot' ? out.dim(' (copilot)') : ''}...`);
     let pid;
-    if (opts.agent === 'copilot') {
+    if (conductorAgent === 'copilot') {
         ({ pid } = (0, spawn_1.spawnCopilotBridge)({
             name: opts.name || `${opts.ensemble}-conductor`,
             ensemble: opts.ensemble,
@@ -587,16 +603,199 @@ async function up(opts) {
             [config_1.ENV.PLAYER_NAME]: sessionName,
         }));
     }
+    out.success(`Conductor launched (pid ${pid ?? 'unknown'})`);
+    // Step 6: If blueprint provided, recruit players and create schedules
+    if (blueprint) {
+        // Connect to Temporal to send signals
+        const connection = await (0, connection_1.createTemporalConnection)(config);
+        const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+        // Wait for conductor workflow to appear
+        out.log(`\n  Waiting for conductor to register...`);
+        const conductorWfId = (0, config_1.conductorWorkflowId)(opts.ensemble);
+        let conductorReady = false;
+        for (let i = 0; i < 30; i++) {
+            await new Promise(r => setTimeout(r, 500));
+            try {
+                const handle = client.workflow.getHandle(conductorWfId);
+                const desc = await handle.describe();
+                if (desc.status.name === 'RUNNING') {
+                    conductorReady = true;
+                    break;
+                }
+            }
+            catch { /* not yet */ }
+        }
+        if (!conductorReady) {
+            out.warn('Conductor did not register within 15s — skipping blueprint players/schedules');
+        }
+        else {
+            out.check('Conductor registered', true);
+            // Send conductor instructions if provided
+            if (blueprint.conductor?.instructions) {
+                try {
+                    const handle = client.workflow.getHandle(conductorWfId);
+                    await handle.signal('receiveMessage', {
+                        from: 'blueprint',
+                        text: blueprint.conductor.instructions,
+                    });
+                    out.check('Conductor instructions sent', true);
+                }
+                catch (err) {
+                    out.warn(`Could not send conductor instructions: ${err}`);
+                }
+            }
+            // Recruit players sequentially (each polls for ~15s)
+            if (blueprint.players.length > 0) {
+                console.log();
+                out.log(`Recruiting ${blueprint.players.length} player${blueprint.players.length !== 1 ? 's' : ''} from blueprint...`);
+                for (const player of blueprint.players) {
+                    const playerAgent = player.agent === 'copilot' ? 'copilot' : 'claude';
+                    const playerWorkDir = player.workDir || process.cwd();
+                    // Record existing workflows to detect the new one
+                    const existingIds = new Set();
+                    const listQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+                    for await (const wf of client.workflow.list({ query: listQuery })) {
+                        existingIds.add(wf.workflowId);
+                    }
+                    // Spawn the player
+                    if (playerAgent === 'copilot') {
+                        (0, spawn_1.spawnCopilotBridge)({
+                            name: player.name,
+                            ensemble: opts.ensemble,
+                            temporalAddress: config.temporalAddress,
+                            temporalNamespace: config.temporalNamespace,
+                            temporalApiKey: config.temporalApiKey,
+                            temporalTlsCertPath: config.temporalTlsCertPath,
+                            temporalTlsKeyPath: config.temporalTlsKeyPath,
+                            isConductor: false,
+                            workDir: playerWorkDir,
+                        });
+                    }
+                    else {
+                        const claudeArgs = [
+                            '--dangerously-skip-permissions',
+                            '--dangerously-load-development-channels', 'server:claude-tempo',
+                            '-n', player.name,
+                        ];
+                        (0, spawn_1.spawnInTerminal)(claudeArgs, playerWorkDir, {
+                            ...temporalEnvVars,
+                            [config_1.ENV.ENSEMBLE]: opts.ensemble,
+                            [config_1.ENV.CONDUCTOR]: '',
+                            [config_1.ENV.PLAYER_NAME]: player.name,
+                        });
+                    }
+                    // Poll for the new workflow to appear (up to ~15s)
+                    let newWorkflowId = null;
+                    for (let attempt = 0; attempt < 30; attempt++) {
+                        await new Promise(r => setTimeout(r, 500));
+                        for await (const wf of client.workflow.list({ query: listQuery })) {
+                            if (!existingIds.has(wf.workflowId)) {
+                                newWorkflowId = wf.workflowId;
+                                break;
+                            }
+                        }
+                        if (newWorkflowId)
+                            break;
+                    }
+                    if (newWorkflowId && player.instructions) {
+                        try {
+                            const handle = client.workflow.getHandle(newWorkflowId);
+                            await handle.signal('receiveMessage', {
+                                from: 'blueprint',
+                                text: player.instructions,
+                            });
+                        }
+                        catch { /* best effort */ }
+                    }
+                    const status = newWorkflowId ? out.green('ok') : out.yellow('slow');
+                    out.log(`  ${status} ${out.bold(player.name)} in ${playerWorkDir}`);
+                }
+            }
+            // Create schedules
+            if (blueprint.schedules && blueprint.schedules.length > 0) {
+                console.log();
+                out.log(`Creating ${blueprint.schedules.length} schedule${blueprint.schedules.length !== 1 ? 's' : ''}...`);
+                for (const sched of blueprint.schedules) {
+                    try {
+                        const entry = blueprintScheduleToEntry(sched);
+                        const schedulerWfId = (0, config_1.schedulerWorkflowId)(opts.ensemble);
+                        const handle = client.workflow.getHandle(schedulerWfId);
+                        await handle.signal(scheduler_signals_1.addScheduleSignal, entry);
+                        out.check(sched.name, true, `→ ${sched.target}`);
+                    }
+                    catch (err) {
+                        out.warn(`Could not create schedule "${sched.name}": ${err}`);
+                    }
+                }
+            }
+        }
+        await connection.close();
+    }
     console.log();
     out.success('You\'re all set!');
-    out.log(`  Conductor launched (pid ${pid ?? 'unknown'})`);
     out.log(`  Ensemble: ${out.cyan(opts.ensemble)}`);
-    out.log(`\n  ${out.bold('What next?')}`);
-    out.log(`  ${out.dim('claude-tempo start ' + opts.ensemble)}    Add a player session`);
-    out.log(`  ${out.dim('claude-tempo status ' + opts.ensemble)}   See who\'s active`);
-    out.log(`  Or ask the conductor to ${out.dim('recruit')} players for you`);
+    if (!blueprint) {
+        out.log(`\n  ${out.bold('What next?')}`);
+        out.log(`  ${out.dim('claude-tempo start ' + opts.ensemble)}    Add a player session`);
+        out.log(`  ${out.dim('claude-tempo status ' + opts.ensemble)}   See who\'s active`);
+        out.log(`  Or ask the conductor to ${out.dim('recruit')} players for you`);
+    }
+    else {
+        out.log(`  Blueprint: ${out.dim(blueprint.name)}`);
+        out.log(`  Players: ${blueprint.players.length}`);
+        if (blueprint.schedules?.length)
+            out.log(`  Schedules: ${blueprint.schedules.length}`);
+        out.log(`\n  ${out.dim('claude-tempo status ' + opts.ensemble)}   See who\'s active`);
+    }
     console.log();
 }
+/** Convert a blueprint schedule definition to a ScheduleEntry for the scheduler workflow. */
+function blueprintScheduleToEntry(sched) {
+    const now = Date.now();
+    let nextFireAt;
+    let interval;
+    if (sched.every) {
+        interval = parseDuration(sched.every);
+        nextFireAt = sched.delay
+            ? new Date(now + parseDuration(sched.delay)).toISOString()
+            : new Date(now + interval).toISOString();
+    }
+    else if (sched.at) {
+        nextFireAt = new Date(sched.at).toISOString();
+    }
+    else if (sched.delay) {
+        nextFireAt = new Date(now + parseDuration(sched.delay)).toISOString();
+    }
+    else {
+        nextFireAt = new Date(now + 60_000).toISOString(); // default: 1 minute
+    }
+    return {
+        name: sched.name,
+        message: sched.message,
+        target: sched.target,
+        createdBy: 'blueprint',
+        nextFireAt,
+        interval,
+        until: sched.until,
+        remainingCount: sched.count,
+        firedCount: 0,
+        type: interval ? 'interval' : 'once',
+    };
+}
+/** Parse a human duration string like "10m", "1h", "30s" to milliseconds. */
+function parseDuration(s) {
+    const match = s.match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d)$/);
+    if (!match)
+        throw new Error(`Invalid duration: "${s}"`);
+    const value = parseFloat(match[1]);
+    switch (match[2]) {
+        case 's': return value * 1_000;
+        case 'm': return value * 60_000;
+        case 'h': return value * 3_600_000;
+        case 'd': return value * 86_400_000;
+        default: throw new Error(`Unknown duration unit: "${match[2]}"`);
+    }
+}
 async function down(opts) {
     const config = (0, config_1.getConfig)(opts);
     out.heading('claude-tempo teardown');
@@ -732,7 +931,7 @@ async function stop(opts) {
                         continue;
                     }
                 }
-                await handle.signal(signals_1.shutdownSignal);
+                await handle.signal(signals_1.updateMetadataSignal, { status: 'terminated' });
                 stopped++;
                 out.log(`  ${out.dim('stopped')} ${wf.workflowId}`);
             }
@@ -792,9 +991,9 @@ async function stopByName(client, name, config, ensemble) {
                 // No conductor or conductor not running — fine
             }
         }
-        // Send shutdown signal (graceful)
+        // Send termination status update (graceful)
         try {
-            await handle.signal(signals_1.shutdownSignal);
+            await handle.signal(signals_1.updateMetadataSignal, { status: 'terminated' });
             out.success(`Stopped "${name}"`);
         }
         catch {
@@ -867,6 +1066,57 @@ function killBridgeProcesses() {
         // logs dir unreadable
     }
 }
+async function ensembleCommand(opts) {
+    switch (opts.subcommand) {
+        case 'save': {
+            const config = (0, config_1.getConfig)(opts);
+            const connection = await (0, connection_1.createTemporalConnection)(config);
+            const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+            const ensemble = opts.name || config.ensemble;
+            try {
+                const path = await (0, saver_1.saveBlueprint)(client, ensemble);
+                out.success(`Saved ensemble "${ensemble}" to ${path}`);
+            }
+            finally {
+                await connection.close();
+            }
+            break;
+        }
+        case 'list': {
+            const blueprints = (0, saver_1.listBlueprints)();
+            if (blueprints.length === 0) {
+                out.log('No saved ensembles. Use `claude-tempo ensemble save [name]` to save one.');
+                return;
+            }
+            out.heading('Saved ensembles');
+            for (const bp of blueprints) {
+                out.log(`  ${out.bold(bp.name)}  ${out.dim(bp.path)}`);
+            }
+            console.log();
+            break;
+        }
+        case 'show': {
+            if (!opts.name) {
+                out.error('Usage: claude-tempo ensemble show <name>');
+                process.exit(1);
+            }
+            const content = (0, saver_1.readSavedBlueprint)(opts.name);
+            if (!content) {
+                out.error(`No saved ensemble named "${opts.name}"`);
+                out.log(`  Run ${out.dim('claude-tempo ensemble list')} to see available ensembles.`);
+                process.exit(1);
+            }
+            console.log(content);
+            break;
+        }
+        default:
+            out.error('Usage: claude-tempo ensemble <save|list|show> [name]');
+            out.log(`\n  ${out.dim('claude-tempo ensemble save [name]')}   Save current ensemble state`);
+            out.log(`  ${out.dim('claude-tempo ensemble list')}          List saved ensembles`);
+            out.log(`  ${out.dim('claude-tempo ensemble show <name>')}   Display a saved blueprint`);
+            process.exit(1);
+    }
+}
 function help() {
     console.log(`
 ${out.bold('claude-tempo')} — Multi-session Claude Code coordination via Temporal
@@ -885,6 +1135,7 @@ ${out.bold('Commands:')}
   ${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
+  ${out.cyan('ensemble')} <sub>       Manage saved ensemble blueprints (save/list/show)
   ${out.cyan('config')}                Configure Temporal connection settings
   ${out.cyan('init')}                  Register MCP server globally (or --project for .mcp.json)
   ${out.cyan('preflight')}             Run preflight checks only
@@ -905,6 +1156,7 @@ ${out.bold('Other options:')}
   --project                   Use per-project .mcp.json instead of global (init only)
   --keep-mcp                  Don't remove MCP config (down only)
   --all                       Stop all sessions (stop only)
+  --from <file>               Load ensemble from a YAML blueprint (up only)
   --ensemble <name>           Target a specific ensemble (stop only)
   -d, --dir <path>            Target directory (default: cwd)