claude-tempo 0.14.0 → 0.16.1

package/CLAUDE.md

@@ -65,9 +65,13 @@ src/
 │   ├── quality-gate.ts # Define quality gates for tasks (conductor only)
 │   ├── evaluate-gate.ts # Mark gate criteria as passed/failed (conductor only)
 │   ├── gates.ts       # List quality gates and their status (conductor only)
+│   ├── worktree.ts    # Manage git worktrees for player isolation (conductor only)
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
 ├── utils/
-│   └── validation.ts  # Shared validation constants (name/message/path limits, encore defaults) and helpers
+│   ├── validation.ts  # Shared validation constants (name/message/path limits, encore defaults) and helpers
+│   ├── worktree.ts    # Git worktree create/remove helpers (cross-platform)
+│   ├── safe-path.ts   # Path safety utilities
+│   └── duration.ts    # Duration parsing helpers
 ├── types.ts           # Shared type definitions
 ├── channel.ts         # Claude channel notification helper
 ├── git-info.ts        # Git repository detection helper
@@ -120,6 +124,7 @@ npm test
 - **Schedule**: A one-shot or recurring message delivery configured via the `schedule` tool. Backed by a durable `claudeSchedulerWorkflow` — survives restarts. Supports delay (`delay`), fixed time (`at`), recurring interval (`every`), and cron expressions (`cron`) with optional IANA timezone (`timezone`). Cron schedules use `croner` for expression parsing and next-fire computation. Managed via `schedule`, `unschedule`, and `schedules` tools.
 - **Lineup**: A YAML file defining an ensemble configuration — which players to recruit, their types, working directories, and optional startup messages. Load via `load_lineup` to bootstrap a full ensemble in one step; save via `save_lineup` to snapshot a running ensemble's state for later reuse.
 - **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).
 - **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.
 
 ## Dashboard

package/README.md

