@stanco323/oh-my-claude-code 4.10.3

package/dist/team/runtime-v2.js

@@ -0,0 +1,1048 @@
+/**
+ * Event-driven team runtime v2 — replaces the polling watchdog from runtime.ts.
+ *
+ * Runtime selection:
+ * - Default: v2 enabled
+ * - Opt-out: set OMC_RUNTIME_V2=0|false|no|off to force legacy v1
+ * NO done.json polling. Completion is detected via:
+ * - CLI API lifecycle transitions (claim-task, transition-task-status)
+ * - Event-driven monitor snapshots
+ * - Worker heartbeat/status files
+ *
+ * Preserves: sentinel gate, circuit breaker, failure sidecars.
+ * Removes: done.json watchdog loop, sleep-based polling.
+ *
+ * Architecture mirrors runtime.ts: startTeam, monitorTeam, shutdownTeam,
+ * assignTask, resumeTeam as discrete operations driven by the caller.
+ */
+import { execFile } from 'child_process';
+import { join, resolve } from 'path';
+import { existsSync } from 'fs';
+import { mkdir, readdir, readFile, writeFile } from 'fs/promises';
+import { performance } from 'perf_hooks';
+import { TeamPaths, absPath, teamStateRoot } from './state-paths.js';
+import { allocateTasksToWorkers } from './allocation-policy.js';
+import { readTeamConfig, readWorkerStatus, readWorkerHeartbeat, readMonitorSnapshot, writeMonitorSnapshot, writeShutdownRequest, readShutdownAck, writeWorkerInbox, listTasksFromFiles, saveTeamConfig, cleanupTeamState, } from './monitor.js';
+import { appendTeamEvent, emitMonitorDerivedEvents } from './events.js';
+import { DEFAULT_TEAM_GOVERNANCE, DEFAULT_TEAM_TRANSPORT_POLICY, getConfigGovernance, } from './governance.js';
+import { inferPhase } from './phase-controller.js';
+import { validateTeamName } from './team-name.js';
+import { buildWorkerArgv, resolveValidatedBinaryPath, getWorkerEnv as getModelWorkerEnv, isPromptModeAgent, getPromptModeArgs, resolveClaudeWorkerModel, } from './model-contract.js';
+import { createTeamSession, spawnWorkerInPane, sendToWorker, waitForPaneReady, paneHasActiveTask, paneLooksReady, applyMainVerticalLayout, } from './tmux-session.js';
+import { composeInitialInbox, ensureWorkerStateDir, writeWorkerOverlay, generateTriggerMessage, } from './worker-bootstrap.js';
+import { queueInboxInstruction } from './mcp-comm.js';
+import { cleanupTeamWorktrees } from './git-worktree.js';
+import { formatOmcCliInvocation } from '../utils/omc-cli-rendering.js';
+import { createSwallowedErrorLogger } from '../lib/swallowed-error.js';
+// ---------------------------------------------------------------------------
+// Feature flag
+// ---------------------------------------------------------------------------
+export function isRuntimeV2Enabled(env = process.env) {
+    const raw = env.OMC_RUNTIME_V2;
+    if (!raw)
+        return true;
+    const normalized = raw.trim().toLowerCase();
+    return !['0', 'false', 'no', 'off'].includes(normalized);
+}
+const MONITOR_SIGNAL_STALE_MS = 30_000;
+// ---------------------------------------------------------------------------
+// Helper: sanitize team name
+// ---------------------------------------------------------------------------
+function sanitizeTeamName(name) {
+    const sanitized = name.toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 30);
+    if (!sanitized)
+        throw new Error(`Invalid team name: "${name}" produces empty slug after sanitization`);
+    return sanitized;
+}
+// ---------------------------------------------------------------------------
+// Helper: check worker liveness via tmux pane
+// ---------------------------------------------------------------------------
+async function isWorkerPaneAlive(paneId) {
+    if (!paneId)
+        return false;
+    try {
+        const { isWorkerAlive } = await import('./tmux-session.js');
+        return await isWorkerAlive(paneId);
+    }
+    catch {
+        return false;
+    }
+}
+async function captureWorkerPane(paneId) {
+    if (!paneId)
+        return '';
+    return await new Promise((resolve) => {
+        execFile('tmux', ['capture-pane', '-t', paneId, '-p', '-S', '-80'], (err, stdout) => {
+            if (err)
+                resolve('');
+            else
+                resolve(stdout ?? '');
+        });
+    });
+}
+function isFreshTimestamp(value, maxAgeMs = MONITOR_SIGNAL_STALE_MS) {
+    if (!value)
+        return false;
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        return false;
+    return Date.now() - parsed <= maxAgeMs;
+}
+function findOutstandingWorkerTask(worker, taskById, inProgressByOwner) {
+    if (typeof worker.assigned_tasks === 'object') {
+        for (const taskId of worker.assigned_tasks) {
+            const task = taskById.get(taskId);
+            if (task && (task.status === 'pending' || task.status === 'in_progress')) {
+                return task;
+            }
+        }
+    }
+    const owned = inProgressByOwner.get(worker.name) ?? [];
+    return owned[0] ?? null;
+}
+// ---------------------------------------------------------------------------
+// V2 task instruction builder — CLI API lifecycle, NO done.json
+// ---------------------------------------------------------------------------
+/**
+ * Build the initial task instruction for v2 workers.
+ * Workers use `omc team api` CLI commands for all lifecycle transitions.
+ */
+function buildV2TaskInstruction(teamName, workerName, task, taskId) {
+    const claimTaskCommand = formatOmcCliInvocation(`team api claim-task --input '${JSON.stringify({ team_name: teamName, task_id: taskId, worker: workerName })}' --json`, {});
+    const completeTaskCommand = formatOmcCliInvocation(`team api transition-task-status --input '${JSON.stringify({ team_name: teamName, task_id: taskId, from: 'in_progress', to: 'completed', claim_token: '<claim_token>' })}' --json`);
+    const failTaskCommand = formatOmcCliInvocation(`team api transition-task-status --input '${JSON.stringify({ team_name: teamName, task_id: taskId, from: 'in_progress', to: 'failed', claim_token: '<claim_token>' })}' --json`);
+    return [
+        `## REQUIRED: Task Lifecycle Commands`,
+        `You MUST run these commands. Do NOT skip any step.`,
+        ``,
+        `1. Claim your task:`,
+        `   ${claimTaskCommand}`,
+        `   Save the claim_token from the response.`,
+        `2. Do the work described below.`,
+        `3. On completion (use claim_token from step 1):`,
+        `   ${completeTaskCommand}`,
+        `4. On failure (use claim_token from step 1):`,
+        `   ${failTaskCommand}`,
+        `5. ACK/progress replies are not a stop signal. Keep executing your assigned or next feasible work until the task is actually complete or failed, then transition and exit.`,
+        ``,
+        `## Task Assignment`,
+        `Task ID: ${taskId}`,
+        `Worker: ${workerName}`,
+        `Subject: ${task.subject}`,
+        ``,
+        task.description,
+        ``,
+        `REMINDER: You MUST run transition-task-status before exiting. Do NOT write done.json or edit task files directly.`,
+    ].join('\n');
+}
+// ---------------------------------------------------------------------------
+// V2 worker spawning — direct tmux pane creation, no v1 delegation
+// ---------------------------------------------------------------------------
+async function notifyStartupInbox(sessionName, paneId, message) {
+    const notified = await notifyPaneWithRetry(sessionName, paneId, message);
+    return notified
+        ? { ok: true, transport: 'tmux_send_keys', reason: 'worker_pane_notified' }
+        : { ok: false, transport: 'tmux_send_keys', reason: 'worker_notify_failed' };
+}
+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;
+}
+function hasWorkerStatusProgress(status, taskId) {
+    if (status.current_task_id === taskId)
+        return true;
+    return ['working', 'blocked', 'done', 'failed'].includes(status.state);
+}
+async function hasWorkerTaskClaimEvidence(teamName, workerName, cwd, taskId) {
+    try {
+        const raw = await readFile(absPath(cwd, TeamPaths.taskFile(teamName, taskId)), 'utf-8');
+        const task = JSON.parse(raw);
+        return task.owner === workerName && ['in_progress', 'completed', 'failed'].includes(task.status);
+    }
+    catch {
+        return false;
+    }
+}
+async function hasWorkerStartupEvidence(teamName, workerName, taskId, cwd) {
+    const [hasClaimEvidence, status] = await Promise.all([
+        hasWorkerTaskClaimEvidence(teamName, workerName, cwd, taskId),
+        readWorkerStatus(teamName, workerName, cwd),
+    ]);
+    return hasClaimEvidence || hasWorkerStatusProgress(status, taskId);
+}
+async function waitForWorkerStartupEvidence(teamName, workerName, taskId, cwd, attempts = 3, delayMs = 250) {
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        if (await hasWorkerStartupEvidence(teamName, workerName, taskId, cwd)) {
+            return true;
+        }
+        if (attempt < attempts) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    return false;
+}
+/**
+ * Spawn a single v2 worker in a tmux pane.
+ * Writes CLI API inbox (no done.json), waits for ready, sends inbox path.
+ */
+async function spawnV2Worker(opts) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    // Split new pane off the last existing pane (or leader if first worker)
+    const splitTarget = opts.existingWorkerPaneIds.length === 0
+        ? opts.leaderPaneId
+        : opts.existingWorkerPaneIds[opts.existingWorkerPaneIds.length - 1];
+    const splitType = opts.existingWorkerPaneIds.length === 0 ? '-h' : '-v';
+    const splitResult = await execFileAsync('tmux', [
+        'split-window', splitType, '-t', splitTarget,
+        '-d', '-P', '-F', '#{pane_id}',
+        '-c', opts.cwd,
+    ]);
+    const paneId = splitResult.stdout.split('\n')[0]?.trim();
+    if (!paneId) {
+        return { paneId: null, startupAssigned: false, startupFailureReason: 'pane_id_missing' };
+    }
+    const usePromptMode = isPromptModeAgent(opts.agentType);
+    // Build v2 task instruction (CLI API, NO done.json)
+    const instruction = buildV2TaskInstruction(opts.teamName, opts.workerName, opts.task, opts.taskId);
+    const inboxTriggerMessage = generateTriggerMessage(opts.teamName, opts.workerName);
+    if (usePromptMode) {
+        await composeInitialInbox(opts.teamName, opts.workerName, instruction, opts.cwd);
+    }
+    // Build env and launch command
+    const envVars = {
+        ...getModelWorkerEnv(opts.teamName, opts.workerName, opts.agentType),
+        OMC_TEAM_STATE_ROOT: teamStateRoot(opts.cwd, opts.teamName),
+        OMC_TEAM_LEADER_CWD: opts.cwd,
+    };
+    const resolvedBinaryPath = opts.resolvedBinaryPaths[opts.agentType]
+        ?? resolveValidatedBinaryPath(opts.agentType);
+    // Resolve model from environment variables.
+    // 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 (opts.agentType === 'codex') {
+            return process.env.OMC_EXTERNAL_MODELS_DEFAULT_CODEX_MODEL
+                || process.env.OMC_CODEX_DEFAULT_MODEL
+                || undefined;
+        }
+        if (opts.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(opts.agentType, {
+        teamName: opts.teamName,
+        workerName: opts.workerName,
+        cwd: opts.cwd,
+        resolvedBinaryPath,
+        model: modelForAgent,
+    });
+    // For prompt-mode agents (codex, gemini), pass instruction via CLI flag
+    if (usePromptMode) {
+        launchArgs.push(...getPromptModeArgs(opts.agentType, instruction));
+    }
+    const paneConfig = {
+        teamName: opts.teamName,
+        workerName: opts.workerName,
+        envVars,
+        launchBinary,
+        launchArgs,
+        cwd: opts.cwd,
+    };
+    await spawnWorkerInPane(opts.sessionName, paneId, paneConfig);
+    // Apply layout
+    await applyMainVerticalLayout(opts.sessionName);
+    // For interactive agents, wait for pane readiness before dispatching startup inbox.
+    if (!usePromptMode) {
+        const paneReady = await waitForPaneReady(paneId);
+        if (!paneReady) {
+            return {
+                paneId,
+                startupAssigned: false,
+                startupFailureReason: 'worker_pane_not_ready',
+            };
+        }
+    }
+    const dispatchOutcome = await queueInboxInstruction({
+        teamName: opts.teamName,
+        workerName: opts.workerName,
+        workerIndex: opts.workerIndex + 1,
+        paneId,
+        inbox: instruction,
+        triggerMessage: inboxTriggerMessage,
+        cwd: opts.cwd,
+        transportPreference: usePromptMode ? 'prompt_stdin' : 'transport_direct',
+        fallbackAllowed: false,
+        inboxCorrelationKey: `startup:${opts.workerName}:${opts.taskId}`,
+        notify: async (_target, triggerMessage) => {
+            if (usePromptMode) {
+                return { ok: true, transport: 'prompt_stdin', reason: 'prompt_mode_launch_args' };
+            }
+            if (opts.agentType === 'gemini') {
+                const confirmed = await notifyPaneWithRetry(opts.sessionName, paneId, '1');
+                if (!confirmed) {
+                    return { ok: false, transport: 'tmux_send_keys', reason: 'worker_notify_failed:trust-confirm' };
+                }
+                await new Promise(r => setTimeout(r, 800));
+            }
+            return notifyStartupInbox(opts.sessionName, paneId, triggerMessage);
+        },
+        deps: {
+            writeWorkerInbox,
+        },
+    });
+    if (!dispatchOutcome.ok) {
+        return {
+            paneId,
+            startupAssigned: false,
+            startupFailureReason: dispatchOutcome.reason,
+        };
+    }
+    if (opts.agentType === 'claude') {
+        const settled = await waitForWorkerStartupEvidence(opts.teamName, opts.workerName, opts.taskId, opts.cwd);
+        if (!settled) {
+            const renotified = await notifyStartupInbox(opts.sessionName, paneId, inboxTriggerMessage);
+            if (!renotified.ok) {
+                return {
+                    paneId,
+                    startupAssigned: false,
+                    startupFailureReason: `${renotified.reason}:startup_evidence_missing`,
+                };
+            }
+            const settledAfterRetry = await waitForWorkerStartupEvidence(opts.teamName, opts.workerName, opts.taskId, opts.cwd);
+            if (!settledAfterRetry) {
+                return {
+                    paneId,
+                    startupAssigned: false,
+                    startupFailureReason: 'claude_startup_evidence_missing',
+                };
+            }
+        }
+    }
+    if (usePromptMode) {
+        const settled = await waitForWorkerStartupEvidence(opts.teamName, opts.workerName, opts.taskId, opts.cwd);
+        if (!settled) {
+            return {
+                paneId,
+                startupAssigned: false,
+                startupFailureReason: `${opts.agentType}_startup_evidence_missing`,
+            };
+        }
+    }
+    return {
+        paneId,
+        startupAssigned: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// startTeamV2 — direct tmux creation, CLI API inbox, NO watchdog
+// ---------------------------------------------------------------------------
+/**
+ * Start a team with the v2 event-driven runtime.
+ * Creates state directories, writes config + task files, spawns workers via
+ * tmux split-panes, and writes CLI API inbox instructions. NO done.json.
+ * NO watchdog polling — the leader drives monitoring via monitorTeamV2().
+ */
+export async function startTeamV2(config) {
+    const sanitized = sanitizeTeamName(config.teamName);
+    const leaderCwd = resolve(config.cwd);
+    validateTeamName(sanitized);
+    // Validate CLIs and pin absolute binary paths
+    const agentTypes = config.agentTypes;
+    const resolvedBinaryPaths = {};
+    for (const agentType of [...new Set(agentTypes)]) {
+        resolvedBinaryPaths[agentType] = resolveValidatedBinaryPath(agentType);
+    }
+    // Create state directories
+    await mkdir(absPath(leaderCwd, TeamPaths.tasks(sanitized)), { recursive: true });
+    await mkdir(absPath(leaderCwd, TeamPaths.workers(sanitized)), { recursive: true });
+    await mkdir(join(leaderCwd, '.omc', 'state', 'team', sanitized, 'mailbox'), { recursive: true });
+    // Write task files
+    for (let i = 0; i < config.tasks.length; i++) {
+        const taskId = String(i + 1);
+        const taskFilePath = absPath(leaderCwd, TeamPaths.taskFile(sanitized, taskId));
+        await mkdir(join(taskFilePath, '..'), { recursive: true });
+        await writeFile(taskFilePath, JSON.stringify({
+            id: taskId,
+            subject: config.tasks[i].subject,
+            description: config.tasks[i].description,
+            status: 'pending',
+            owner: null,
+            result: null,
+            created_at: new Date().toISOString(),
+        }, null, 2), 'utf-8');
+    }
+    // Build allocation inputs for the new role-aware allocator
+    const workerNames = Array.from({ length: config.workerCount }, (_, index) => `worker-${index + 1}`);
+    const workerNameSet = new Set(workerNames);
+    // Respect explicit owner fields first, then allocate remaining tasks
+    const startupAllocations = [];
+    const unownedTaskIndices = [];
+    for (let i = 0; i < config.tasks.length; i++) {
+        const owner = config.tasks[i]?.owner;
+        if (typeof owner === 'string' && workerNameSet.has(owner)) {
+            startupAllocations.push({ workerName: owner, taskIndex: i });
+        }
+        else {
+            unownedTaskIndices.push(i);
+        }
+    }
+    if (unownedTaskIndices.length > 0) {
+        const allocationTasks = unownedTaskIndices.map(idx => ({
+            id: String(idx),
+            subject: config.tasks[idx].subject,
+            description: config.tasks[idx].description,
+        }));
+        const allocationWorkers = workerNames.map((name, i) => ({
+            name,
+            role: config.workerRoles?.[i]
+                ?? (agentTypes[i % agentTypes.length] ?? agentTypes[0] ?? 'claude'),
+            currentLoad: 0,
+        }));
+        for (const r of allocateTasksToWorkers(allocationTasks, allocationWorkers)) {
+            startupAllocations.push({ workerName: r.workerName, taskIndex: Number(r.taskId) });
+        }
+    }
+    // Set up worker state dirs and overlays (with v2 CLI API instructions)
+    for (let i = 0; i < workerNames.length; i++) {
+        const wName = workerNames[i];
+        const agentType = (agentTypes[i % agentTypes.length] ?? agentTypes[0] ?? 'claude');
+        await ensureWorkerStateDir(sanitized, wName, leaderCwd);
+        await writeWorkerOverlay({
+            teamName: sanitized, workerName: wName, agentType,
+            tasks: config.tasks.map((t, idx) => ({
+                id: String(idx + 1), subject: t.subject, description: t.description,
+            })),
+            cwd: leaderCwd,
+            ...(config.rolePrompt ? { bootstrapInstructions: config.rolePrompt } : {}),
+        });
+    }
+    // Create tmux session (leader only — workers spawned below)
+    const session = await createTeamSession(sanitized, 0, leaderCwd, {
+        newWindow: Boolean(config.newWindow),
+    });
+    const sessionName = session.sessionName;
+    const leaderPaneId = session.leaderPaneId;
+    const ownsWindow = session.sessionMode !== 'split-pane';
+    const workerPaneIds = [];
+    // Build workers info for config
+    const workersInfo = workerNames.map((wName, i) => ({
+        name: wName,
+        index: i + 1,
+        role: config.workerRoles?.[i]
+            ?? (agentTypes[i % agentTypes.length] ?? agentTypes[0] ?? 'claude'),
+        assigned_tasks: [],
+        working_dir: leaderCwd,
+    }));
+    // Write initial v2 config
+    const teamConfig = {
+        name: sanitized,
+        task: config.tasks.map(t => t.subject).join('; '),
+        agent_type: agentTypes[0] || 'claude',
+        worker_launch_mode: 'interactive',
+        policy: DEFAULT_TEAM_TRANSPORT_POLICY,
+        governance: DEFAULT_TEAM_GOVERNANCE,
+        worker_count: config.workerCount,
+        max_workers: 20,
+        workers: workersInfo,
+        created_at: new Date().toISOString(),
+        tmux_session: sessionName,
+        tmux_window_owned: ownsWindow,
+        next_task_id: config.tasks.length + 1,
+        leader_cwd: leaderCwd,
+        team_state_root: teamStateRoot(leaderCwd, sanitized),
+        leader_pane_id: leaderPaneId,
+        hud_pane_id: null,
+        resize_hook_name: null,
+        resize_hook_target: null,
+        ...(ownsWindow ? { workspace_mode: 'single' } : {}),
+    };
+    await saveTeamConfig(teamConfig, leaderCwd);
+    const permissionsSnapshot = {
+        approval_mode: process.env.OMC_APPROVAL_MODE || 'default',
+        sandbox_mode: process.env.OMC_SANDBOX_MODE || 'default',
+        network_access: process.env.OMC_NETWORK_ACCESS === '1',
+    };
+    const teamManifest = {
+        schema_version: 2,
+        name: sanitized,
+        task: teamConfig.task,
+        leader: {
+            session_id: sessionName,
+            worker_id: 'leader-fixed',
+            role: 'leader',
+        },
+        policy: DEFAULT_TEAM_TRANSPORT_POLICY,
+        governance: DEFAULT_TEAM_GOVERNANCE,
+        permissions_snapshot: permissionsSnapshot,
+        tmux_session: sessionName,
+        worker_count: teamConfig.worker_count,
+        workers: workersInfo,
+        next_task_id: teamConfig.next_task_id,
+        created_at: teamConfig.created_at,
+        leader_cwd: leaderCwd,
+        team_state_root: teamConfig.team_state_root,
+        workspace_mode: teamConfig.workspace_mode,
+        leader_pane_id: leaderPaneId,
+        hud_pane_id: null,
+        resize_hook_name: null,
+        resize_hook_target: null,
+        next_worker_index: teamConfig.next_worker_index,
+    };
+    await writeFile(absPath(leaderCwd, TeamPaths.manifest(sanitized)), JSON.stringify(teamManifest, null, 2), 'utf-8');
+    // Spawn workers for initial tasks (at most one startup task per worker)
+    const initialStartupAllocations = [];
+    const seenStartupWorkers = new Set();
+    for (const decision of startupAllocations) {
+        if (seenStartupWorkers.has(decision.workerName))
+            continue;
+        initialStartupAllocations.push(decision);
+        seenStartupWorkers.add(decision.workerName);
+        if (initialStartupAllocations.length >= config.workerCount)
+            break;
+    }
+    for (const decision of initialStartupAllocations) {
+        const wName = decision.workerName;
+        const workerIndex = Number.parseInt(wName.replace('worker-', ''), 10) - 1;
+        const taskId = String(decision.taskIndex + 1);
+        const task = config.tasks[decision.taskIndex];
+        if (!task || workerIndex < 0)
+            continue;
+        const workerLaunch = await spawnV2Worker({
+            sessionName,
+            leaderPaneId,
+            existingWorkerPaneIds: workerPaneIds,
+            teamName: sanitized,
+            workerName: wName,
+            workerIndex,
+            agentType: (agentTypes[workerIndex % agentTypes.length] ?? agentTypes[0] ?? 'claude'),
+            task,
+            taskId,
+            cwd: leaderCwd,
+            resolvedBinaryPaths,
+        });
+        if (workerLaunch.paneId) {
+            workerPaneIds.push(workerLaunch.paneId);
+            const workerInfo = workersInfo[workerIndex];
+            if (workerInfo) {
+                workerInfo.pane_id = workerLaunch.paneId;
+                workerInfo.assigned_tasks = workerLaunch.startupAssigned ? [taskId] : [];
+            }
+        }
+        if (workerLaunch.startupFailureReason) {
+            await appendTeamEvent(sanitized, {
+                type: 'team_leader_nudge',
+                worker: 'leader-fixed',
+                reason: `startup_manual_intervention_required:${wName}:${workerLaunch.startupFailureReason}`,
+            }, leaderCwd);
+        }
+    }
+    // Persist config with pane IDs
+    teamConfig.workers = workersInfo;
+    await saveTeamConfig(teamConfig, leaderCwd);
+    // Emit start event — NO watchdog, leader drives via monitorTeamV2()
+    await appendTeamEvent(sanitized, {
+        type: 'team_leader_nudge',
+        worker: 'leader-fixed',
+        reason: `start_team_v2: workers=${config.workerCount} tasks=${config.tasks.length} panes=${workerPaneIds.length}`,
+    }, leaderCwd);
+    return {
+        teamName: sanitized,
+        sanitizedName: sanitized,
+        sessionName,
+        config: teamConfig,
+        cwd: leaderCwd,
+        ownsWindow: ownsWindow,
+    };
+}
+// ---------------------------------------------------------------------------
+// Circuit breaker — 3 consecutive failures -> write watchdog-failed.json
+// ---------------------------------------------------------------------------
+const CIRCUIT_BREAKER_THRESHOLD = 3;
+export async function writeWatchdogFailedMarker(teamName, cwd, reason) {
+    const { writeFile } = await import('fs/promises');
+    const marker = {
+        failedAt: Date.now(),
+        reason,
+        writtenBy: 'runtime-v2',
+    };
+    const root = absPath(cwd, TeamPaths.root(sanitizeTeamName(teamName)));
+    const markerPath = join(root, 'watchdog-failed.json');
+    await mkdir(root, { recursive: true });
+    await writeFile(markerPath, JSON.stringify(marker, null, 2), 'utf-8');
+}
+/**
+ * Circuit breaker context for tracking consecutive monitor failures.
+ * The caller (runtime-cli v2 loop) should call recordSuccess on each
+ * successful monitor cycle and recordFailure on each error. When the
+ * threshold is reached, the breaker trips and writes watchdog-failed.json.
+ */
+export class CircuitBreakerV2 {
+    teamName;
+    cwd;
+    threshold;
+    consecutiveFailures = 0;
+    tripped = false;
+    constructor(teamName, cwd, threshold = CIRCUIT_BREAKER_THRESHOLD) {
+        this.teamName = teamName;
+        this.cwd = cwd;
+        this.threshold = threshold;
+    }
+    recordSuccess() {
+        this.consecutiveFailures = 0;
+    }
+    async recordFailure(reason) {
+        this.consecutiveFailures++;
+        if (this.consecutiveFailures >= this.threshold && !this.tripped) {
+            this.tripped = true;
+            await writeWatchdogFailedMarker(this.teamName, this.cwd, reason);
+            return true; // breaker tripped
+        }
+        return false;
+    }
+    isTripped() {
+        return this.tripped;
+    }
+}
+// ---------------------------------------------------------------------------
+// Failure sidecars — requeue tasks from dead workers
+// ---------------------------------------------------------------------------
+/**
+ * Requeue tasks from dead workers by writing failure sidecars and resetting
+ * task status back to pending so they can be claimed by other workers.
+ */
+export async function requeueDeadWorkerTasks(teamName, deadWorkerNames, cwd) {
+    const logEventFailure = createSwallowedErrorLogger('team.runtime-v2.requeueDeadWorkerTasks appendTeamEvent failed');
+    const sanitized = sanitizeTeamName(teamName);
+    const tasks = await listTasksFromFiles(sanitized, cwd);
+    const requeued = [];
+    const deadSet = new Set(deadWorkerNames);
+    for (const task of tasks) {
+        if (task.status !== 'in_progress')
+            continue;
+        if (!task.owner || !deadSet.has(task.owner))
+            continue;
+        // Write failure sidecar
+        const sidecarPath = absPath(cwd, `${TeamPaths.tasks(sanitized)}/${task.id}.failure.json`);
+        const sidecar = {
+            taskId: task.id,
+            lastError: `worker_dead:${task.owner}`,
+            retryCount: 0,
+            lastFailedAt: new Date().toISOString(),
+        };
+        const { writeFile } = await import('fs/promises');
+        await mkdir(absPath(cwd, TeamPaths.tasks(sanitized)), { recursive: true });
+        await writeFile(sidecarPath, JSON.stringify(sidecar, null, 2), 'utf-8');
+        // Reset task to pending (locked to prevent race with concurrent claimTask)
+        const taskPath = absPath(cwd, TeamPaths.taskFile(sanitized, task.id));
+        try {
+            const { readFileSync, writeFileSync } = await import('fs');
+            const { withFileLockSync } = await import('../lib/file-lock.js');
+            withFileLockSync(taskPath + '.lock', () => {
+                const raw = readFileSync(taskPath, 'utf-8');
+                const taskData = JSON.parse(raw);
+                // Only requeue if still in_progress — another worker may have already claimed it
+                if (taskData.status === 'in_progress') {
+                    taskData.status = 'pending';
+                    taskData.owner = undefined;
+                    taskData.claim = undefined;
+                    writeFileSync(taskPath, JSON.stringify(taskData, null, 2), 'utf-8');
+                    requeued.push(task.id);
+                }
+            });
+        }
+        catch {
+            // Task file may have been removed or lock failed; skip
+        }
+        await appendTeamEvent(sanitized, {
+            type: 'team_leader_nudge',
+            worker: 'leader-fixed',
+            task_id: task.id,
+            reason: `requeue_dead_worker:${task.owner}`,
+        }, cwd).catch(logEventFailure);
+    }
+    return requeued;
+}
+// ---------------------------------------------------------------------------
+// monitorTeam — snapshot-based, event-driven (no watchdog)
+// ---------------------------------------------------------------------------
+/**
+ * Take a single monitor snapshot of team state.
+ * Caller drives the loop (e.g., runtime-cli poll interval or event trigger).
+ */
+export async function monitorTeamV2(teamName, cwd) {
+    const monitorStartMs = performance.now();
+    const sanitized = sanitizeTeamName(teamName);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        return null;
+    const previousSnapshot = await readMonitorSnapshot(sanitized, cwd);
+    // Load all tasks
+    const listTasksStartMs = performance.now();
+    const allTasks = await listTasksFromFiles(sanitized, cwd);
+    const listTasksMs = performance.now() - listTasksStartMs;
+    const taskById = new Map(allTasks.map((task) => [task.id, task]));
+    const inProgressByOwner = new Map();
+    for (const task of allTasks) {
+        if (task.status !== 'in_progress' || !task.owner)
+            continue;
+        const existing = inProgressByOwner.get(task.owner) || [];
+        existing.push(task);
+        inProgressByOwner.set(task.owner, existing);
+    }
+    // Scan workers
+    const workers = [];
+    const deadWorkers = [];
+    const nonReportingWorkers = [];
+    const recommendations = [];
+    const workerScanStartMs = performance.now();
+    const workerSignals = await Promise.all(config.workers.map(async (worker) => {
+        const alive = await isWorkerPaneAlive(worker.pane_id);
+        const [status, heartbeat, paneCapture] = await Promise.all([
+            readWorkerStatus(sanitized, worker.name, cwd),
+            readWorkerHeartbeat(sanitized, worker.name, cwd),
+            alive ? captureWorkerPane(worker.pane_id) : Promise.resolve(''),
+        ]);
+        return { worker, alive, status, heartbeat, paneCapture };
+    }));
+    const workerScanMs = performance.now() - workerScanStartMs;
+    for (const { worker: w, alive, status, heartbeat, paneCapture } of workerSignals) {
+        const currentTask = status.current_task_id ? taskById.get(status.current_task_id) ?? null : null;
+        const outstandingTask = currentTask ?? findOutstandingWorkerTask(w, taskById, inProgressByOwner);
+        const expectedTaskId = status.current_task_id ?? outstandingTask?.id ?? w.assigned_tasks[0] ?? '';
+        const previousTurns = previousSnapshot ? (previousSnapshot.workerTurnCountByName[w.name] ?? 0) : null;
+        const previousTaskId = previousSnapshot?.workerTaskIdByName[w.name] ?? '';
+        const currentTaskId = status.current_task_id ?? '';
+        const turnsWithoutProgress = heartbeat &&
+            previousTurns !== null &&
+            status.state === 'working' &&
+            currentTask &&
+            (currentTask.status === 'pending' || currentTask.status === 'in_progress') &&
+            currentTaskId !== '' &&
+            previousTaskId === currentTaskId
+            ? Math.max(0, heartbeat.turn_count - previousTurns)
+            : 0;
+        workers.push({
+            name: w.name,
+            alive,
+            status,
+            heartbeat,
+            assignedTasks: w.assigned_tasks,
+            turnsWithoutProgress,
+        });
+        if (!alive) {
+            deadWorkers.push(w.name);
+            const deadWorkerTasks = inProgressByOwner.get(w.name) || [];
+            for (const t of deadWorkerTasks) {
+                recommendations.push(`Reassign task-${t.id} from dead ${w.name}`);
+            }
+        }
+        const paneSuggestsIdle = alive && paneLooksReady(paneCapture) && !paneHasActiveTask(paneCapture);
+        const statusFresh = isFreshTimestamp(status.updated_at);
+        const heartbeatFresh = isFreshTimestamp(heartbeat?.last_turn_at);
+        const hasWorkStartEvidence = expectedTaskId !== '' && hasWorkerStatusProgress(status, expectedTaskId);
+        let stallReason = null;
+        if (paneSuggestsIdle && expectedTaskId !== '' && !hasWorkStartEvidence) {
+            stallReason = 'no_work_start_evidence';
+        }
+        else if (paneSuggestsIdle && expectedTaskId !== '' && (!statusFresh || !heartbeatFresh)) {
+            stallReason = 'stale_or_missing_worker_reports';
+        }
+        else if (paneSuggestsIdle && turnsWithoutProgress > 5) {
+            stallReason = 'no_meaningful_turn_progress';
+        }
+        if (stallReason) {
+            nonReportingWorkers.push(w.name);
+            if (stallReason === 'no_work_start_evidence') {
+                recommendations.push(`Investigate ${w.name}: assigned work but no work-start evidence; pane is idle at prompt`);
+            }
+            else if (stallReason === 'stale_or_missing_worker_reports') {
+                recommendations.push(`Investigate ${w.name}: pane is idle while status/heartbeat are stale or missing`);
+            }
+            else {
+                recommendations.push(`Investigate ${w.name}: no meaningful turn progress and pane is idle at prompt`);
+            }
+        }
+    }
+    // Count tasks
+    const taskCounts = {
+        total: allTasks.length,
+        pending: allTasks.filter((t) => t.status === 'pending').length,
+        blocked: allTasks.filter((t) => t.status === 'blocked').length,
+        in_progress: allTasks.filter((t) => t.status === 'in_progress').length,
+        completed: allTasks.filter((t) => t.status === 'completed').length,
+        failed: allTasks.filter((t) => t.status === 'failed').length,
+    };
+    const allTasksTerminal = taskCounts.pending === 0 && taskCounts.blocked === 0 && taskCounts.in_progress === 0;
+    // Infer phase from task distribution
+    const phase = inferPhase(allTasks.map((t) => ({
+        status: t.status,
+        metadata: undefined,
+    })));
+    // Emit monitor-derived events (task completions, worker state changes)
+    await emitMonitorDerivedEvents(sanitized, allTasks, workers.map((w) => ({ name: w.name, alive: w.alive, status: w.status })), previousSnapshot, cwd);
+    // Persist snapshot for next cycle
+    const updatedAt = new Date().toISOString();
+    const totalMs = performance.now() - monitorStartMs;
+    await writeMonitorSnapshot(sanitized, {
+        taskStatusById: Object.fromEntries(allTasks.map((t) => [t.id, t.status])),
+        workerAliveByName: Object.fromEntries(workers.map((w) => [w.name, w.alive])),
+        workerStateByName: Object.fromEntries(workers.map((w) => [w.name, w.status.state])),
+        workerTurnCountByName: Object.fromEntries(workers.map((w) => [w.name, w.heartbeat?.turn_count ?? 0])),
+        workerTaskIdByName: Object.fromEntries(workers.map((w) => [w.name, w.status.current_task_id ?? ''])),
+        mailboxNotifiedByMessageId: previousSnapshot?.mailboxNotifiedByMessageId ?? {},
+        completedEventTaskIds: previousSnapshot?.completedEventTaskIds ?? {},
+        monitorTimings: {
+            list_tasks_ms: Number(listTasksMs.toFixed(2)),
+            worker_scan_ms: Number(workerScanMs.toFixed(2)),
+            mailbox_delivery_ms: 0,
+            total_ms: Number(totalMs.toFixed(2)),
+            updated_at: updatedAt,
+        },
+    }, cwd);
+    return {
+        teamName: sanitized,
+        phase,
+        workers,
+        tasks: {
+            ...taskCounts,
+            items: allTasks,
+        },
+        allTasksTerminal,
+        deadWorkers,
+        nonReportingWorkers,
+        recommendations,
+        performance: {
+            list_tasks_ms: Number(listTasksMs.toFixed(2)),
+            worker_scan_ms: Number(workerScanMs.toFixed(2)),
+            total_ms: Number(totalMs.toFixed(2)),
+            updated_at: updatedAt,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// shutdownTeam — graceful shutdown with gate, ack, force kill
+// ---------------------------------------------------------------------------
+/**
+ * Graceful team shutdown:
+ * 1. Shutdown gate check (unless force)
+ * 2. Send shutdown request to all workers via inbox
+ * 3. Wait for ack or timeout
+ * 4. Force kill remaining tmux panes
+ * 5. Clean up state
+ */
+export async function shutdownTeamV2(teamName, cwd, options = {}) {
+    const logEventFailure = createSwallowedErrorLogger('team.runtime-v2.shutdownTeamV2 appendTeamEvent failed');
+    const force = options.force === true;
+    const ralph = options.ralph === true;
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const sanitized = sanitizeTeamName(teamName);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config) {
+        // No config available; only clean state. We intentionally avoid guessing
+        // a tmux session name here to prevent accidental self-session termination.
+        await cleanupTeamState(sanitized, cwd);
+        return;
+    }
+    // 1. Shutdown gate check
+    if (!force) {
+        const allTasks = await listTasksFromFiles(sanitized, cwd);
+        const governance = getConfigGovernance(config);
+        const gate = {
+            total: allTasks.length,
+            pending: allTasks.filter((t) => t.status === 'pending').length,
+            blocked: allTasks.filter((t) => t.status === 'blocked').length,
+            in_progress: allTasks.filter((t) => t.status === 'in_progress').length,
+            completed: allTasks.filter((t) => t.status === 'completed').length,
+            failed: allTasks.filter((t) => t.status === 'failed').length,
+            allowed: false,
+        };
+        gate.allowed = gate.pending === 0 && gate.blocked === 0 && gate.in_progress === 0 && gate.failed === 0;
+        await appendTeamEvent(sanitized, {
+            type: 'shutdown_gate',
+            worker: 'leader-fixed',
+            reason: `allowed=${gate.allowed} total=${gate.total} pending=${gate.pending} blocked=${gate.blocked} in_progress=${gate.in_progress} completed=${gate.completed} failed=${gate.failed}${ralph ? ' policy=ralph' : ''}`,
+        }, cwd).catch(logEventFailure);
+        if (!gate.allowed) {
+            const hasActiveWork = gate.pending > 0 || gate.blocked > 0 || gate.in_progress > 0;
+            if (!governance.cleanup_requires_all_workers_inactive) {
+                await appendTeamEvent(sanitized, {
+                    type: 'team_leader_nudge',
+                    worker: 'leader-fixed',
+                    reason: `cleanup_override_bypassed:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`,
+                }, cwd).catch(logEventFailure);
+            }
+            else if (ralph && !hasActiveWork) {
+                // Ralph policy: bypass on failure-only scenarios
+                await appendTeamEvent(sanitized, {
+                    type: 'team_leader_nudge',
+                    worker: 'leader-fixed',
+                    reason: `gate_bypassed:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`,
+                }, cwd).catch(logEventFailure);
+            }
+            else {
+                throw new Error(`shutdown_gate_blocked:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`);
+            }
+        }
+    }
+    if (force) {
+        await appendTeamEvent(sanitized, {
+            type: 'shutdown_gate_forced',
+            worker: 'leader-fixed',
+            reason: 'force_bypass',
+        }, cwd).catch(logEventFailure);
+    }
+    // 2. Send shutdown request to each worker
+    const shutdownRequestTimes = new Map();
+    for (const w of config.workers) {
+        try {
+            const requestedAt = new Date().toISOString();
+            await writeShutdownRequest(sanitized, w.name, 'leader-fixed', cwd);
+            shutdownRequestTimes.set(w.name, requestedAt);
+            // Write shutdown inbox
+            const shutdownInbox = `# Shutdown Request\n\nAll tasks are complete. Please wrap up and respond with a shutdown acknowledgement.\n\nWrite your ack to: ${TeamPaths.shutdownAck(sanitized, w.name)}\nFormat: {"status":"accept","reason":"ok","updated_at":"<iso>"}\n\nThen exit your session.\n`;
+            await writeWorkerInbox(sanitized, w.name, shutdownInbox, cwd);
+        }
+        catch (err) {
+            process.stderr.write(`[team/runtime-v2] shutdown request failed for ${w.name}: ${err}\n`);
+        }
+    }
+    // 3. Wait for ack or timeout
+    const deadline = Date.now() + timeoutMs;
+    const rejected = [];
+    const ackedWorkers = new Set();
+    while (Date.now() < deadline) {
+        for (const w of config.workers) {
+            if (ackedWorkers.has(w.name))
+                continue;
+            const ack = await readShutdownAck(sanitized, w.name, cwd, shutdownRequestTimes.get(w.name));
+            if (ack) {
+                ackedWorkers.add(w.name);
+                await appendTeamEvent(sanitized, {
+                    type: 'shutdown_ack',
+                    worker: w.name,
+                    reason: ack.status === 'reject' ? `reject:${ack.reason || 'no_reason'}` : 'accept',
+                }, cwd).catch(logEventFailure);
+                if (ack.status === 'reject') {
+                    rejected.push({ worker: w.name, reason: ack.reason || 'no_reason' });
+                }
+            }
+        }
+        if (rejected.length > 0 && !force) {
+            const detail = rejected.map((r) => `${r.worker}:${r.reason}`).join(',');
+            throw new Error(`shutdown_rejected:${detail}`);
+        }
+        // Check if all workers have acked or exited
+        const allDone = config.workers.every((w) => ackedWorkers.has(w.name));
+        if (allDone)
+            break;
+        await new Promise((r) => setTimeout(r, 2_000));
+    }
+    // 4. Force kill remaining tmux panes
+    try {
+        const { killWorkerPanes, killTeamSession, resolveSplitPaneWorkerPaneIds } = await import('./tmux-session.js');
+        const recordedWorkerPaneIds = config.workers
+            .map((w) => w.pane_id)
+            .filter((p) => typeof p === 'string' && p.trim().length > 0);
+        const ownsWindow = config.tmux_window_owned === true;
+        const workerPaneIds = ownsWindow
+            ? recordedWorkerPaneIds
+            : await resolveSplitPaneWorkerPaneIds(config.tmux_session, recordedWorkerPaneIds, config.leader_pane_id ?? undefined);
+        await killWorkerPanes({
+            paneIds: workerPaneIds,
+            leaderPaneId: config.leader_pane_id ?? undefined,
+            teamName: sanitized,
+            cwd,
+        });
+        if (config.tmux_session && (ownsWindow || !config.tmux_session.includes(':'))) {
+            const sessionMode = ownsWindow
+                ? (config.tmux_session.includes(':') ? 'dedicated-window' : 'detached-session')
+                : 'detached-session';
+            await killTeamSession(config.tmux_session, workerPaneIds, config.leader_pane_id ?? undefined, { sessionMode });
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[team/runtime-v2] tmux cleanup: ${err}\n`);
+    }
+    // 5. Ralph completion logging
+    if (ralph) {
+        const finalTasks = await listTasksFromFiles(sanitized, cwd).catch(() => []);
+        const completed = finalTasks.filter((t) => t.status === 'completed').length;
+        const failed = finalTasks.filter((t) => t.status === 'failed').length;
+        const pending = finalTasks.filter((t) => t.status === 'pending').length;
+        await appendTeamEvent(sanitized, {
+            type: 'team_leader_nudge',
+            worker: 'leader-fixed',
+            reason: `ralph_cleanup_summary: total=${finalTasks.length} completed=${completed} failed=${failed} pending=${pending} force=${force}`,
+        }, cwd).catch(logEventFailure);
+    }
+    // 6. Clean up state
+    try {
+        cleanupTeamWorktrees(sanitized, cwd);
+    }
+    catch (err) {
+        process.stderr.write(`[team/runtime-v2] worktree cleanup: ${err}\n`);
+    }
+    await cleanupTeamState(sanitized, cwd);
+}
+// ---------------------------------------------------------------------------
+// resumeTeam — reconstruct runtime from persisted state
+// ---------------------------------------------------------------------------
+export async function resumeTeamV2(teamName, cwd) {
+    const sanitized = sanitizeTeamName(teamName);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        return null;
+    // Verify tmux session is alive
+    try {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        const sessionName = config.tmux_session || `omc-team-${sanitized}`;
+        await execFileAsync('tmux', ['has-session', '-t', sessionName.split(':')[0]]);
+        return {
+            teamName: sanitized,
+            sanitizedName: sanitized,
+            sessionName,
+            ownsWindow: config.tmux_window_owned === true,
+            config,
+            cwd,
+        };
+    }
+    catch {
+        return null; // Session not alive
+    }
+}
+// ---------------------------------------------------------------------------
+// findActiveTeams — discover running teams
+// ---------------------------------------------------------------------------
+export async function findActiveTeamsV2(cwd) {
+    const root = join(cwd, '.omc', 'state', 'team');
+    if (!existsSync(root))
+        return [];
+    const entries = await readdir(root, { withFileTypes: true });
+    const active = [];
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const teamName = e.name;
+        const config = await readTeamConfig(teamName, cwd);
+        if (config) {
+            active.push(teamName);
+        }
+    }
+    return active;
+}
+//# sourceMappingURL=runtime-v2.js.map