@stanco323/oh-my-claude-code 4.10.3

package/dist/team/runtime.js

@@ -0,0 +1,819 @@
+import { mkdir, writeFile, readFile, rm, rename } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { buildWorkerArgv, resolveValidatedBinaryPath, getWorkerEnv as getModelWorkerEnv, isPromptModeAgent, getPromptModeArgs, resolveClaudeWorkerModel } from './model-contract.js';
+import { validateTeamName } from './team-name.js';
+import { createTeamSession, spawnWorkerInPane, sendToWorker, isWorkerAlive, killTeamSession, resolveSplitPaneWorkerPaneIds, waitForPaneReady, applyMainVerticalLayout, } from './tmux-session.js';
+import { composeInitialInbox, ensureWorkerStateDir, writeWorkerOverlay, generateTriggerMessage, } from './worker-bootstrap.js';
+import { cleanupTeamWorktrees } from './git-worktree.js';
+import { withTaskLock, writeTaskFailure, DEFAULT_MAX_TASK_RETRIES, } from './task-file-ops.js';
+function workerName(index) {
+    return `worker-${index + 1}`;
+}
+function stateRoot(cwd, teamName) {
+    validateTeamName(teamName);
+    return join(cwd, `.omc/state/team/${teamName}`);
+}
+async function writeJson(filePath, data) {
+    await mkdir(join(filePath, '..'), { recursive: true });
+    await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+async function readJsonSafe(filePath) {
+    const isDoneSignalPath = filePath.endsWith('done.json');
+    const maxAttempts = isDoneSignalPath ? 4 : 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                if (!isDoneSignalPath || attempt === maxAttempts) {
+                    return null;
+                }
+            }
+        }
+        catch (error) {
+            const isMissingDoneSignal = isDoneSignalPath
+                && typeof error === 'object'
+                && error !== null
+                && 'code' in error
+                && error.code === 'ENOENT';
+            if (isMissingDoneSignal) {
+                return null;
+            }
+            if (!isDoneSignalPath || attempt === maxAttempts) {
+                return null;
+            }
+        }
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    return null;
+}
+function parseWorkerIndex(workerNameValue) {
+    const match = workerNameValue.match(/^worker-(\d+)$/);
+    if (!match)
+        return 0;
+    const parsed = Number.parseInt(match[1], 10) - 1;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+function taskPath(root, taskId) {
+    return join(root, 'tasks', `${taskId}.json`);
+}
+async function writePanesTrackingFileIfPresent(runtime) {
+    const jobId = process.env.OMC_JOB_ID;
+    const omcJobsDir = process.env.OMC_JOBS_DIR;
+    if (!jobId || !omcJobsDir)
+        return;
+    const panesPath = join(omcJobsDir, `${jobId}-panes.json`);
+    const tempPath = `${panesPath}.tmp`;
+    await writeFile(tempPath, JSON.stringify({
+        paneIds: [...runtime.workerPaneIds],
+        leaderPaneId: runtime.leaderPaneId,
+        sessionName: runtime.sessionName,
+        ownsWindow: Boolean(runtime.ownsWindow),
+    }), 'utf-8');
+    await rename(tempPath, panesPath);
+}
+async function readTask(root, taskId) {
+    return readJsonSafe(taskPath(root, taskId));
+}
+async function writeTask(root, task) {
+    await writeJson(taskPath(root, task.id), task);
+}
+async function markTaskInProgress(root, taskId, owner, teamName, cwd) {
+    const result = await withTaskLock(teamName, taskId, async () => {
+        const task = await readTask(root, taskId);
+        if (!task || task.status !== 'pending')
+            return false;
+        task.status = 'in_progress';
+        task.owner = owner;
+        task.assignedAt = new Date().toISOString();
+        await writeTask(root, task);
+        return true;
+    }, { cwd });
+    // withTaskLock returns null if the lock could not be acquired — treat as not claimed
+    return result ?? false;
+}
+async function resetTaskToPending(root, taskId, teamName, cwd) {
+    await withTaskLock(teamName, taskId, async () => {
+        const task = await readTask(root, taskId);
+        if (!task)
+            return;
+        task.status = 'pending';
+        task.owner = null;
+        task.assignedAt = undefined;
+        await writeTask(root, task);
+    }, { cwd });
+}
+async function markTaskFromDone(root, teamName, cwd, taskId, status, summary) {
+    await withTaskLock(teamName, taskId, async () => {
+        const task = await readTask(root, taskId);
+        if (!task)
+            return;
+        task.status = status;
+        task.result = summary;
+        task.summary = summary;
+        if (status === 'completed') {
+            task.completedAt = new Date().toISOString();
+        }
+        else {
+            task.failedAt = new Date().toISOString();
+        }
+        await writeTask(root, task);
+    }, { cwd });
+}
+async function applyDeadPaneTransition(runtime, workerNameValue, taskId) {
+    const root = stateRoot(runtime.cwd, runtime.teamName);
+    const transition = await withTaskLock(runtime.teamName, taskId, async () => {
+        const task = await readTask(root, taskId);
+        if (!task)
+            return { action: 'skipped' };
+        if (task.status === 'completed' || task.status === 'failed') {
+            return { action: 'skipped' };
+        }
+        if (task.status !== 'in_progress' || task.owner !== workerNameValue) {
+            return { action: 'skipped' };
+        }
+        const failure = await writeTaskFailure(runtime.teamName, taskId, `Worker pane died before done.json was written (${workerNameValue})`, { cwd: runtime.cwd });
+        const retryCount = failure.retryCount;
+        if (retryCount >= DEFAULT_MAX_TASK_RETRIES) {
+            task.status = 'failed';
+            task.owner = workerNameValue;
+            task.summary = `Worker pane died before done.json was written (${workerNameValue})`;
+            task.result = task.summary;
+            task.failedAt = new Date().toISOString();
+            await writeTask(root, task);
+            return { action: 'failed', retryCount };
+        }
+        task.status = 'pending';
+        task.owner = null;
+        task.assignedAt = undefined;
+        await writeTask(root, task);
+        return { action: 'requeued', retryCount };
+    }, { cwd: runtime.cwd });
+    return transition ?? { action: 'skipped' };
+}
+async function nextPendingTaskIndex(runtime) {
+    const root = stateRoot(runtime.cwd, runtime.teamName);
+    const transientReadRetryAttempts = 3;
+    const transientReadRetryDelayMs = 15;
+    for (let i = 0; i < runtime.config.tasks.length; i++) {
+        const taskId = String(i + 1);
+        let task = await readTask(root, taskId);
+        if (!task) {
+            for (let attempt = 1; attempt < transientReadRetryAttempts; attempt++) {
+                await new Promise(resolve => setTimeout(resolve, transientReadRetryDelayMs));
+                task = await readTask(root, taskId);
+                if (task)
+                    break;
+            }
+        }
+        if (task?.status === 'pending')
+            return i;
+    }
+    return null;
+}
+async function notifyPaneWithRetry(sessionName, paneId, message, maxAttempts = 6, retryDelayMs = 350) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (await sendToWorker(sessionName, paneId, message)) {
+            return true;
+        }
+        if (attempt < maxAttempts) {
+            await new Promise(r => setTimeout(r, retryDelayMs));
+        }
+    }
+    return false;
+}
+export async function allTasksTerminal(runtime) {
+    const root = stateRoot(runtime.cwd, runtime.teamName);
+    for (let i = 0; i < runtime.config.tasks.length; i++) {
+        const task = await readTask(root, String(i + 1));
+        if (!task)
+            return false;
+        if (task.status !== 'completed' && task.status !== 'failed')
+            return false;
+    }
+    return true;
+}
+/**
+ * Build the initial task instruction written to a worker's inbox.
+ * Includes task ID, subject, full description, and done-signal path.
+ */
+function buildInitialTaskInstruction(teamName, workerName, task, taskId) {
+    const donePath = `.omc/state/team/${teamName}/workers/${workerName}/done.json`;
+    return [
+        `## Initial Task Assignment`,
+        `Task ID: ${taskId}`,
+        `Worker: ${workerName}`,
+        `Subject: ${task.subject}`,
+        ``,
+        task.description,
+        ``,
+        `When complete, write done signal to ${donePath}:`,
+        `{"taskId":"${taskId}","status":"completed","summary":"<brief summary>","completedAt":"<ISO timestamp>"}`,
+        ``,
+        `IMPORTANT: Execute ONLY the task assigned to you in this inbox. After writing done.json, exit immediately. Do not read from the task directory or claim other tasks.`,
+    ].join('\n');
+}
+/**
+ * Start a new team: create tmux session, spawn workers, wait for ready.
+ */
+export async function startTeam(config) {
+    const { teamName, agentTypes, tasks, cwd } = config;
+    validateTeamName(teamName);
+    // Validate CLIs once and pin absolute binary paths for consistent spawn behavior.
+    const resolvedBinaryPaths = {};
+    for (const agentType of [...new Set(agentTypes)]) {
+        resolvedBinaryPaths[agentType] = resolveValidatedBinaryPath(agentType);
+    }
+    const root = stateRoot(cwd, teamName);
+    await mkdir(join(root, 'tasks'), { recursive: true });
+    await mkdir(join(root, 'mailbox'), { recursive: true });
+    // Write initial config before tmux topology is created.
+    await writeJson(join(root, 'config.json'), config);
+    // Create task files
+    for (let i = 0; i < tasks.length; i++) {
+        const taskId = String(i + 1);
+        await writeJson(join(root, 'tasks', `${taskId}.json`), {
+            id: taskId,
+            subject: tasks[i].subject,
+            description: tasks[i].description,
+            status: 'pending',
+            owner: null,
+            result: null,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    // Set up worker state dirs and overlays for all potential workers up front
+    // (overlays are cheap; workers are spawned on-demand later)
+    const workerNames = [];
+    for (let i = 0; i < tasks.length; i++) {
+        const wName = workerName(i);
+        workerNames.push(wName);
+        const agentType = agentTypes[i % agentTypes.length] ?? agentTypes[0] ?? 'claude';
+        await ensureWorkerStateDir(teamName, wName, cwd);
+        await writeWorkerOverlay({
+            teamName, workerName: wName, agentType,
+            tasks: tasks.map((t, idx) => ({ id: String(idx + 1), subject: t.subject, description: t.description })),
+            cwd,
+        });
+    }
+    // Create tmux session with ZERO worker panes (leader only).
+    // Workers are spawned on-demand by the orchestrator.
+    const session = await createTeamSession(teamName, 0, cwd, {
+        newWindow: Boolean(config.newWindow),
+    });
+    const runtime = {
+        teamName,
+        sessionName: session.sessionName,
+        leaderPaneId: session.leaderPaneId,
+        config: {
+            ...config,
+            tmuxSession: session.sessionName,
+            leaderPaneId: session.leaderPaneId,
+            tmuxOwnsWindow: session.sessionMode !== 'split-pane',
+        },
+        workerNames,
+        workerPaneIds: session.workerPaneIds, // initially empty []
+        activeWorkers: new Map(),
+        cwd,
+        resolvedBinaryPaths,
+        ownsWindow: session.sessionMode !== 'split-pane',
+    };
+    await writeJson(join(root, 'config.json'), runtime.config);
+    const maxConcurrentWorkers = agentTypes.length;
+    for (let i = 0; i < maxConcurrentWorkers; i++) {
+        const taskIndex = await nextPendingTaskIndex(runtime);
+        if (taskIndex == null)
+            break;
+        await spawnWorkerForTask(runtime, workerName(i), taskIndex);
+    }
+    runtime.stopWatchdog = watchdogCliWorkers(runtime, 1000);
+    return runtime;
+}
+/**
+ * Monitor team: poll worker health, detect stalls, return snapshot.
+ */
+export async function monitorTeam(teamName, cwd, workerPaneIds) {
+    validateTeamName(teamName);
+    const monitorStartedAt = Date.now();
+    const root = stateRoot(cwd, teamName);
+    // Read task counts
+    const taskScanStartedAt = Date.now();
+    const taskCounts = { pending: 0, inProgress: 0, completed: 0, failed: 0 };
+    try {
+        const { readdir } = await import('fs/promises');
+        const taskFiles = await readdir(join(root, 'tasks'));
+        for (const f of taskFiles.filter(f => f.endsWith('.json'))) {
+            const task = await readJsonSafe(join(root, 'tasks', f));
+            if (task?.status === 'pending')
+                taskCounts.pending++;
+            else if (task?.status === 'in_progress')
+                taskCounts.inProgress++;
+            else if (task?.status === 'completed')
+                taskCounts.completed++;
+            else if (task?.status === 'failed')
+                taskCounts.failed++;
+        }
+    }
+    catch { /* tasks dir may not exist yet */ }
+    const listTasksMs = Date.now() - taskScanStartedAt;
+    // Check worker health
+    const workerScanStartedAt = Date.now();
+    const workers = [];
+    const deadWorkers = [];
+    for (let i = 0; i < workerPaneIds.length; i++) {
+        const wName = `worker-${i + 1}`;
+        const paneId = workerPaneIds[i];
+        const alive = await isWorkerAlive(paneId);
+        const heartbeatPath = join(root, 'workers', wName, 'heartbeat.json');
+        const heartbeat = await readJsonSafe(heartbeatPath);
+        // Detect stall: no heartbeat update in 60s
+        let stalled = false;
+        if (heartbeat?.updatedAt) {
+            const age = Date.now() - new Date(heartbeat.updatedAt).getTime();
+            stalled = age > 60_000;
+        }
+        const status = {
+            workerName: wName,
+            alive,
+            paneId,
+            currentTaskId: heartbeat?.currentTaskId,
+            lastHeartbeat: heartbeat?.updatedAt,
+            stalled,
+        };
+        workers.push(status);
+        if (!alive)
+            deadWorkers.push(wName);
+        // Note: CLI workers (codex/gemini) may not write heartbeat.json — stall is advisory only
+    }
+    const workerScanMs = Date.now() - workerScanStartedAt;
+    // Infer phase from task counts
+    let phase = 'executing';
+    if (taskCounts.inProgress === 0 && taskCounts.pending > 0 && taskCounts.completed === 0) {
+        phase = 'planning';
+    }
+    else if (taskCounts.failed > 0 && taskCounts.pending === 0 && taskCounts.inProgress === 0) {
+        phase = 'fixing';
+    }
+    else if (taskCounts.completed > 0 && taskCounts.pending === 0 && taskCounts.inProgress === 0 && taskCounts.failed === 0) {
+        phase = 'completed';
+    }
+    return {
+        teamName,
+        phase,
+        workers,
+        taskCounts,
+        deadWorkers,
+        monitorPerformance: {
+            listTasksMs,
+            workerScanMs,
+            totalMs: Date.now() - monitorStartedAt,
+        },
+    };
+}
+/**
+ * Runtime-owned worker watchdog/orchestrator loop.
+ * Handles done.json completion, dead pane failures, and next-task spawning.
+ */
+export function watchdogCliWorkers(runtime, intervalMs) {
+    let tickInFlight = false;
+    let consecutiveFailures = 0;
+    const MAX_CONSECUTIVE_FAILURES = 3;
+    // Track consecutive unresponsive ticks per worker
+    const unresponsiveCounts = new Map();
+    const UNRESPONSIVE_KILL_THRESHOLD = 3;
+    const tick = async () => {
+        if (tickInFlight)
+            return;
+        tickInFlight = true;
+        try {
+            const workers = [...runtime.activeWorkers.entries()];
+            if (workers.length === 0)
+                return;
+            const root = stateRoot(runtime.cwd, runtime.teamName);
+            // Collect done signals and alive checks in parallel to avoid O(N×300ms) sequential tmux calls.
+            const [doneSignals, aliveResults] = await Promise.all([
+                Promise.all(workers.map(([wName]) => {
+                    const donePath = join(root, 'workers', wName, 'done.json');
+                    return readJsonSafe(donePath);
+                })),
+                Promise.all(workers.map(([, active]) => isWorkerAlive(active.paneId))),
+            ]);
+            for (let i = 0; i < workers.length; i++) {
+                const [wName, active] = workers[i];
+                const donePath = join(root, 'workers', wName, 'done.json');
+                const signal = doneSignals[i];
+                // Process done.json first if present
+                if (signal) {
+                    unresponsiveCounts.delete(wName);
+                    await markTaskFromDone(root, runtime.teamName, runtime.cwd, signal.taskId || active.taskId, signal.status, signal.summary);
+                    try {
+                        const { unlink } = await import('fs/promises');
+                        await unlink(donePath);
+                    }
+                    catch {
+                        // no-op
+                    }
+                    await killWorkerPane(runtime, wName, active.paneId);
+                    if (!(await allTasksTerminal(runtime))) {
+                        const nextTaskIndexValue = await nextPendingTaskIndex(runtime);
+                        if (nextTaskIndexValue != null) {
+                            await spawnWorkerForTask(runtime, wName, nextTaskIndexValue);
+                        }
+                    }
+                    continue;
+                }
+                // Dead pane without done.json => retry as transient failure when possible
+                const alive = aliveResults[i];
+                if (!alive) {
+                    unresponsiveCounts.delete(wName);
+                    const transition = await applyDeadPaneTransition(runtime, wName, active.taskId);
+                    if (transition.action === 'requeued') {
+                        const retryCount = transition.retryCount ?? 1;
+                        console.warn(`[watchdog] worker ${wName} dead pane — requeuing task ${active.taskId} (retry ${retryCount}/${DEFAULT_MAX_TASK_RETRIES})`);
+                    }
+                    await killWorkerPane(runtime, wName, active.paneId);
+                    if (!(await allTasksTerminal(runtime))) {
+                        const nextTaskIndexValue = await nextPendingTaskIndex(runtime);
+                        if (nextTaskIndexValue != null) {
+                            await spawnWorkerForTask(runtime, wName, nextTaskIndexValue);
+                        }
+                    }
+                    continue;
+                }
+                // Pane is alive but no done.json — check heartbeat for stall detection
+                const heartbeatPath = join(root, 'workers', wName, 'heartbeat.json');
+                const heartbeat = await readJsonSafe(heartbeatPath);
+                const isStalled = heartbeat?.updatedAt
+                    ? Date.now() - new Date(heartbeat.updatedAt).getTime() > 60_000
+                    : false;
+                if (isStalled) {
+                    const count = (unresponsiveCounts.get(wName) ?? 0) + 1;
+                    unresponsiveCounts.set(wName, count);
+                    if (count < UNRESPONSIVE_KILL_THRESHOLD) {
+                        console.warn(`[watchdog] worker ${wName} unresponsive (${count}/${UNRESPONSIVE_KILL_THRESHOLD}), task ${active.taskId}`);
+                    }
+                    else {
+                        console.warn(`[watchdog] worker ${wName} unresponsive ${count} consecutive ticks — killing and reassigning task ${active.taskId}`);
+                        unresponsiveCounts.delete(wName);
+                        const transition = await applyDeadPaneTransition(runtime, wName, active.taskId);
+                        if (transition.action === 'requeued') {
+                            console.warn(`[watchdog] worker ${wName} stall-killed — requeuing task ${active.taskId} (retry ${transition.retryCount}/${DEFAULT_MAX_TASK_RETRIES})`);
+                        }
+                        await killWorkerPane(runtime, wName, active.paneId);
+                        if (!(await allTasksTerminal(runtime))) {
+                            const nextTaskIndexValue = await nextPendingTaskIndex(runtime);
+                            if (nextTaskIndexValue != null) {
+                                await spawnWorkerForTask(runtime, wName, nextTaskIndexValue);
+                            }
+                        }
+                    }
+                }
+                else {
+                    // Worker is responsive — reset counter
+                    unresponsiveCounts.delete(wName);
+                }
+            }
+            // Reset failure counter on a successful tick
+            consecutiveFailures = 0;
+        }
+        catch (err) {
+            consecutiveFailures++;
+            console.warn('[watchdog] tick error:', err);
+            if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                console.warn(`[watchdog] ${consecutiveFailures} consecutive failures — marking team as failed`);
+                try {
+                    const root = stateRoot(runtime.cwd, runtime.teamName);
+                    await writeJson(join(root, 'watchdog-failed.json'), {
+                        failedAt: new Date().toISOString(),
+                        consecutiveFailures,
+                        lastError: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                catch {
+                    // best-effort
+                }
+                clearInterval(intervalId);
+            }
+        }
+        finally {
+            tickInFlight = false;
+        }
+    };
+    const intervalId = setInterval(() => { tick(); }, intervalMs);
+    return () => clearInterval(intervalId);
+}
+/**
+ * Spawn a worker pane for an explicit task assignment.
+ */
+export async function spawnWorkerForTask(runtime, workerNameValue, taskIndex) {
+    const root = stateRoot(runtime.cwd, runtime.teamName);
+    const taskId = String(taskIndex + 1);
+    const task = runtime.config.tasks[taskIndex];
+    if (!task)
+        return '';
+    const marked = await markTaskInProgress(root, taskId, workerNameValue, runtime.teamName, runtime.cwd);
+    if (!marked)
+        return '';
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    const splitTarget = runtime.workerPaneIds.length === 0
+        ? runtime.leaderPaneId
+        : runtime.workerPaneIds[runtime.workerPaneIds.length - 1];
+    const splitType = runtime.workerPaneIds.length === 0 ? '-h' : '-v';
+    const splitResult = await execFileAsync('tmux', [
+        'split-window', splitType, '-t', splitTarget,
+        '-d', '-P', '-F', '#{pane_id}',
+        '-c', runtime.cwd,
+    ]);
+    const paneId = splitResult.stdout.split('\n')[0]?.trim();
+    if (!paneId) {
+        try {
+            await resetTaskToPending(root, taskId, runtime.teamName, runtime.cwd);
+        }
+        catch {
+            // best-effort revert
+        }
+        return '';
+    }
+    const workerIndex = parseWorkerIndex(workerNameValue);
+    const agentType = runtime.config.agentTypes[workerIndex % runtime.config.agentTypes.length]
+        ?? runtime.config.agentTypes[0]
+        ?? 'claude';
+    const usePromptMode = isPromptModeAgent(agentType);
+    // Build the initial task instruction and write inbox before spawn.
+    // For prompt-mode agents the instruction is passed via CLI flag;
+    // for interactive agents it is sent via tmux send-keys after startup.
+    const instruction = buildInitialTaskInstruction(runtime.teamName, workerNameValue, task, taskId);
+    await composeInitialInbox(runtime.teamName, workerNameValue, instruction, runtime.cwd);
+    const envVars = getModelWorkerEnv(runtime.teamName, workerNameValue, agentType);
+    const resolvedBinaryPath = runtime.resolvedBinaryPaths?.[agentType] ?? resolveValidatedBinaryPath(agentType);
+    if (!runtime.resolvedBinaryPaths) {
+        runtime.resolvedBinaryPaths = {};
+    }
+    runtime.resolvedBinaryPaths[agentType] = resolvedBinaryPath;
+    // Resolve model from environment variables based on agent type.
+    // For Claude agents on Bedrock/Vertex, resolve the provider-specific model
+    // so workers don't fall back to invalid Anthropic API model names. (#1695)
+    const modelForAgent = (() => {
+        if (agentType === 'codex') {
+            return process.env.OMC_EXTERNAL_MODELS_DEFAULT_CODEX_MODEL
+                || process.env.OMC_CODEX_DEFAULT_MODEL
+                || undefined;
+        }
+        if (agentType === 'gemini') {
+            return process.env.OMC_EXTERNAL_MODELS_DEFAULT_GEMINI_MODEL
+                || process.env.OMC_GEMINI_DEFAULT_MODEL
+                || undefined;
+        }
+        // Claude agents: resolve Bedrock/Vertex model when on those providers
+        return resolveClaudeWorkerModel();
+    })();
+    const [launchBinary, ...launchArgs] = buildWorkerArgv(agentType, {
+        teamName: runtime.teamName,
+        workerName: workerNameValue,
+        cwd: runtime.cwd,
+        resolvedBinaryPath,
+        model: modelForAgent,
+    });
+    // For prompt-mode agents (e.g. Gemini Ink TUI), pass instruction via CLI
+    // flag so tmux send-keys never needs to interact with the TUI input widget.
+    if (usePromptMode) {
+        const promptArgs = getPromptModeArgs(agentType, generateTriggerMessage(runtime.teamName, workerNameValue));
+        launchArgs.push(...promptArgs);
+    }
+    const paneConfig = {
+        teamName: runtime.teamName,
+        workerName: workerNameValue,
+        envVars,
+        launchBinary,
+        launchArgs,
+        cwd: runtime.cwd,
+    };
+    await spawnWorkerInPane(runtime.sessionName, paneId, paneConfig);
+    runtime.workerPaneIds.push(paneId);
+    runtime.activeWorkers.set(workerNameValue, { paneId, taskId, spawnedAt: Date.now() });
+    await applyMainVerticalLayout(runtime.sessionName);
+    try {
+        await writePanesTrackingFileIfPresent(runtime);
+    }
+    catch {
+        // panes tracking is best-effort
+    }
+    if (!usePromptMode) {
+        // Interactive mode: wait for pane readiness, handle trust-confirm, then
+        // send instruction via tmux send-keys.
+        const paneReady = await waitForPaneReady(paneId);
+        if (!paneReady) {
+            await killWorkerPane(runtime, workerNameValue, paneId);
+            await resetTaskToPending(root, taskId, runtime.teamName, runtime.cwd);
+            throw new Error(`worker_pane_not_ready:${workerNameValue}`);
+        }
+        if (agentType === 'gemini') {
+            const confirmed = await notifyPaneWithRetry(runtime.sessionName, paneId, '1');
+            if (!confirmed) {
+                await killWorkerPane(runtime, workerNameValue, paneId);
+                await resetTaskToPending(root, taskId, runtime.teamName, runtime.cwd);
+                throw new Error(`worker_notify_failed:${workerNameValue}:trust-confirm`);
+            }
+            await new Promise(r => setTimeout(r, 800));
+        }
+        const notified = await notifyPaneWithRetry(runtime.sessionName, paneId, generateTriggerMessage(runtime.teamName, workerNameValue));
+        if (!notified) {
+            await killWorkerPane(runtime, workerNameValue, paneId);
+            await resetTaskToPending(root, taskId, runtime.teamName, runtime.cwd);
+            throw new Error(`worker_notify_failed:${workerNameValue}:initial-inbox`);
+        }
+    }
+    // Prompt-mode agents: instruction already passed via CLI flag at spawn.
+    // No trust-confirm or tmux send-keys interaction needed.
+    return paneId;
+}
+/**
+ * Kill a single worker pane and update runtime state.
+ */
+export async function killWorkerPane(runtime, workerNameValue, paneId) {
+    try {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        await execFileAsync('tmux', ['kill-pane', '-t', paneId]);
+    }
+    catch {
+        // idempotent: pane may already be gone
+    }
+    const paneIndex = runtime.workerPaneIds.indexOf(paneId);
+    if (paneIndex >= 0) {
+        runtime.workerPaneIds.splice(paneIndex, 1);
+    }
+    runtime.activeWorkers.delete(workerNameValue);
+    try {
+        await writePanesTrackingFileIfPresent(runtime);
+    }
+    catch {
+        // panes tracking is best-effort
+    }
+}
+/**
+ * Assign a task to a specific worker via inbox + tmux trigger.
+ */
+export async function assignTask(teamName, taskId, targetWorkerName, paneId, sessionName, cwd) {
+    const root = stateRoot(cwd, teamName);
+    const taskFilePath = join(root, 'tasks', `${taskId}.json`);
+    let previousTaskState = null;
+    await withTaskLock(teamName, taskId, async () => {
+        const t = await readJsonSafe(taskFilePath);
+        previousTaskState = t ? {
+            status: t.status,
+            owner: t.owner,
+            assignedAt: t.assignedAt,
+        } : null;
+        if (t) {
+            t.owner = targetWorkerName;
+            t.status = 'in_progress';
+            t.assignedAt = new Date().toISOString();
+            await writeJson(taskFilePath, t);
+        }
+    }, { cwd });
+    // Write to worker inbox
+    const inboxPath = join(root, 'workers', targetWorkerName, 'inbox.md');
+    await mkdir(join(inboxPath, '..'), { recursive: true });
+    const msg = `\n\n---\n## New Task Assignment\nTask ID: ${taskId}\nClaim and execute task from: .omc/state/team/${teamName}/tasks/${taskId}.json\n`;
+    const { appendFile } = await import('fs/promises');
+    await appendFile(inboxPath, msg, 'utf-8');
+    // Send tmux trigger
+    const notified = await notifyPaneWithRetry(sessionName, paneId, `new-task:${taskId}`);
+    if (!notified) {
+        if (previousTaskState) {
+            await withTaskLock(teamName, taskId, async () => {
+                const t = await readJsonSafe(taskFilePath);
+                if (t) {
+                    t.status = previousTaskState.status;
+                    t.owner = previousTaskState.owner;
+                    t.assignedAt = previousTaskState.assignedAt;
+                    await writeJson(taskFilePath, t);
+                }
+            }, { cwd });
+        }
+        throw new Error(`worker_notify_failed:${targetWorkerName}:new-task:${taskId}`);
+    }
+}
+/**
+ * Gracefully shut down all workers and clean up.
+ */
+export async function shutdownTeam(teamName, sessionName, cwd, timeoutMs = 30_000, workerPaneIds, leaderPaneId, ownsWindow) {
+    const root = stateRoot(cwd, teamName);
+    // Write shutdown request
+    await writeJson(join(root, 'shutdown.json'), {
+        requestedAt: new Date().toISOString(),
+        teamName,
+    });
+    const configData = await readJsonSafe(join(root, 'config.json'));
+    // CLI workers (claude/codex/gemini tmux pane processes) never write shutdown-ack.json.
+    // Polling for ACK files on CLI worker teams wastes the full timeoutMs on every shutdown.
+    // Detect CLI worker teams by checking if all agent types are known CLI types, and skip
+    // ACK polling — the tmux kill below handles process cleanup instead.
+    const CLI_AGENT_TYPES = new Set(['claude', 'codex', 'gemini']);
+    const agentTypes = configData?.agentTypes ?? [];
+    const isCliWorkerTeam = agentTypes.length > 0 && agentTypes.every(t => CLI_AGENT_TYPES.has(t));
+    if (!isCliWorkerTeam) {
+        // Bridge daemon workers do write shutdown-ack.json — poll for them.
+        const deadline = Date.now() + timeoutMs;
+        const workerCount = configData?.workerCount ?? 0;
+        const expectedAcks = Array.from({ length: workerCount }, (_, i) => `worker-${i + 1}`);
+        while (Date.now() < deadline && expectedAcks.length > 0) {
+            for (const wName of [...expectedAcks]) {
+                const ackPath = join(root, 'workers', wName, 'shutdown-ack.json');
+                if (existsSync(ackPath)) {
+                    expectedAcks.splice(expectedAcks.indexOf(wName), 1);
+                }
+            }
+            if (expectedAcks.length > 0) {
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+    }
+    // CLI worker teams: skip ACK polling — process exit is handled by tmux kill below.
+    // Kill tmux session (or just worker panes in split-pane mode)
+    const sessionMode = (ownsWindow ?? Boolean(configData?.tmuxOwnsWindow))
+        ? (sessionName.includes(':') ? 'dedicated-window' : 'detached-session')
+        : 'split-pane';
+    const effectiveWorkerPaneIds = sessionMode === 'split-pane'
+        ? await resolveSplitPaneWorkerPaneIds(sessionName, workerPaneIds, leaderPaneId)
+        : workerPaneIds;
+    await killTeamSession(sessionName, effectiveWorkerPaneIds, leaderPaneId, { sessionMode });
+    // Clean up state
+    try {
+        cleanupTeamWorktrees(teamName, cwd);
+    }
+    catch {
+        // best-effort: worktree cleanup is dormant in current runtime paths
+    }
+    try {
+        await rm(root, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Resume an existing team from persisted state.
+ * Reconstructs activeWorkers by scanning task files for in_progress tasks
+ * so the watchdog loop can continue processing without stalling.
+ */
+export async function resumeTeam(teamName, cwd) {
+    const root = stateRoot(cwd, teamName);
+    const configData = await readJsonSafe(join(root, 'config.json'));
+    if (!configData)
+        return null;
+    // Check if session is alive
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    const sName = configData.tmuxSession || `omc-team-${teamName}`;
+    try {
+        await execFileAsync('tmux', ['has-session', '-t', sName.split(':')[0]]);
+    }
+    catch {
+        return null; // Session not alive
+    }
+    const paneTarget = sName.includes(':') ? sName : sName.split(':')[0];
+    const panesResult = await execFileAsync('tmux', [
+        'list-panes', '-t', paneTarget, '-F', '#{pane_id}'
+    ]);
+    const allPanes = panesResult.stdout.trim().split('\n').filter(Boolean);
+    // First pane is leader, rest are workers
+    const workerPaneIds = allPanes.slice(1);
+    const workerNames = workerPaneIds.map((_, i) => `worker-${i + 1}`);
+    // Reconstruct activeWorkers by scanning task files for in_progress tasks.
+    // Build a paneId lookup: worker-N maps to workerPaneIds[N-1].
+    const paneByWorker = new Map(workerNames.map((wName, i) => [wName, workerPaneIds[i] ?? '']));
+    const activeWorkers = new Map();
+    for (let i = 0; i < configData.tasks.length; i++) {
+        const taskId = String(i + 1);
+        const task = await readTask(root, taskId);
+        if (task?.status === 'in_progress' && task.owner) {
+            const paneId = paneByWorker.get(task.owner) ?? '';
+            activeWorkers.set(task.owner, {
+                paneId,
+                taskId,
+                spawnedAt: task.assignedAt ? new Date(task.assignedAt).getTime() : Date.now(),
+            });
+        }
+    }
+    return {
+        teamName,
+        sessionName: sName,
+        leaderPaneId: configData.leaderPaneId ?? allPanes[0] ?? '',
+        config: configData,
+        workerNames,
+        workerPaneIds,
+        activeWorkers,
+        cwd,
+        ownsWindow: Boolean(configData.tmuxOwnsWindow),
+    };
+}
+//# sourceMappingURL=runtime.js.map