@@ -133,6 +133,7 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `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. |
+| `worktree` | Manage git worktrees for player isolation. Actions: `create`, `remove`, `list`. Conductor only. |
 | `quality_gate` | Define or replace a quality gate for a task — a named checklist of criteria that must pass. Conductor only. |
 | `evaluate_gate` | Mark one or more criteria on a quality gate as passed or failed. Conductor only. |
 | `gates` | List quality gates and their status. Filter by task name or status (`open`, `passed`, `failed`). Conductor only. |
@@ -477,6 +478,8 @@ 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 |
+| `broadcast <msg>` | Send a message to all active players. Use `--type` to filter by player type, `--include-stale` to include stale sessions. |
+| `encore <name>` | Revive a stale player session by name. Use `--host` to target a remote machine. |
 | `ensemble <sub>` | Manage saved lineups (`save`, `list`, `show`) |
 | `agent-types <sub>` | Manage player types (`list`, `show <name>`, `init`) |
 | `version` | Print the installed version |

package/dist/activities/outbox.d.ts

@@ -46,6 +46,8 @@ export interface SpawnProcessInput {
     nativeResolvable?: boolean;
     /** When true, use --resume instead of -n (reconnect to existing session). */
     resume?: boolean;
+    /** Claude Code session UUID for --session-id (new sessions) or --resume (encore). */
+    claudeSessionId?: string;
     /** Tool restrictions from the agent definition frontmatter. */
     allowedTools?: string[];
 }
@@ -64,6 +66,8 @@ export interface EncoreResult {
     agentDefinitionPath?: string;
     nativeResolvable?: boolean;
     allowedTools?: string[];
+    /** Claude Code session UUID for deterministic --resume. */
+    claudeSessionId?: string;
     temporalAddress: string;
     temporalNamespace: string;
 }
@@ -71,11 +75,15 @@ export interface OutboxActivityResult {
     success: boolean;
     error?: string;
 }
+export interface RecruitResult extends OutboxActivityResult {
+    /** Claude Code session UUID assigned at recruit time. */
+    claudeSessionId?: string;
+}
 export interface OutboxActivities {
     deliverCue(input: DeliverCueInput): Promise<OutboxActivityResult>;
     deliverReport(input: DeliverReportInput): Promise<OutboxActivityResult>;
     terminateSession(input: TerminateSessionInput): Promise<OutboxActivityResult>;
-    startRecruitedSession(input: StartRecruitedSessionInput): Promise<OutboxActivityResult>;
+    startRecruitedSession(input: StartRecruitedSessionInput): Promise<RecruitResult>;
     spawnProcess(input: SpawnProcessInput): Promise<OutboxActivityResult>;
     performEncore(input: PerformEncoreInput): Promise<EncoreResult>;
 }

package/dist/activities/outbox.js

@@ -98,6 +98,8 @@ function createOutboxActivities(client, config) {
                     ? (0, config_1.conductorWorkflowId)(ensemble)
                     : (0, config_1.sessionWorkflowId)(ensemble, targetName);
                 const { gitRoot, gitBranch } = (0, git_info_1.getGitInfo)(workDir);
+                // Generate a UUID for the Claude Code session — used for deterministic --resume on encore
+                const claudeSessionId = crypto.randomUUID();
                 const sessionInput = {
                     metadata: {
                         playerId: targetName,
@@ -109,6 +111,7 @@ function createOutboxActivities(client, config) {
                         isConductor,
                         agentType: agent,
                         status: 'pending',
+                        claudeSessionId,
                         ...(agentDefinition ? { playerType: agentDefinition } : {}),
                         ...(agentDefinitionDescription ? { playerTypeDescription: agentDefinitionDescription } : {}),
                         recruitedBy: fromPlayerId,
@@ -137,15 +140,15 @@ function createOutboxActivities(client, config) {
                         ClaudeTempoPlayerId: [targetName],
                     },
                 });
-                log(`Pre-created workflow ${workflowId} for recruit "${targetName}"`);
-                return { success: true };
+                log(`Pre-created workflow ${workflowId} for recruit "${targetName}" (sessionId=${claudeSessionId})`);
+                return { success: true, claudeSessionId };
             }
             catch (err) {
                 throw activity_1.ApplicationFailure.nonRetryable(`Failed to start recruited session "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
             }
         },
         async spawnProcess(input) {
-            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume, allowedTools } = input;
+            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume, claudeSessionId, allowedTools } = input;
             // Read secrets from the worker's config closure — never from workflow state
             const { temporalApiKey, temporalTlsCertPath, temporalTlsKeyPath } = config;
             try {
@@ -178,8 +181,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];
+                    // Use --resume for encore (reconnect to existing session) or -n for new sessions.
+                    // For encore: use UUID for deterministic --resume (no interactive picker).
+                    // For new sessions: use --session-id to track the UUID for future encores.
+                    const nameArgs = resume
+                        ? ['--resume', claudeSessionId || targetName]
+                        : ['-n', targetName, ...(claudeSessionId ? ['--session-id', claudeSessionId] : [])];
                     // Build --allowedTools flag from agent definition frontmatter
                     const allowedToolsFlags = allowedTools && allowedTools.length > 0
                         ? ['--allowedTools', ...allowedTools]
@@ -280,6 +287,7 @@ function createOutboxActivities(client, config) {
                     agentDefinitionPath,
                     nativeResolvable,
                     allowedTools,
+                    claudeSessionId: metadata.claudeSessionId || undefined,
                     temporalAddress: config.temporalAddress,
                     temporalNamespace: config.temporalNamespace,
                 };

package/dist/ensemble/loader.js

