claude-tempo 0.14.0 → 0.15.0

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. |

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

@@ -46,6 +46,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 +156,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/workflows/session.js

@@ -25,6 +25,7 @@ async function claudeSessionWorkflow(input) {
     (0, workflow_1.patched)('v0.10-initial');
     (0, workflow_1.patched)('v0.11-check-and-set-status');
     (0, workflow_1.patched)('v0.13-quality-gates');
+    (0, workflow_1.patched)('v0.14-worktrees');
     // Ensure search attributes are always current — critical when reconnecting
     // via WorkflowIdConflictPolicy.USE_EXISTING, which skips the attributes
     // passed to client.workflow.start().
@@ -169,6 +170,7 @@ async function claudeSessionWorkflow(input) {
     const commandHistory = input.commandHistory ?? [];
     const reportHistory = input.reportHistory ?? [];
     const qualityGates = input.qualityGates ?? [];
+    const worktrees = input.worktrees ?? [];
     // ── Conductor-specific Handlers ──
     if (input.metadata.isConductor) {
         (0, workflow_1.setHandler)(signals_1.commandSignal, (cmd) => {
@@ -258,6 +260,23 @@ async function claudeSessionWorkflow(input) {
             gate.status = deriveGateStatus(gate);
         });
         (0, workflow_1.setHandler)(signals_1.qualityGatesQuery, () => qualityGates);
+        // ── Worktree Handlers ──
+        (0, workflow_1.setHandler)(signals_1.setWorktreeSignal, (entry) => {
+            const existing = worktrees.findIndex((w) => w.player === entry.player);
+            if (existing >= 0) {
+                worktrees[existing] = entry;
+            }
+            else {
+                worktrees.push(entry);
+            }
+        });
+        (0, workflow_1.setHandler)(signals_1.removeWorktreeSignal, (playerName) => {
+            const idx = worktrees.findIndex((w) => w.player === playerName);
+            if (idx >= 0) {
+                worktrees.splice(idx, 1);
+            }
+        });
+        (0, workflow_1.setHandler)(signals_1.worktreesQuery, () => worktrees);
     }
     // ── Main Loop ──
     const hasPendingOutbox = () => outbox.some((e) => e.status === 'pending');
@@ -416,7 +435,7 @@ async function claudeSessionWorkflow(input) {
                 messages: messages.filter((m) => !m.delivered),
                 sentMessages: sentMessages.slice(-50),
                 outbox: outbox.filter((e) => e.status === 'pending' || e.status === 'processing'),
-                ...(input.metadata.isConductor ? { commandHistory, reportHistory, qualityGates } : {}),
+                ...(input.metadata.isConductor ? { commandHistory, reportHistory, qualityGates, worktrees } : {}),
             });
         }
     }

package/dist/workflows/signals.d.ts

@@ -1,5 +1,5 @@
-import type { SessionMetadata, Message, SentMessage, HistoryEntry, OutboxEntry, OutboxEntryInput, QualityGate } from '../types';
-export type { SessionMetadata, SessionInput, SessionStatus, Message, Command, PlayerReport, SentMessage, HistoryEntry, OutboxEntry, OutboxEntryInput, OutboxEntryStatus, CueOutboxEntry, RecruitOutboxEntry, ReportOutboxEntry, StopOutboxEntry, EncoreOutboxEntry, QualityGate, QualityGateCriterion, } from '../types';
+import type { SessionMetadata, Message, SentMessage, HistoryEntry, OutboxEntry, OutboxEntryInput, QualityGate, WorktreeEntry } from '../types';
+export type { SessionMetadata, SessionInput, SessionStatus, Message, Command, PlayerReport, SentMessage, HistoryEntry, OutboxEntry, OutboxEntryInput, OutboxEntryStatus, CueOutboxEntry, RecruitOutboxEntry, ReportOutboxEntry, StopOutboxEntry, EncoreOutboxEntry, QualityGate, QualityGateCriterion, WorktreeEntry, } from '../types';
 export declare const receiveMessageSignal: import("@temporalio/workflow").SignalDefinition<[{
     from: string;
     text: string;
@@ -61,3 +61,6 @@ export declare const evaluateGateCriteriaSignal: import("@temporalio/workflow").
     evaluatedBy: string;
 }], string>;
 export declare const qualityGatesQuery: import("@temporalio/workflow").QueryDefinition<QualityGate[], [], string>;
+export declare const setWorktreeSignal: import("@temporalio/workflow").SignalDefinition<[WorktreeEntry], string>;
+export declare const removeWorktreeSignal: import("@temporalio/workflow").SignalDefinition<[string], string>;
+export declare const worktreesQuery: import("@temporalio/workflow").QueryDefinition<WorktreeEntry[], [], string>;

