claude-tempo 0.13.1 → 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/cli/commands.d.ts

@@ -32,6 +32,8 @@ interface UpOpts extends CliOverrides {
 }
 export declare function up(opts: UpOpts): Promise<void>;
 interface DownOpts extends CliOverrides {
+    ensemble: string;
+    all: boolean;
     removeMcp: boolean;
     dir: string;
 }

package/dist/cli/commands.js

@@ -893,16 +893,26 @@ function parseDuration(s) {
 }
 async function down(opts) {
     const config = (0, config_1.getConfig)(opts);
+    const ensembleName = opts.ensemble;
+    // Validate ensemble name before interpolating into query strings
+    const nameErr = (0, validation_1.validateEnsembleName)(ensembleName);
+    if (nameErr) {
+        out.error(nameErr);
+        process.exit(1);
+    }
     out.heading('claude-tempo teardown');
-    // Step 1: Terminate all active workflows
+    out.log(`  Ensemble: ${out.bold(ensembleName)}${opts.all ? ' (--all: will also stop Temporal server)' : ''}`);
+    // Step 1: Terminate workflows for the target ensemble
     const temporalUp = await isTemporalReachable(config);
+    let hasRemainingWorkflows = false;
     if (temporalUp) {
         try {
             const connection = await (0, connection_1.createTemporalConnection)(config);
             const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
-            const query = 'WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"';
+            // Terminate session workflows scoped to this ensemble
+            const sessionQuery = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running" AND ClaudeTempoEnsemble = "${ensembleName}"`;
             let terminated = 0;
-            for await (const wf of client.workflow.list({ query })) {
+            for await (const wf of client.workflow.list({ query: sessionQuery })) {
                 try {
                     const handle = client.workflow.getHandle(wf.workflowId);
                     await handle.terminate('claude-tempo down');
@@ -910,12 +920,25 @@ async function down(opts) {
                 }
                 catch { /* already closed */ }
             }
+            // Also terminate the ensemble's scheduler workflow
+            try {
+                const schedulerHandle = client.workflow.getHandle((0, config_1.schedulerWorkflowId)(ensembleName));
+                await schedulerHandle.terminate('claude-tempo down');
+                terminated++;
+            }
+            catch { /* no scheduler or already closed */ }
+            // Check if other workflows still running (to decide whether to kill Temporal)
+            const allRunningQuery = 'ExecutionStatus = "Running"';
+            for await (const _ of client.workflow.list({ query: allRunningQuery })) {
+                hasRemainingWorkflows = true;
+                break;
+            }
             await connection.close();
             if (terminated > 0) {
-                out.success(`Terminated ${terminated} active session${terminated !== 1 ? 's' : ''}`);
+                out.success(`Terminated ${terminated} workflow${terminated !== 1 ? 's' : ''} in ensemble "${ensembleName}"`);
             }
             else {
-                out.log(`  ${out.dim('No active sessions to terminate')}`);
+                out.warn(`No active workflows found for ensemble "${ensembleName}"`);
             }
         }
         catch {
@@ -924,8 +947,8 @@ async function down(opts) {
     }
     // Step 2: Kill bridge processes via PID files
     killBridgeProcesses();
-    // Step 3: Stop Temporal server
-    if (temporalUp) {
+    // Step 3: Stop Temporal server — only if --all flag or no other workflows remain
+    if (temporalUp && (opts.all || !hasRemainingWorkflows)) {
         // Find and kill the temporal dev server process
         try {
             if (process.platform === 'win32') {
@@ -941,6 +964,9 @@ async function down(opts) {
             out.warn('Could not stop Temporal server (may need to stop it manually)');
         }
     }
+    else if (temporalUp) {
+        out.log(`  ${out.dim('Temporal server left running (other ensembles still active)')}`);
+    }
     else {
         out.log(`  ${out.dim('Temporal not running')}`);
     }

package/dist/cli.js

@@ -205,6 +205,8 @@ async function main() {
             break;
         case 'down':
             await (0, commands_1.down)({
+                ensemble,
+                all: args.all,
                 removeMcp: !args.keepMcp,
                 dir: args.dir,
                 ...overrides,

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

@@ -16,6 +16,8 @@ export interface SessionMetadata {
     playerTypeDescription?: string;
     /** Player ID of who recruited this player. */
     recruitedBy?: string;
+    /** Worktree path if this session was spawned in an isolated worktree. */
+    worktreePath?: string;
 }
 export interface AgentTypeInfo {
     name: string;
@@ -44,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;
@@ -152,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/utils/validation.d.ts

@@ -30,6 +30,8 @@ export declare const GATE_CRITERIA_MAX = 20;
 export declare const GATE_CRITERION_TEXT_MAX = 512;
 /** Maximum length for gate criterion notes. */
 export declare const GATE_NOTES_MAX = 1024;
+/** Timeout for npm install in worktrees (60s). */
+export declare const WORKTREE_INSTALL_TIMEOUT = 60000;
 /** 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. */

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.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.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;
@@ -36,6 +36,8 @@ exports.GATE_CRITERIA_MAX = 20;
 exports.GATE_CRITERION_TEXT_MAX = 512;
 /** Maximum length for gate criterion notes. */
 exports.GATE_NOTES_MAX = 1024;
+/** Timeout for npm install in worktrees (60s). */
+exports.WORKTREE_INSTALL_TIMEOUT = 60000;
 /** Default number of recent messages to include as context in an encore. */
 exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = 10;
 /** Maximum length for message preview truncation. */

package/dist/utils/worktree.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Compute the base directory for all worktrees in an ensemble.
+ * Convention: `{gitRoot}/../.ct-worktrees/{ensemble}/`
+ */
+export declare function worktreeBasePath(gitRoot: string, ensemble: string): string;
+export interface CreateWorktreeOpts {
+    gitRoot: string;
+    ensemble: string;
+    playerName: string;
+    branch?: string;
+}
+export interface CreateWorktreeResult {
+    /** Absolute path to the worktree directory. */
+    path: string;
+    /** Branch name used for the worktree. */
+    branch: string;
+    /** Whether the worktree was newly created (false if it already existed). */
+    created: boolean;
+}
+/**
+ * Create a git worktree for a player. If the worktree already exists
+ * at the expected path, returns it without re-creating.
+ *
+ * Branch defaults to `{ensemble}/{playerName}` if not specified.
+ */
+export declare function createWorktree(opts: CreateWorktreeOpts): CreateWorktreeResult;
+/**
+ * Install dependencies in a worktree directory.
+ *
+ * Detects the package manager (npm, yarn, pnpm) by lockfile presence.
+ * Failure or timeout is logged but does not throw — the recruit proceeds
+ * with whatever state the worktree is in.
+ */
+export declare function installDependencies(worktreePath: string, timeoutMs?: number): void;
+/**
+ * Remove a git worktree.
+ */
+export declare function removeWorktree(worktreePath: string): void;

package/dist/utils/worktree.js

@@ -0,0 +1,168 @@
+"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.worktreeBasePath = worktreeBasePath;
+exports.createWorktree = createWorktree;
+exports.installDependencies = installDependencies;
+exports.removeWorktree = removeWorktree;
+/**
+ * Git worktree helpers for player isolation.
+ *
+ * Creates and manages git worktrees so each player can work on an
+ * isolated copy of the repository without conflicting with others.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const validation_1 = require("./validation");
+const log = (...args) => console.error('[claude-tempo:worktree]', ...args);
+/**
+ * Compute the base directory for all worktrees in an ensemble.
+ * Convention: `{gitRoot}/../.ct-worktrees/{ensemble}/`
+ */
+function worktreeBasePath(gitRoot, ensemble) {
+    return path.join(path.dirname(gitRoot), '.ct-worktrees', ensemble);
+}
+/**
+ * Create a git worktree for a player. If the worktree already exists
+ * at the expected path, returns it without re-creating.
+ *
+ * Branch defaults to `{ensemble}/{playerName}` if not specified.
+ */
+function createWorktree(opts) {
+    const { gitRoot, ensemble, playerName } = opts;
+    const branch = opts.branch || `${ensemble}/${playerName}`;
+    const basePath = worktreeBasePath(gitRoot, ensemble);
+    const wtPath = path.join(basePath, playerName);
+    // If worktree already exists, reuse it
+    if ((0, fs_1.existsSync)(path.join(wtPath, '.git'))) {
+        log(`Worktree already exists at "${wtPath}" — reusing`);
+        return { path: wtPath, branch, created: false };
+    }
+    // Ensure base directory exists
+    (0, fs_1.mkdirSync)(basePath, { recursive: true });
+    // Check if the branch already has a worktree (would cause git error)
+    try {
+        const existing = (0, child_process_1.execFileSync)('git', ['worktree', 'list', '--porcelain'], {
+            cwd: gitRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Parse porcelain output: "branch refs/heads/{branch}" lines
+        const branchRef = `refs/heads/${branch}`;
+        if (existing.includes(`branch ${branchRef}`)) {
+            throw new Error(`Branch "${branch}" already has an active worktree. ` +
+                `Remove it first with \`git worktree remove\` or choose a different branch.`);
+        }
+    }
+    catch (err) {
+        // Re-throw our own error, swallow git failures (e.g., no worktrees yet)
+        if (err.message?.includes('already has an active worktree'))
+            throw err;
+    }
+    // Create the worktree. Use -B to create/reset the branch.
+    try {
+        log(`Creating worktree: git worktree add -B ${branch} ${wtPath}`);
+        (0, child_process_1.execFileSync)('git', ['worktree', 'add', '-B', branch, wtPath], {
+            cwd: gitRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        const msg = err.stderr || err.stdout || err.message || String(err);
+        throw new Error(`Failed to create worktree at "${wtPath}": ${msg.trim()}`);
+    }
+    return { path: wtPath, branch, created: true };
+}
+/**
+ * Install dependencies in a worktree directory.
+ *
+ * Detects the package manager (npm, yarn, pnpm) by lockfile presence.
+ * Failure or timeout is logged but does not throw — the recruit proceeds
+ * with whatever state the worktree is in.
+ */
+function installDependencies(worktreePath, timeoutMs = validation_1.WORKTREE_INSTALL_TIMEOUT) {
+    // Detect package manager by lockfile
+    let cmd;
+    let args;
+    if ((0, fs_1.existsSync)(path.join(worktreePath, 'pnpm-lock.yaml'))) {
+        cmd = 'pnpm';
+        args = ['install', '--frozen-lockfile'];
+    }
+    else if ((0, fs_1.existsSync)(path.join(worktreePath, 'yarn.lock'))) {
+        cmd = 'yarn';
+        args = ['install', '--frozen-lockfile'];
+    }
+    else if ((0, fs_1.existsSync)(path.join(worktreePath, 'package-lock.json')) || (0, fs_1.existsSync)(path.join(worktreePath, 'package.json'))) {
+        cmd = 'npm';
+        args = ['install'];
+    }
+    else {
+        log(`No package.json found in "${worktreePath}" — skipping install`);
+        return;
+    }
+    try {
+        log(`Installing dependencies in "${worktreePath}": ${cmd} ${args.join(' ')}`);
+        (0, child_process_1.execFileSync)(cmd, args, {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            timeout: timeoutMs,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        log(`Dependencies installed successfully in "${worktreePath}"`);
+    }
+    catch (err) {
+        // Log warning but don't throw — recruit should still proceed
+        const msg = err.killed ? `Timed out after ${timeoutMs}ms` : (err.stderr || err.message || String(err));
+        log(`Warning: dependency install failed in "${worktreePath}": ${msg}`);
+    }
+}
+/**
+ * Remove a git worktree.
+ */
+function removeWorktree(worktreePath) {
+    try {
+        (0, child_process_1.execFileSync)('git', ['worktree', 'remove', '--force', worktreePath], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        log(`Removed worktree at "${worktreePath}"`);
+    }
+    catch (err) {
+        const msg = err.stderr || err.message || String(err);
+        log(`Warning: failed to remove worktree at "${worktreePath}": ${msg.trim()}`);
+    }
+}