@@ -28,12 +28,6 @@ function loadLineup(filePath) {
         if (!/^[a-zA-Z0-9_-]+$/.test(p.name)) {
             throw new Error(`Invalid lineup: players[${i}].name "${p.name}" contains invalid characters`);
         }
-        if (p.isolation != null && p.isolation !== 'worktree') {
-            throw new Error(`Invalid lineup: players[${i}].isolation must be "worktree" if specified`);
-        }
-        if (p.branch != null && (typeof p.branch !== 'string' || !p.branch)) {
-            throw new Error(`Invalid lineup: players[${i}].branch must be a non-empty string`);
-        }
     }
     // Validate schedules if present
     if (doc.schedules != null) {
@@ -76,8 +70,6 @@ function loadLineup(filePath) {
             ...(p.agent != null && { agent: p.agent }),
             ...(p.instructions != null && { instructions: p.instructions }),
             ...(Array.isArray(p.allowedTools) && { allowedTools: p.allowedTools.map(String) }),
-            ...(p.isolation != null && { isolation: p.isolation }),
-            ...(p.branch != null && { branch: p.branch }),
         })),
         schedules: doc.schedules,
     };

package/dist/ensemble/schema.d.ts

@@ -14,8 +14,6 @@ export interface EnsembleLineup {
         agent?: string;
         instructions?: string;
         allowedTools?: string[];
-        isolation?: 'worktree';
-        branch?: string;
         /** Transient: resolved agent definition name (set by loadAndResolveLineup). */
         _agentDefinition?: string;
         /** Transient: resolved absolute path to .md file (set by loadAndResolveLineup). */

package/dist/server.js

@@ -67,6 +67,7 @@ const encore_1 = require("./tools/encore");
 const quality_gate_1 = require("./tools/quality-gate");
 const evaluate_gate_1 = require("./tools/evaluate-gate");
 const gates_1 = require("./tools/gates");
+const worktree_1 = require("./tools/worktree");
 const channel_1 = require("./channel");
 const agent_types_2 = require("./ensemble/agent-types");
 const log = (...args) => console.error('[claude-tempo]', ...args);
@@ -288,6 +289,7 @@ async function main() {
         (0, quality_gate_1.registerQualityGateTool)(mcpServer, handle, getPlayerId);
         (0, evaluate_gate_1.registerEvaluateGateTool)(mcpServer, handle, getPlayerId);
         (0, gates_1.registerGatesTool)(mcpServer, handle);
+        (0, worktree_1.registerWorktreeTool)(mcpServer, client, config, handle, getPlayerId);
     }
     const MAESTRO_ACK = '\n\n[IMPORTANT: This message is from a human (Maestro). Immediately cue the sender back with a brief acknowledgment and your planned next step before doing the work.]';
     // Start message poller — push messages into Claude Code via channel notifications.

package/dist/tools/load-lineup.js

@@ -15,7 +15,6 @@ const duration_1 = require("../utils/duration");
 const safe_path_1 = require("../utils/safe-path");
 const helpers_1 = require("./helpers");
 const validation_1 = require("../utils/validation");
-const worktree_1 = require("../utils/worktree");
 const log = (...args) => console.error('[claude-tempo:load-lineup]', ...args);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -80,8 +79,7 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
             // Recruit players sequentially
             for (const player of lineup.players) {
                 const playerName = player.name;
-                let workDir = player.workDir || process.cwd();
-                let worktreePath;
+                const workDir = player.workDir || process.cwd();
                 const agentType = player.agent === 'copilot' ? 'copilot' : 'claude';
                 const isCustomAgent = player.agent && player.agent !== 'default' && player.agent !== 'copilot';
                 const systemPrompt = player._agentDefinition ? undefined : (isCustomAgent ? player.agent : undefined);
@@ -106,31 +104,6 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                     }
                     continue;
                 }
-                // Create worktree if isolation is requested
-                if (player.isolation === 'worktree') {
-                    try {
-                        // Determine git root: use the player's workDir as the git root,
-                        // or fall back to cwd (which should be a git repo).
-                        const gitRoot = workDir;
-                        const result = (0, worktree_1.createWorktree)({
-                            gitRoot,
-                            ensemble: config.ensemble,
-                            playerName,
-                            branch: player.branch,
-                        });
-                        worktreePath = result.path;
-                        workDir = result.path;
-                        log(`Worktree for "${playerName}": ${result.path} (branch: ${result.branch}, created: ${result.created})`);
-                        // Install dependencies — blocking but failure is non-fatal
-                        if (result.created) {
-                            (0, worktree_1.installDependencies)(result.path);
-                        }
-                    }
-                    catch (err) {
-                        failed.push(`${playerName}: worktree creation failed — ${err}`);
-                        continue;
-                    }
-                }
                 // Record existing workflows to detect the new one
                 const existingIds = new Set();
                 const listQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