package/dist/workflows/signals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.qualityGatesQuery = exports.evaluateGateCriteriaSignal = exports.setQualityGateSignal = exports.outboxQuery = exports.submitOutboxUpdate = exports.checkAndSetStatusUpdate = exports.historyQuery = exports.playerReportSignal = exports.commandSignal = exports.allSentMessagesQuery = exports.allMessagesQuery = exports.pendingMessagesQuery = exports.getMetadataQuery = exports.getPartQuery = exports.updateMetadataSignal = exports.setNameSignal = exports.markDeliveredSignal = exports.setPartSignal = exports.recordSentMessageSignal = exports.receiveMessageSignal = void 0;
+exports.worktreesQuery = exports.removeWorktreeSignal = exports.setWorktreeSignal = exports.qualityGatesQuery = exports.evaluateGateCriteriaSignal = exports.setQualityGateSignal = exports.outboxQuery = exports.submitOutboxUpdate = exports.checkAndSetStatusUpdate = exports.historyQuery = exports.playerReportSignal = exports.commandSignal = exports.allSentMessagesQuery = exports.allMessagesQuery = exports.pendingMessagesQuery = exports.getMetadataQuery = exports.getPartQuery = exports.updateMetadataSignal = exports.setNameSignal = exports.markDeliveredSignal = exports.setPartSignal = exports.recordSentMessageSignal = exports.receiveMessageSignal = void 0;
 const workflow_1 = require("@temporalio/workflow");
 // ── Player Signals ──
 exports.receiveMessageSignal = (0, workflow_1.defineSignal)('receiveMessage');
@@ -30,3 +30,7 @@ exports.outboxQuery = (0, workflow_1.defineQuery)('outbox');
 exports.setQualityGateSignal = (0, workflow_1.defineSignal)('setQualityGate');
 exports.evaluateGateCriteriaSignal = (0, workflow_1.defineSignal)('evaluateGateCriteria');
 exports.qualityGatesQuery = (0, workflow_1.defineQuery)('qualityGates');
+// ── Worktree Signals + Query (conductor-only) ──
+exports.setWorktreeSignal = (0, workflow_1.defineSignal)('setWorktree');
+exports.removeWorktreeSignal = (0, workflow_1.defineSignal)('removeWorktree');
+exports.worktreesQuery = (0, workflow_1.defineQuery)('worktrees');

package/examples/agents/tempo-conductor.md

@@ -53,7 +53,7 @@ You are a combination of Product Manager, Task Decomposition Expert, and Context
 
 ## Worktree Coordination
 
-Use git worktrees when two or more engineers need to work in the same repo on different branches simultaneously. Each worktree is an independent checkout — players can build, test, and commit without interfering with each other.
+Use the `worktree` tool to give players isolated git checkouts when two or more engineers need to work in the same repo on different branches simultaneously. Each worktree is an independent checkout — players can build, test, and commit without interfering with each other.
 
 ### When to use
 
@@ -63,28 +63,16 @@ Use git worktrees when two or more engineers need to work in the same repo on di
 
 ### How to coordinate
 
-1. **Create the worktree** (you or a player with shell access):
-   ```
-   git worktree add ../ct-{task} {branch}
-   ```
-2. **Install dependencies** in the new worktree:
-   ```
-   cd ../ct-{task} && npm install
-   ```
-3. **Recruit with `workDir`** pointing to the worktree:
-   ```
-   recruit({ name: "eng-33", workDir: "../ct-{task}", ... })
-   ```
-4. **Clean up** after the task: stop the player first, then remove the worktree:
-   ```
-   git worktree remove ../ct-{task}
-   ```
-
-`recruit` already accepts `workDir` — no new tools are needed for manual worktree coordination.
+1. **Create**: `worktree({ action: "create", player: "eng-33" })` — provisions the worktree, installs dependencies, and notifies the player with the path and branch.
+2. **Work**: the player receives a cue with their worktree path and branch. They commit and push as normal.
+3. **Remove**: `worktree({ action: "remove", player: "eng-33" })` — cleans up the worktree and notifies the player. Stop the player session first on Windows (NTFS locks).
+4. **List**: `worktree({ action: "list" })` — shows all active worktree assignments.
+
+By default, `create` names the branch `{ensemble}/{player-name}`. Pass `branch` to override.
 
 ### Platform notes
 
-- **Windows**: Use short sibling paths (e.g. `../ct-feat33`) to avoid MAX_PATH limits. Always stop players before removing worktrees — NTFS file locks will block cleanup while a session is active.
+- **Windows**: Worktrees are placed in short sibling directories (e.g. `../ct-feat33`) to avoid MAX_PATH limits. Stop the player session before calling `remove` — NTFS file locks will block cleanup while a session is active.
 
 ## Handling Context Pressure
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-tempo",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "MCP server for multi-session Claude Code coordination via Temporal",
   "keywords": [
     "mcp",