@@ -221,16 +194,6 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                     failed.push(`${playerName}: spawned but did not register within 15s`);
                     continue;
                 }
-                // Record worktree path in session metadata
-                if (worktreePath && newWorkflowId) {
-                    try {
-                        const newHandle = client.workflow.getHandle(newWorkflowId);
-                        await newHandle.signal('updateMetadata', { worktreePath });
-                    }
-                    catch (err) {
-                        log(`Failed to set worktreePath metadata for "${playerName}":`, err);
-                    }
-                }
                 // Send initial instructions if provided
                 if (player.instructions) {
                     try {

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

package/dist/tools/worktree.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorktreeTool = registerWorktreeTool;
+const zod_1 = require("zod");
+const resolve_1 = require("./resolve");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const worktree_1 = require("../utils/worktree");
+const validation_1 = require("../utils/validation");
+function registerWorktreeTool(server, client, config, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'worktree', 'Manage git worktrees for player isolation. Conductor only. Actions: create (provision worktree for a player), remove (clean up), list (show active worktrees).', {
+        action: zod_1.z.enum(['create', 'remove', 'list']).describe('Action to perform'),
+        player: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Player name (required for create/remove)'),
+        branch: zod_1.z.string().optional().describe('Git branch for the worktree (defaults to {ensemble}/{player-name})'),
+    }, async (args) => {
+        const { action, player, branch } = args;
+        try {
+            switch (action) {
+                case 'create': {
+                    if (!player) {
+                        return {
+                            content: [{ type: 'text', text: '`player` is required for create action.' }],
+                            isError: true,
+                        };
+                    }
+                    // Verify player exists
+                    const targetHandle = await (0, resolve_1.resolveSession)(client, config.ensemble, player);
+                    if (!targetHandle) {
+                        return {
+                            content: [{ type: 'text', text: `No active session found for "${player}".` }],
+                            isError: true,
+                        };
+                    }
+                    // Check target is on same host (cross-machine worktrees not supported)
+                    const targetMeta = await targetHandle.query('getMetadata');
+                    const { hostname } = await Promise.resolve().then(() => __importStar(require('os'))).then((os) => ({ hostname: os.hostname() }));
+                    if (targetMeta.hostname && targetMeta.hostname !== hostname) {
+                        return {
+                            content: [{ type: 'text', text: `Cannot create worktree for "${player}" — they are on host "${targetMeta.hostname}" but worktrees must be created locally.` }],
+                            isError: true,
+                        };
+                    }
+                    const gitRoot = process.cwd();
+                    const result = (0, worktree_1.createWorktree)({
+                        gitRoot,
+                        ensemble: config.ensemble,
+                        playerName: player,
+                        branch,
+                    });
+                    if (result.created) {
+                        (0, worktree_1.installDependencies)(result.path);
+                    }
+                    // Record in conductor's worktree state
+                    const entry = {
+                        player,
+                        path: result.path,
+                        branch: result.branch,
+                        gitRoot,
+                        createdAt: new Date().toISOString(),
+                        createdBy: getPlayerId(),
+                    };
+                    await handle.signal('setWorktree', entry);
+                    // Auto-cue the player with worktree info
+                    const cueMessage = [
+                        `\u{1f33f} **Worktree ready** for your task:`,
+                        `- **Path**: \`${result.path}\``,
+                        `- **Branch**: \`${result.branch}\``,
+                        '',
+                        `Run \`cd ${result.path}\` to switch to your isolated workspace.`,
+                        `All your changes will be on branch \`${result.branch}\`.`,
+                        `When done, commit and push \u2014 the conductor will handle cleanup.`,
+                    ].join('\n');
+                    await handle.executeUpdate(signals_1.submitOutboxUpdate, {
+                        args: [{
+                                type: 'cue',
+                                targetPlayerId: player,
+                                message: cueMessage,
+                            }],
+                    });
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Worktree created for **${player}**:\n- Path: \`${result.path}\`\n- Branch: \`${result.branch}\`\n- Created: ${result.created ? 'new' : 'reused existing'}\n\nPlayer has been notified.`,
+                            }],
+                    };
+                }
+                case 'remove': {
+                    if (!player) {
+                        return {
+                            content: [{ type: 'text', text: '`player` is required for remove action.' }],
+                            isError: true,
+                        };
+                    }
+                    // Look up worktree entry from conductor state
+                    const entries = await handle.query('worktrees');
+                    const entry = entries.find((w) => w.player === player);
+                    if (!entry) {
+                        return {
+                            content: [{ type: 'text', text: `No worktree found for player "${player}".` }],
+                            isError: true,
+                        };
+                    }
+                    // Remove from disk
+                    (0, worktree_1.removeWorktree)(entry.path);
+                    // Remove from conductor state
+                    await handle.signal('removeWorktree', player);
+                    // Auto-cue the player
+                    try {
+                        await handle.executeUpdate(signals_1.submitOutboxUpdate, {
+                            args: [{
+                                    type: 'cue',
+                                    targetPlayerId: player,
+                                    message: `Worktree removed. You're back in the shared repository.`,
+                                }],
+                        });
+                    }
+                    catch {
+                        // Player may no longer be active — non-fatal
+                    }
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Worktree for **${player}** removed (branch: \`${entry.branch}\`).`,
+                            }],
+                    };
+                }
+                case 'list': {
+                    const entries = await handle.query('worktrees');
+                    if (entries.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: 'No active worktrees.' }],
+                        };
+                    }
+                    const lines = entries.map((w) => `- **${w.player}**: \`${w.path}\` (branch: \`${w.branch}\`, created: ${w.createdAt} by ${w.createdBy})`);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `${entries.length} active worktree${entries.length === 1 ? '' : 's'}:\n${lines.join('\n')}`,
+                            }],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Worktree operation failed: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 export type AgentType = 'claude' | 'copilot';
-export type SessionStatus = 'active' | 'stale' | 'pending' | 'terminated';
+export type SessionStatus = 'active' | 'stale' | 'pending' | 'terminated' | 'blocked';
 export interface SessionMetadata {
     playerId: string;
     ensemble: string;
@@ -18,6 +18,8 @@ export interface SessionMetadata {
     recruitedBy?: string;
     /** Worktree path if this session was spawned in an isolated worktree. */
     worktreePath?: string;
+    /** Claude Code session UUID — used for deterministic --resume on encore. */
+    claudeSessionId?: string;
 }
 export interface AgentTypeInfo {
     name: string;
@@ -46,6 +48,8 @@ export interface SessionInput {
     disableStaleDetection?: boolean;
     /** Restored from continue-as-new (conductor only) */
     qualityGates?: QualityGate[];
+    /** Restored from continue-as-new (conductor only) */
+    worktrees?: WorktreeEntry[];
     /** Temporal config passed through for outbox activities (non-secret fields only). */
     temporalConfig?: {
         temporalAddress: string;
@@ -154,6 +158,20 @@ export interface QualityGate {
     /** Derived: all passed → passed, any failed → failed, else open. */
     status: 'open' | 'passed' | 'failed';
 }
+export interface WorktreeEntry {
+    /** Player name assigned to this worktree. */
+    player: string;
+    /** Absolute path to worktree directory. */
+    path: string;
+    /** Git branch for this worktree. */
+    branch: string;
+    /** Original git root (for git worktree remove). */
+    gitRoot: string;
+    /** ISO timestamp of creation. */
+    createdAt: string;
+    /** Player ID of creator. */
+    createdBy: string;
+}
 export interface ScheduleEntry {
     /** Unique name for this schedule (used as key for add/replace/remove). */
     name: string;

package/dist/utils/validation.d.ts

@@ -32,13 +32,15 @@ export declare const GATE_CRITERION_TEXT_MAX = 512;
 export declare const GATE_NOTES_MAX = 1024;
 /** Timeout for npm install in worktrees (60s). */
 export declare const WORKTREE_INSTALL_TIMEOUT = 60000;
+/** Window for blocked session detection (5 minutes). */
+export declare const BLOCKED_WINDOW_MS: number;
 /** Default number of recent messages to include as context in an encore. */
 export declare const ENCORE_DEFAULT_CONTEXT_MESSAGES = 10;
 /** Maximum length for message preview truncation. */
 export declare const PREVIEW_MAX_LENGTH = 200;
 /**
  * Whether a session should be included in a broadcast based on its status.
- * Always excludes pending and terminated. Excludes stale unless includeStale is true.
+ * Always excludes pending, terminated, and blocked. Excludes stale unless includeStale is true.
  */
 export declare function shouldIncludeInBroadcast(status: string | undefined, includeStale: boolean): boolean;
 /** Validate a player name string. Returns an error message or null if valid. */

package/dist/utils/validation.js

@@ -4,7 +4,7 @@
  * Used by MCP tool Zod schemas and config validation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREVIEW_MAX_LENGTH = exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = exports.WORKTREE_INSTALL_TIMEOUT = exports.GATE_NOTES_MAX = exports.GATE_CRITERION_TEXT_MAX = exports.GATE_CRITERIA_MAX = exports.GATE_TASK_MAX = exports.CRON_EXPRESSION_MAX = exports.SCHEDULE_MESSAGE_MAX = exports.SCHEDULE_NAME_MAX = exports.PATH_MAX = exports.PART_MAX = exports.MESSAGE_MAX = exports.ENSEMBLE_NAME_REGEX = exports.PLAYER_NAME_MAX = exports.PLAYER_NAME_REGEX = void 0;
+exports.PREVIEW_MAX_LENGTH = exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = exports.BLOCKED_WINDOW_MS = exports.WORKTREE_INSTALL_TIMEOUT = exports.GATE_NOTES_MAX = exports.GATE_CRITERION_TEXT_MAX = exports.GATE_CRITERIA_MAX = exports.GATE_TASK_MAX = exports.CRON_EXPRESSION_MAX = exports.SCHEDULE_MESSAGE_MAX = exports.SCHEDULE_NAME_MAX = exports.PATH_MAX = exports.PART_MAX = exports.MESSAGE_MAX = exports.ENSEMBLE_NAME_REGEX = exports.PLAYER_NAME_MAX = exports.PLAYER_NAME_REGEX = void 0;
 exports.shouldIncludeInBroadcast = shouldIncludeInBroadcast;
 exports.validatePlayerName = validatePlayerName;
 exports.validateEnsembleName = validateEnsembleName;
@@ -38,17 +38,19 @@ exports.GATE_CRITERION_TEXT_MAX = 512;
 exports.GATE_NOTES_MAX = 1024;
 /** Timeout for npm install in worktrees (60s). */
 exports.WORKTREE_INSTALL_TIMEOUT = 60000;
+/** Window for blocked session detection (5 minutes). */
+exports.BLOCKED_WINDOW_MS = 5 * 60 * 1000;
 /** Default number of recent messages to include as context in an encore. */
 exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = 10;
 /** Maximum length for message preview truncation. */
 exports.PREVIEW_MAX_LENGTH = 200;
 /**
  * Whether a session should be included in a broadcast based on its status.
- * Always excludes pending and terminated. Excludes stale unless includeStale is true.
+ * Always excludes pending, terminated, and blocked. Excludes stale unless includeStale is true.
  */
 function shouldIncludeInBroadcast(status, includeStale) {
     const s = status || 'active';
-    if (s === 'pending' || s === 'terminated')
+    if (s === 'pending' || s === 'terminated' || s === 'blocked')
         return false;
     if (s === 'stale' && !includeStale)
         return false;