@jstn-sdk/rcs 0.1.0

package/dist/team/runtime.js

@@ -0,0 +1,3925 @@
+import { join, resolve, dirname } from 'path';
+import { existsSync, appendFileSync, mkdirSync } from 'fs';
+import { mkdir, readdir, readFile, writeFile } from 'fs/promises';
+import { performance } from 'perf_hooks';
+import { spawn, spawnSync } from 'child_process';
+import { sanitizeTeamName, isTmuxAvailable, hasCurrentTmuxClientContext, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, waitForWorkerReadyAsync, dismissTrustPromptIfPresent, evaluateStartupDirectTriggerSafety, sendToWorker, sendToWorkerStdin, isWorkerAlive, isWorkerPaneOpen, getWorkerPanePid, killWorkerByPaneIdAsync, restoreStandaloneHudPane, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listPaneIds, listTeamSessions, resolveSharedSessionShutdownTopology, } from './tmux-session.js';
+import { teamInit as initTeamState, DEFAULT_MAX_WORKERS, teamReadConfig as readTeamConfig, teamWriteWorkerIdentity as writeWorkerIdentity, teamReadWorkerHeartbeat as readWorkerHeartbeat, teamReadWorkerStatus as readWorkerStatus, teamWriteWorkerInbox as writeWorkerInbox, teamCreateTask as createStateTask, teamReadTask as readTask, teamListTasks as listTasks, teamUpdateTask as updateTask, teamReadManifest as readTeamManifestV2, teamNormalizeGovernance as normalizeTeamGovernance, teamNormalizePolicy as normalizeTeamPolicy, teamClaimTask as claimTask, teamReleaseTaskClaim as releaseTaskClaim, teamReclaimExpiredTaskClaim as reclaimExpiredTaskClaim, teamAppendEvent as appendTeamEvent, teamReadTaskApproval as readTaskApproval, teamListMailbox as listMailboxMessages, teamMarkMessageDelivered as markMessageDelivered, teamMarkMessageNotified as markMessageNotified, teamEnqueueDispatchRequest as enqueueDispatchRequest, teamMarkDispatchRequestNotified as markDispatchRequestNotified, teamTransitionDispatchRequest as transitionDispatchRequest, teamReadDispatchRequest as readDispatchRequest, teamCleanup as cleanupTeamState, teamSaveConfig as saveTeamConfig, teamWriteShutdownRequest as writeShutdownRequest, teamReadShutdownAck as readShutdownAck, teamReadMonitorSnapshot as readMonitorSnapshot, teamWriteMonitorSnapshot as writeMonitorSnapshot, teamReadPhase as readTeamPhaseState, teamWritePhase as writeTeamPhaseState, teamWriteWorkerStatus as writeWorkerStatus, writeAtomic, } from './team-ops.js';
+import { queueInboxInstruction, queueDirectMailboxMessage, queueBroadcastMailboxMessage, waitForDispatchReceipt, } from './mcp-comm.js';
+import { appendTeamDeliveryLogForCwd } from './delivery-log.js';
+import { remapRepoAwareDecompositionMetadataToCreatedTasks, } from './repo-aware-decomposition.js';
+import { generateWorkerOverlay, writeTeamWorkerInstructionsFile, removeTeamWorkerInstructionsFile, writeWorkerWorktreeRootAgentsFile, removeWorkerWorktreeRootAgentsFile, generateInitialInbox, generateTaskAssignmentInbox, generateShutdownInbox, buildTriggerDirective, buildMailboxTriggerDirective, buildLeaderMailboxTriggerDirective, writeWorkerRoleInstructionsFile, } from './worker-bootstrap.js';
+import { synthesizeDelegationPlan } from './delegation-policy.js';
+import { loadRolePrompt } from './role-router.js';
+import { composeRoleInstructionsForRole } from '../agents/native-config.js';
+import { codexPromptsDir } from '../utils/paths.js';
+import { isTerminalPhase } from './orchestrator.js';
+import { resolveTeamWorkerLaunchArgs, TEAM_LOW_COMPLEXITY_DEFAULT_MODEL, parseTeamWorkerLaunchArgs, splitWorkerLaunchArgs, resolveAgentDefaultModel, resolveAgentReasoningEffort, } from './model-contract.js';
+import { resolveCanonicalTeamStateRoot } from './state-root.js';
+import { buildInternalTeamName, resolveTeamIdentityScope, resolveTeamNameForCurrentContext } from './team-identity.js';
+import { inferPhaseTargetFromTaskCounts, reconcilePhaseStateForMonitor } from './phase-controller.js';
+import { getTeamTmuxSessions } from '../notifications/tmux.js';
+import { hasStructuredVerificationEvidence } from '../verification/verifier.js';
+import { buildRebalanceDecisions } from './rebalance-policy.js';
+import { getStatePath } from '../mcp/state-paths.js';
+import { readModeState, updateModeState } from '../modes/base.js';
+import { appendTeamCommitHygieneEntries, buildTeamCommitHygieneContext, resolveTeamCommitHygieneArtifactCwd, writeTeamCommitHygieneContext, } from './commit-hygiene.js';
+import { assertCleanLeaderWorkspaceForWorkerWorktrees, ensureWorktree, isGitRepository, isWorktreeDirty, planWorktreeTarget, removeWorktreeForce, rollbackProvisionedWorktrees, } from './worktree.js';
+import { cleanupRcsMcpProcesses, findLaunchSafeCleanupCandidates, } from '../cli/cleanup.js';
+async function syncRootTeamModeStateOnTerminalPhase(teamName, phase, cwd) {
+    if (phase !== 'complete' && phase !== 'failed' && phase !== 'cancelled')
+        return;
+    try {
+        const teamState = await readModeState('team', cwd);
+        if (!teamState)
+            return;
+        const stateTeamName = typeof teamState.team_name === 'string' ? teamState.team_name.trim() : '';
+        if (stateTeamName && stateTeamName !== teamName)
+            return;
+        const alreadySynced = teamState.active === false
+            && teamState.current_phase === phase
+            && typeof teamState.completed_at === 'string'
+            && teamState.completed_at.length > 0;
+        if (alreadySynced)
+            return;
+        const updates = {
+            active: false,
+            current_phase: phase,
+            team_name: teamName,
+        };
+        if (typeof teamState.completed_at !== 'string' || !teamState.completed_at) {
+            updates.completed_at = new Date().toISOString();
+        }
+        await updateModeState('team', updates, cwd);
+    }
+    catch {
+        // Best-effort compatibility sync only.
+    }
+}
+function matchesTeamModeStateForShutdown(state, teamName) {
+    const stateTeamName = typeof state?.team_name === 'string' ? state.team_name.trim() : '';
+    return !stateTeamName || stateTeamName === teamName;
+}
+async function syncExactTeamModeStateOnShutdown(teamName, cwd, sessionId) {
+    const path = getStatePath('team', cwd, sessionId);
+    if (!existsSync(path))
+        return;
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf-8'));
+        if (!matchesTeamModeStateForShutdown(parsed, teamName))
+            return;
+        const next = {
+            ...parsed,
+            active: false,
+            current_phase: 'cancelled',
+            completed_at: typeof parsed.completed_at === 'string' && parsed.completed_at.trim().length > 0
+                ? parsed.completed_at
+                : new Date().toISOString(),
+            team_name: teamName,
+        };
+        await writeFile(path, JSON.stringify(next, null, 2));
+    }
+    catch {
+        // Best-effort compatibility sync only.
+    }
+}
+async function syncTeamModeStateOnShutdown(teamName, cwd, leaderSessionId) {
+    await syncExactTeamModeStateOnShutdown(teamName, cwd);
+    const normalizedLeaderSessionId = typeof leaderSessionId === 'string' ? leaderSessionId.trim() : '';
+    if (normalizedLeaderSessionId) {
+        await syncExactTeamModeStateOnShutdown(teamName, cwd, normalizedLeaderSessionId);
+    }
+}
+async function assertTeamStartupIsNonDestructive(teamName, cwd, leaderSessionId) {
+    const activeTeams = await findActiveTeams(cwd, leaderSessionId);
+    if (activeTeams.length > 0) {
+        throw new Error(`leader_session_conflict: active team exists (${activeTeams.join(', ')})`);
+    }
+    const [existingConfig, existingManifest, existingPhase] = await Promise.all([
+        readTeamConfig(teamName, cwd),
+        readTeamManifestV2(teamName, cwd),
+        readTeamPhaseState(teamName, cwd),
+    ]);
+    if (!existingConfig && !existingManifest)
+        return;
+    const currentPhase = existingPhase?.current_phase;
+    if (currentPhase && isTerminalPhase(currentPhase))
+        return;
+    const tmuxSession = existingConfig?.tmux_session ?? existingManifest?.tmux_session ?? `rcs-team-${teamName}`;
+    const renderedPhase = currentPhase ?? 'team-exec';
+    throw new Error(`team_name_conflict: active team state already exists for "${teamName}" (phase: ${renderedPhase}, tmux: ${tmuxSession}). `
+        + `Use "rcs team status ${teamName}", "rcs team resume ${teamName}", or "rcs team shutdown ${teamName}" instead of launching a duplicate team.`);
+}
+export function applyCreatedInteractiveSessionToConfig(config, createdSession, workerPaneIds) {
+    config.tmux_session = createdSession.name;
+    config.leader_pane_id = createdSession.leaderPaneId;
+    config.hud_pane_id = createdSession.hudPaneId;
+    config.resize_hook_name = createdSession.resizeHookName;
+    config.resize_hook_target = createdSession.resizeHookTarget;
+    for (let i = 0; i < createdSession.workerPaneIds.length; i++) {
+        const paneId = createdSession.workerPaneIds[i];
+        workerPaneIds[i] = paneId;
+        if (config.workers[i]) {
+            config.workers[i].pane_id = paneId;
+        }
+    }
+}
+function collectShutdownPaneIds(params) {
+    const { config, livePaneIds = [], restoredStandaloneHudPaneId = null, leaderPaneId = config.leader_pane_id, hudPaneId = config.hud_pane_id, } = params;
+    const excludedPaneIds = new Set([
+        leaderPaneId,
+        hudPaneId,
+        restoredStandaloneHudPaneId,
+    ].filter((paneId) => typeof paneId === 'string' && paneId.trim().startsWith('%')));
+    const paneIds = new Set();
+    for (const paneId of [
+        ...config.workers.map((worker) => worker.pane_id),
+        ...livePaneIds,
+    ]) {
+        if (typeof paneId !== 'string')
+            continue;
+        const normalized = paneId.trim();
+        if (!normalized.startsWith('%'))
+            continue;
+        if (excludedPaneIds.has(normalized))
+            continue;
+        paneIds.add(normalized);
+    }
+    return [...paneIds];
+}
+export function shouldPrekillInteractiveShutdownProcessTrees(sessionName) {
+    // Shared-window tmux sessions can expose overlapping ancestry around the
+    // invoking leader client. Rely on pane-targeted teardown there so shutdown
+    // does not signal the leader while tearing down worker panes.
+    if (sessionName.includes(':'))
+        return false;
+    // Detached session teardown still benefits from process-tree prekill,
+    // including native Windows prompt-worker ancestry where pane-targeted
+    // teardown alone is insufficient.
+    return true;
+}
+export async function cleanupTeamWorkerLaunchOrphanedMcpProcesses(dependencies = {}) {
+    const cleanup = dependencies.cleanup ?? (() => cleanupRcsMcpProcesses([], {
+        selectCandidates: findLaunchSafeCleanupCandidates,
+        writeLine: () => { },
+    }));
+    const writeWarning = dependencies.writeWarning ?? ((message) => process.stderr.write(`${message}\n`));
+    try {
+        const result = await cleanup();
+        if (result.failedPids.length > 0) {
+            writeWarning(`[team/runtime] Failed to reap ${result.failedPids.length} orphaned RCS MCP process(es); continuing worker launch.`);
+        }
+    }
+    catch (err) {
+        writeWarning(`[team/runtime] pre-launch MCP cleanup failed: ${err}; continuing worker launch.`);
+    }
+}
+async function logRuntimeDispatchOutcome(params) {
+    const { cwd, teamName, workerName, requestId, messageId, intent, outcome, source = 'team.runtime' } = params;
+    await appendTeamDeliveryLogForCwd(cwd, {
+        event: 'dispatch_result',
+        source,
+        team: teamName,
+        request_id: requestId,
+        message_id: messageId,
+        to_worker: workerName,
+        intent,
+        transport: outcome.transport,
+        result: outcome.ok ? 'confirmed' : 'failed',
+        reason: outcome.reason,
+    });
+}
+async function logStartupTiming(params) {
+    const { cwd, teamName, workerName, event, paneId, elapsedMs, reason, requestId, transport } = params;
+    await appendTeamDeliveryLogForCwd(cwd, {
+        event: 'startup_timing',
+        source: 'team.runtime',
+        team: teamName,
+        to_worker: workerName,
+        startup_event: event,
+        pane_id: paneId,
+        elapsed_ms: typeof elapsedMs === 'number' ? Math.round(elapsedMs) : undefined,
+        reason,
+        request_id: requestId,
+        transport,
+    });
+}
+function collectProvisionedShutdownWorktrees(config) {
+    const seenWorktreePaths = new Set();
+    const worktrees = [];
+    for (const worker of config.workers) {
+        if (worker.worktree_created !== true)
+            continue;
+        if (worker.worktree_detached !== true)
+            continue;
+        if (!worker.worktree_repo_root || !worker.worktree_path)
+            continue;
+        if (!existsSync(worker.worktree_path))
+            continue;
+        const worktreePath = resolve(worker.worktree_path);
+        if (seenWorktreePaths.has(worktreePath))
+            continue;
+        seenWorktreePaths.add(worktreePath);
+        worktrees.push({
+            enabled: true,
+            repoRoot: worker.worktree_repo_root,
+            worktreePath,
+            detached: true,
+            branchName: null,
+            created: true,
+            reused: false,
+            createdBranch: false,
+        });
+    }
+    return worktrees;
+}
+function runCommand(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    return {
+        ok: result.status === 0,
+        stdout: (result.stdout || '').trim(),
+        stderr: (result.stderr || '').trim(),
+        exitCode: result.status,
+    };
+}
+function runGitCommand(repoRoot, args, cwd = repoRoot) {
+    return runCommand('git', args, cwd);
+}
+function getWorktreeDiffText(worktreePath) {
+    const staged = runGitCommand(worktreePath, ['diff', '--cached', '--stat', '--patch'], worktreePath);
+    if (staged.ok && staged.stdout)
+        return staged.stdout;
+    const unstaged = runGitCommand(worktreePath, ['diff', '--stat', '--patch'], worktreePath);
+    if (unstaged.ok && unstaged.stdout)
+        return unstaged.stdout;
+    const againstHead = runGitCommand(worktreePath, ['diff', 'HEAD', '--stat', '--patch'], worktreePath);
+    if (againstHead.ok && againstHead.stdout)
+        return againstHead.stdout;
+    return '';
+}
+function summarizeWorktreeDiffWithSparkShell(worktreePath) {
+    const shellCommand = `git diff --cached --stat --patch || git diff --stat --patch || git diff HEAD --stat --patch`;
+    const result = runCommand('rcs', ['sparkshell', 'sh', '-lc', shellCommand], worktreePath);
+    if (!result.ok || !result.stdout)
+        return null;
+    return result.stdout;
+}
+function resolveWorkerHead(worktreePath) {
+    const head = runGitCommand(worktreePath, ['rev-parse', 'HEAD'], worktreePath);
+    return head.ok && head.stdout ? head.stdout : null;
+}
+function resolveLeaderHead(repoRoot, leaderCwd) {
+    const head = runGitCommand(repoRoot, ['rev-parse', 'HEAD'], leaderCwd);
+    return head.ok && head.stdout ? head.stdout : null;
+}
+function listCommitRange(repoRoot, baseRef, headRef, cwd) {
+    if (!baseRef || !headRef || baseRef === headRef)
+        return [];
+    const range = runGitCommand(repoRoot, ['rev-list', '--reverse', `${baseRef}..${headRef}`], cwd);
+    if (!range.ok || !range.stdout)
+        return [];
+    return range.stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+}
+function listConflictFiles(repoRoot, cwd) {
+    const result = runGitCommand(repoRoot, ['diff', '--name-only', '--diff-filter=U'], cwd);
+    if (!result.ok || !result.stdout)
+        return [];
+    return result.stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+}
+async function appendIntegrationEvent(teamName, type, worker, metadata, cwd) {
+    await appendTeamEvent(teamName, {
+        type,
+        worker: worker.name,
+        task_id: worker.assigned_tasks[0],
+        reason: typeof metadata.summary === 'string' ? metadata.summary : undefined,
+        metadata,
+    }, cwd);
+}
+async function sendIntegrationMessageToLeader(teamName, worker, body, cwd) {
+    await sendWorkerMessage(teamName, worker.name, 'leader-fixed', body, cwd).catch(() => { });
+}
+function leaderHeadAdvanced(before, after) {
+    return typeof after === 'string' && after.length > 0 && after !== before;
+}
+async function recordIntegrationFailure(teamName, worker, state, details, cwd) {
+    const leaderHeadAfter = details.leaderHeadAfter ?? details.leaderHeadBefore;
+    const sourceShort = details.sourceCommit.slice(0, 12);
+    const leaderShort = details.leaderHeadBefore.slice(0, 12);
+    state.last_leader_head = leaderHeadAfter;
+    state.status = 'integration_failed';
+    state.conflict_commit = details.sourceCommit;
+    state.conflict_files = undefined;
+    state.updated_at = new Date().toISOString();
+    await appendIntegrationEvent(teamName, 'worker_integration_failed', worker, {
+        worker_name: worker.name,
+        operation: details.operation,
+        source_commit: details.sourceCommit,
+        leader_head_before: details.leaderHeadBefore,
+        leader_head_after: leaderHeadAfter,
+        worktree_path: details.worktreePath,
+        summary: `${details.operation} for ${worker.name} reported success but leader HEAD did not advance`,
+    }, cwd);
+    appendIntegrationReport(teamName, {
+        workerName: worker.name,
+        operation: details.operation,
+        strategy: details.strategy,
+        files: [],
+        detail: `${details.operation} reported success for ${sourceShort}, but leader HEAD did not advance from ${leaderShort}; not marking worker as integrated.`,
+    }, cwd);
+    await sendIntegrationMessageToLeader(teamName, worker, `INTEGRATION FAILED: ${details.operation} for ${worker.name} reported success, but leader HEAD stayed at ${leaderShort}. Not emitting INTEGRATED; retry or inspect leader branch state before continuing.`, cwd);
+}
+async function emitCanonicalWorkerEvent(cwd, eventName, context) {
+    try {
+        const { buildNativeHookEvent } = await import('../hooks/extensibility/events.js');
+        const { dispatchHookEvent } = await import('../hooks/extensibility/dispatcher.js');
+        const event = buildNativeHookEvent(eventName, {
+            normalized_event: eventName,
+            scope: 'team-runtime',
+            ...context,
+        });
+        await dispatchHookEvent(event, { cwd });
+    }
+    catch {
+        // best effort only
+    }
+}
+function autoCommitDirtyWorktree(worker) {
+    const worktreePath = resolve(worker.worktree_path);
+    const repoRoot = resolve(worker.worktree_repo_root);
+    const status = runGitCommand(repoRoot, ['status', '--porcelain'], worktreePath);
+    if (!status.ok || !status.stdout.trim())
+        return { committed: false, commitHash: null };
+    const taskId = worker.assigned_tasks[0] || 'unknown';
+    const addResult = runGitCommand(repoRoot, ['add', '-A'], worktreePath);
+    if (!addResult.ok)
+        return { committed: false, commitHash: null };
+    const msg = `rcs(team): auto-checkpoint ${worker.name} [${taskId}]`;
+    const commitResult = runGitCommand(repoRoot, ['commit', '--no-verify', '-m', msg], worktreePath);
+    if (!commitResult.ok)
+        return { committed: false, commitHash: null };
+    const head = runGitCommand(repoRoot, ['rev-parse', 'HEAD'], worktreePath);
+    return { committed: true, commitHash: head.ok ? head.stdout : null };
+}
+function appendIntegrationReport(teamName, entry, cwd) {
+    const teamStateRoot = resolveCanonicalTeamStateRoot(cwd);
+    const reportPath = join(teamStateRoot, 'team', teamName, 'integration-report.md');
+    const dir = dirname(reportPath);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const timestamp = new Date().toISOString();
+    const line = `- [${timestamp}] ${entry.workerName}: ${entry.operation} conflict auto-resolved (${entry.strategy}) on files: ${entry.files.join(', ') || 'unknown'}. ${entry.detail}\n`;
+    appendFileSync(reportPath, existsSync(reportPath) ? line : `# Integration Report\n\n${line}`);
+}
+function resolveWorkerMergeRef(branchResult, workerHead) {
+    const branchRef = branchResult.ok ? branchResult.stdout.trim() : '';
+    if (!branchRef || branchRef === 'HEAD')
+        return workerHead;
+    return branchRef;
+}
+function leaderContainsCommit(repoRoot, cwd, commit) {
+    return runGitCommand(repoRoot, ['merge-base', '--is-ancestor', commit, 'HEAD'], cwd).ok;
+}
+async function integrateWorkerCommitsIntoLeader(params) {
+    const { teamName, config, previous, cwd } = params;
+    const next = { ...(previous?.integrationByWorker ?? {}) };
+    const leaderHeadAtCycleStart = resolveLeaderHead(resolve(config.workers[0]?.worktree_repo_root ?? cwd), cwd);
+    const integratedWorkerNames = new Set();
+    const commitHygieneEntries = [];
+    const artifactCwd = resolveTeamCommitHygieneArtifactCwd(config, cwd);
+    // ── Phase A: Auto-commit dirty worktrees ──
+    for (const worker of config.workers) {
+        if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path))
+            continue;
+        const { committed, commitHash } = autoCommitDirtyWorktree(worker);
+        if (committed) {
+            await appendIntegrationEvent(teamName, 'worker_auto_commit', worker, {
+                worker_name: worker.name,
+                commit_hash: commitHash,
+                worktree_path: resolve(worker.worktree_path),
+                summary: `auto-committed dirty worktree for ${worker.name}`,
+            }, cwd);
+            commitHygieneEntries.push({
+                recorded_at: new Date().toISOString(),
+                operation: 'auto_checkpoint',
+                worker_name: worker.name,
+                task_id: worker.assigned_tasks[0],
+                status: 'applied',
+                operational_commit: commitHash,
+                worktree_path: resolve(worker.worktree_path),
+                detail: 'Dirty worker worktree checkpointed before runtime integration.',
+            });
+        }
+    }
+    // ── Phase B: Integrate worker commits to leader (hybrid strategy) ──
+    for (const worker of config.workers) {
+        if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path))
+            continue;
+        const repoRoot = resolve(worker.worktree_repo_root);
+        const worktreePath = resolve(worker.worktree_path);
+        const leaderHead = resolveLeaderHead(repoRoot, cwd);
+        const workerHead = resolveWorkerHead(worktreePath);
+        const previousState = next[worker.name] ?? {};
+        const state = { ...previousState, last_leader_head: leaderHead ?? previousState.last_leader_head };
+        if (!workerHead || !leaderHead) {
+            next[worker.name] = state;
+            continue;
+        }
+        state.last_seen_head = workerHead;
+        const alreadyMerged = runGitCommand(repoRoot, ['merge-base', '--is-ancestor', workerHead, 'HEAD'], cwd).ok;
+        if (alreadyMerged) {
+            state.last_integrated_head = workerHead;
+            state.status = 'idle';
+            state.updated_at = new Date().toISOString();
+            next[worker.name] = state;
+            continue;
+        }
+        // Determine if worker is cleanly ahead of leader (merge) or diverged (cherry-pick)
+        const workerIsAheadOfLeader = runGitCommand(repoRoot, ['merge-base', '--is-ancestor', leaderHead, workerHead], cwd).ok;
+        if (workerIsAheadOfLeader) {
+            // Worker is cleanly ahead → merge --no-ff -X theirs
+            const workerBranch = runGitCommand(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
+            const branchRef = resolveWorkerMergeRef(workerBranch, workerHead);
+            const merge = runGitCommand(repoRoot, ['merge', '--no-ff', '-X', 'theirs', '-m', `rcs(team): merge ${worker.name}`, branchRef], cwd);
+            if (merge.ok) {
+                const newLeaderHead = resolveLeaderHead(repoRoot, cwd) ?? leaderHead;
+                const workerIntegrated = leaderContainsCommit(repoRoot, cwd, workerHead);
+                if (!leaderHeadAdvanced(leaderHead, newLeaderHead)) {
+                    await recordIntegrationFailure(teamName, worker, state, {
+                        operation: 'merge',
+                        sourceCommit: workerHead,
+                        leaderHeadBefore: leaderHead,
+                        leaderHeadAfter: newLeaderHead,
+                        worktreePath,
+                        strategy: '-X theirs',
+                    }, cwd);
+                }
+                else if (workerIntegrated) {
+                    state.last_integrated_head = workerHead;
+                    state.last_leader_head = newLeaderHead;
+                    state.status = 'integrated';
+                    state.conflict_commit = undefined;
+                    state.conflict_files = undefined;
+                    state.updated_at = new Date().toISOString();
+                    integratedWorkerNames.add(worker.name);
+                    await appendIntegrationEvent(teamName, 'worker_merge_applied', worker, {
+                        worker_name: worker.name,
+                        worker_head: workerHead,
+                        leader_head_before: leaderHead,
+                        leader_head_after: newLeaderHead,
+                        worktree_path: worktreePath,
+                        summary: `merged ${worker.name} into leader via --no-ff -X theirs`,
+                    }, cwd);
+                    await sendIntegrationMessageToLeader(teamName, worker, `INTEGRATED: merged ${worker.name} (${workerHead.slice(0, 12)}) into leader HEAD ${newLeaderHead.slice(0, 12)} via merge --no-ff.`, cwd);
+                    commitHygieneEntries.push({
+                        recorded_at: new Date().toISOString(),
+                        operation: 'integration_merge',
+                        worker_name: worker.name,
+                        task_id: worker.assigned_tasks[0],
+                        status: 'applied',
+                        operational_commit: newLeaderHead,
+                        source_commit: workerHead,
+                        leader_head_before: leaderHead,
+                        leader_head_after: newLeaderHead,
+                        worktree_path: worktreePath,
+                        detail: 'Leader created a runtime merge commit to integrate worker history.',
+                    });
+                }
+                else {
+                    state.last_leader_head = newLeaderHead;
+                    state.status = 'idle';
+                    state.updated_at = new Date().toISOString();
+                    appendIntegrationReport(teamName, {
+                        workerName: worker.name,
+                        operation: 'merge',
+                        strategy: '-X theirs',
+                        files: [],
+                        detail: `merge reported success but leader HEAD did not advance cleanly (leader_before=${leaderHead.slice(0, 12)}, leader_after=${newLeaderHead.slice(0, 12)}, worker_integrated=${workerIntegrated}, merge_ref=${branchRef}).`,
+                    }, cwd);
+                    await sendIntegrationMessageToLeader(teamName, worker, `INTEGRATION NO-OP: merge for ${worker.name} using ${branchRef.slice(0, 12)} reported success but leader HEAD stayed ${newLeaderHead.slice(0, 12)}. Inspect ${worktreePath}.`, cwd);
+                    commitHygieneEntries.push({
+                        recorded_at: new Date().toISOString(),
+                        operation: 'integration_merge',
+                        worker_name: worker.name,
+                        task_id: worker.assigned_tasks[0],
+                        status: 'skipped',
+                        operational_commit: newLeaderHead,
+                        source_commit: workerHead,
+                        leader_head_before: leaderHead,
+                        leader_head_after: newLeaderHead,
+                        worktree_path: worktreePath,
+                        detail: 'Merge command reported success but leader HEAD did not advance or contain the worker commit; runtime refused to report false integration.',
+                    });
+                }
+            }
+            else {
+                // Merge failed even with -X theirs (e.g. binary conflict) — abort and log
+                const conflictFiles = listConflictFiles(repoRoot, cwd);
+                runGitCommand(repoRoot, ['merge', '--abort'], cwd);
+                state.status = 'cherry_pick_conflict';
+                state.conflict_commit = workerHead;
+                state.conflict_files = conflictFiles;
+                state.updated_at = new Date().toISOString();
+                await appendIntegrationEvent(teamName, 'worker_merge_conflict', worker, {
+                    worker_name: worker.name,
+                    worker_head: workerHead,
+                    leader_head: leaderHead,
+                    worktree_path: worktreePath,
+                    conflict_files: conflictFiles,
+                    stderr: merge.stderr || merge.stdout,
+                    summary: `merge conflict for ${worker.name} (auto-resolve failed)`,
+                }, cwd);
+                appendIntegrationReport(teamName, {
+                    workerName: worker.name,
+                    operation: 'merge',
+                    strategy: '-X theirs',
+                    files: conflictFiles,
+                    detail: `merge --no-ff -X theirs failed; aborted. stderr: ${(merge.stderr || '').slice(0, 200)}`,
+                }, cwd);
+                await sendIntegrationMessageToLeader(teamName, worker, `CONFLICT AUTO-RESOLVED FAILED: ${worker.name}'s merge resolved with -X theirs failed on files: ${conflictFiles.join(', ') || 'unknown'}. Consider steering ${worker.name} to review these areas.`, cwd);
+            }
+        }
+        else {
+            // Diverged → cherry-pick individual commits with -X theirs
+            const baseline = state.last_integrated_head && runGitCommand(repoRoot, ['rev-parse', '--verify', state.last_integrated_head], worktreePath).ok
+                ? state.last_integrated_head
+                : leaderHead;
+            const commits = listCommitRange(repoRoot, baseline, workerHead, worktreePath);
+            if (commits.length === 0) {
+                next[worker.name] = state;
+                continue;
+            }
+            let allPicked = true;
+            for (const commit of commits) {
+                await appendIntegrationEvent(teamName, 'worker_cherry_pick_detected', worker, {
+                    worker_name: worker.name,
+                    worker_head: workerHead,
+                    commit,
+                    leader_head: resolveLeaderHead(repoRoot, cwd),
+                    worktree_path: worktreePath,
+                    summary: `detected worker commit ${commit.slice(0, 12)}`,
+                }, cwd);
+                const pick = runGitCommand(repoRoot, ['cherry-pick', '--allow-empty', '-X', 'theirs', commit], cwd);
+                if (!pick.ok) {
+                    // Even -X theirs failed (binary conflict etc.) — abort this commit, log, continue
+                    const conflictFiles = listConflictFiles(repoRoot, cwd);
+                    runGitCommand(repoRoot, ['cherry-pick', '--abort'], cwd);
+                    state.status = 'cherry_pick_conflict';
+                    state.conflict_commit = commit;
+                    state.conflict_files = conflictFiles;
+                    state.updated_at = new Date().toISOString();
+                    await appendIntegrationEvent(teamName, 'worker_cherry_pick_conflict', worker, {
+                        worker_name: worker.name,
+                        commit,
+                        leader_head: leaderHead,
+                        worktree_path: worktreePath,
+                        conflict_files: conflictFiles,
+                        stderr: pick.stderr || pick.stdout,
+                        summary: `cherry-pick conflict for ${worker.name} at ${commit.slice(0, 12)} (auto-resolve failed)`,
+                    }, cwd);
+                    appendIntegrationReport(teamName, {
+                        workerName: worker.name,
+                        operation: 'cherry-pick',
+                        strategy: '-X theirs',
+                        files: conflictFiles,
+                        detail: `cherry-pick -X theirs ${commit.slice(0, 12)} failed; aborted. stderr: ${(pick.stderr || '').slice(0, 200)}`,
+                    }, cwd);
+                    await sendIntegrationMessageToLeader(teamName, worker, `CONFLICT AUTO-RESOLVED FAILED: ${worker.name}'s cherry-pick ${commit.slice(0, 12)} with -X theirs failed on files: ${conflictFiles.join(', ') || 'unknown'}. Consider steering ${worker.name} to review these areas.`, cwd);
+                    allPicked = false;
+                    break;
+                }
+                const newLeaderHead = resolveLeaderHead(repoRoot, cwd) ?? leaderHead;
+                if (!leaderHeadAdvanced(leaderHead, newLeaderHead)) {
+                    await recordIntegrationFailure(teamName, worker, state, {
+                        operation: 'cherry-pick',
+                        sourceCommit: commit,
+                        leaderHeadBefore: leaderHead,
+                        leaderHeadAfter: newLeaderHead,
+                        worktreePath,
+                        strategy: '-X theirs',
+                    }, cwd);
+                    allPicked = false;
+                    break;
+                }
+                state.last_integrated_head = commit;
+                state.last_leader_head = newLeaderHead;
+                state.status = 'integrated';
+                state.conflict_commit = undefined;
+                state.conflict_files = undefined;
+                state.updated_at = new Date().toISOString();
+                await appendIntegrationEvent(teamName, 'worker_cherry_pick_applied', worker, {
+                    worker_name: worker.name,
+                    commit,
+                    leader_head_before: leaderHead,
+                    leader_head_after: newLeaderHead,
+                    worktree_path: worktreePath,
+                    summary: `cherry-picked ${commit.slice(0, 12)} from ${worker.name} with -X theirs`,
+                }, cwd);
+                await sendIntegrationMessageToLeader(teamName, worker, `INTEGRATED: cherry-picked ${commit.slice(0, 12)} from ${worker.name} into leader HEAD ${newLeaderHead.slice(0, 12)} (-X theirs).`, cwd);
+                commitHygieneEntries.push({
+                    recorded_at: new Date().toISOString(),
+                    operation: 'integration_cherry_pick',
+                    worker_name: worker.name,
+                    task_id: worker.assigned_tasks[0],
+                    status: 'applied',
+                    operational_commit: newLeaderHead,
+                    source_commit: commit,
+                    leader_head_before: leaderHead,
+                    leader_head_after: newLeaderHead,
+                    worktree_path: worktreePath,
+                    detail: 'Leader created a runtime cherry-pick commit while integrating diverged worker history.',
+                });
+            }
+            if (allPicked) {
+                integratedWorkerNames.add(worker.name);
+            }
+        }
+        next[worker.name] = state;
+    }
+    // ── Phase C: Cross-worker rebase (idle/done/failed workers onto new leader) ──
+    const newLeaderHead = resolveLeaderHead(resolve(config.workers[0]?.worktree_repo_root ?? cwd), cwd);
+    if (newLeaderHead && leaderHeadAtCycleStart && newLeaderHead !== leaderHeadAtCycleStart) {
+        for (const worker of config.workers) {
+            if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path))
+                continue;
+            // Note: do NOT skip integratedWorkerNames here — cherry-picked workers need
+            // rebase to pick up other workers' changes that landed on leader in the same cycle.
+            const repoRoot = resolve(worker.worktree_repo_root);
+            const worktreePath = resolve(worker.worktree_path);
+            // Only rebase idle/done/failed workers to avoid race conditions
+            const workerStatus = await readWorkerStatus(teamName, worker.name, cwd);
+            const rebaseEligibleStates = new Set(['idle', 'done', 'failed']);
+            if (!rebaseEligibleStates.has(workerStatus.state)) {
+                await appendIntegrationEvent(teamName, 'worker_cross_rebase_skipped', worker, {
+                    worker_name: worker.name,
+                    worker_state: workerStatus.state,
+                    leader_head: newLeaderHead,
+                    worktree_path: worktreePath,
+                    summary: `skipped cross-rebase for ${worker.name} (state: ${workerStatus.state})`,
+                }, cwd);
+                continue;
+            }
+            // Skip if worktree is dirty (will auto-commit next cycle, then rebase)
+            const statusCheck = runGitCommand(repoRoot, ['status', '--porcelain'], worktreePath);
+            if (statusCheck.ok && statusCheck.stdout.trim()) {
+                await appendIntegrationEvent(teamName, 'worker_cross_rebase_skipped', worker, {
+                    worker_name: worker.name,
+                    reason: 'dirty_worktree',
+                    leader_head: newLeaderHead,
+                    worktree_path: worktreePath,
+                    summary: `skipped cross-rebase for ${worker.name} (dirty worktree)`,
+                }, cwd);
+                continue;
+            }
+            // Rebase with -X ours (in rebase context, "ours" = upstream = leader wins)
+            const workerHeadBeforeRebase = resolveWorkerHead(worktreePath);
+            const rebase = runGitCommand(repoRoot, ['rebase', '-X', 'ours', newLeaderHead], worktreePath);
+            if (rebase.ok) {
+                const workerHeadAfterRebase = resolveWorkerHead(worktreePath);
+                const state = next[worker.name] ?? {};
+                state.last_rebased_leader_head = newLeaderHead;
+                state.status = 'idle';
+                state.conflict_commit = undefined;
+                state.conflict_files = undefined;
+                state.updated_at = new Date().toISOString();
+                next[worker.name] = state;
+                await appendIntegrationEvent(teamName, 'worker_cross_rebase_applied', worker, {
+                    worker_name: worker.name,
+                    leader_head: newLeaderHead,
+                    worktree_path: worktreePath,
+                    summary: `cross-rebased ${worker.name} onto ${newLeaderHead.slice(0, 12)} (-X ours)`,
+                }, cwd);
+                commitHygieneEntries.push({
+                    recorded_at: new Date().toISOString(),
+                    operation: 'cross_rebase',
+                    worker_name: worker.name,
+                    task_id: worker.assigned_tasks[0],
+                    status: 'applied',
+                    operational_commit: workerHeadAfterRebase,
+                    leader_head_after: newLeaderHead,
+                    worker_head_before: workerHeadBeforeRebase,
+                    worker_head_after: workerHeadAfterRebase,
+                    worktree_path: worktreePath,
+                    detail: 'Runtime rebase rewrote worker history onto the updated leader head.',
+                });
+            }
+            else {
+                // Rebase failed — abort to restore worktree, log for retry next cycle
+                const conflictFiles = listConflictFiles(repoRoot, worktreePath);
+                runGitCommand(repoRoot, ['rebase', '--abort'], worktreePath);
+                await appendIntegrationEvent(teamName, 'worker_cross_rebase_conflict', worker, {
+                    worker_name: worker.name,
+                    leader_head: newLeaderHead,
+                    worktree_path: worktreePath,
+                    conflict_files: conflictFiles,
+                    stderr: rebase.stderr || rebase.stdout,
+                    summary: `cross-rebase conflict for ${worker.name} onto ${newLeaderHead.slice(0, 12)} (aborted, will retry)`,
+                }, cwd);
+                appendIntegrationReport(teamName, {
+                    workerName: worker.name,
+                    operation: 'rebase',
+                    strategy: '-X ours',
+                    files: conflictFiles,
+                    detail: `rebase -X ours onto ${newLeaderHead.slice(0, 12)} failed; aborted. Will retry next cycle.`,
+                }, cwd);
+                await sendIntegrationMessageToLeader(teamName, worker, `CONFLICT AUTO-RESOLVED FAILED: ${worker.name}'s rebase onto ${newLeaderHead.slice(0, 12)} with -X ours failed on files: ${conflictFiles.join(', ') || 'unknown'}. Consider steering ${worker.name} to review these areas.`, cwd);
+            }
+        }
+    }
+    if (commitHygieneEntries.length > 0) {
+        await appendTeamCommitHygieneEntries(teamName, commitHygieneEntries, artifactCwd);
+    }
+    return next;
+}
+function renderWorktreeMergeReport(report) {
+    const lines = [
+        `# Worker ${report.workerName} shutdown report`,
+        '',
+        `- worktree: ${report.worktreePath}`,
+        `- report_path: ${report.reportPath}`,
+        `- source_ref: ${report.sourceRef ?? 'none'}`,
+        `- synthetic_commit: ${report.syntheticCommit ?? 'none'}`,
+        `- merge_outcome: ${report.mergeOutcome}`,
+        `- merge_detail: ${report.mergeDetail}`,
+        `- leader_head_before: ${report.leaderHeadBefore ?? 'none'}`,
+        `- leader_head_after: ${report.leaderHeadAfter ?? 'none'}`,
+        '',
+        '## Summary',
+        report.summaryText ?? 'sparkshell summary unavailable; using raw diff fallback.',
+        '',
+        '## Diff',
+        report.diffText || '(no diff output)',
+        '',
+    ];
+    return lines.join('\n');
+}
+async function prepareShutdownMergeReport(worker, leaderCwd) {
+    if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path)) {
+        return null;
+    }
+    const worktreePath = resolve(worker.worktree_path);
+    const repoRoot = resolve(worker.worktree_repo_root);
+    const statusBefore = runGitCommand(repoRoot, ['status', '--porcelain'], worktreePath);
+    const hadChanges = statusBefore.ok && statusBefore.stdout.length > 0;
+    let syntheticCommit = null;
+    if (hadChanges) {
+        const addResult = runGitCommand(repoRoot, ['add', '-A'], worktreePath);
+        if (!addResult.ok) {
+            return {
+                workerName: worker.name,
+                worktreePath,
+                reportPath: join(worktreePath, '.rcs', 'diff.md'),
+                sourceRef: null,
+                syntheticCommit: null,
+                diffText: getWorktreeDiffText(worktreePath),
+                summaryText: null,
+                mergeOutcome: 'skipped',
+                mergeDetail: addResult.stderr || 'git add -A failed',
+                leaderHeadBefore: resolveLeaderHead(repoRoot, leaderCwd),
+                leaderHeadAfter: resolveLeaderHead(repoRoot, leaderCwd),
+            };
+        }
+        const commitResult = runGitCommand(repoRoot, ['commit', '--no-verify', '-m', `rcs(team): checkpoint ${worker.name} shutdown changes`], worktreePath);
+        if (commitResult.ok) {
+            const revParse = runGitCommand(repoRoot, ['rev-parse', 'HEAD'], worktreePath);
+            syntheticCommit = revParse.ok && revParse.stdout ? revParse.stdout : null;
+        }
+        else if (!/nothing to commit/i.test(commitResult.stderr)) {
+            return {
+                workerName: worker.name,
+                worktreePath,
+                reportPath: join(worktreePath, '.rcs', 'diff.md'),
+                sourceRef: null,
+                syntheticCommit: null,
+                diffText: getWorktreeDiffText(worktreePath),
+                summaryText: null,
+                mergeOutcome: 'skipped',
+                mergeDetail: commitResult.stderr || 'git commit failed',
+                leaderHeadBefore: resolveLeaderHead(repoRoot, leaderCwd),
+                leaderHeadAfter: resolveLeaderHead(repoRoot, leaderCwd),
+            };
+        }
+    }
+    const sourceRefResult = runGitCommand(repoRoot, ['rev-parse', 'HEAD'], worktreePath);
+    const sourceRef = sourceRefResult.ok && sourceRefResult.stdout ? sourceRefResult.stdout : null;
+    const diffText = getWorktreeDiffText(worktreePath);
+    const summaryText = summarizeWorktreeDiffWithSparkShell(worktreePath);
+    const reportPath = join(worktreePath, '.rcs', 'diff.md');
+    const leaderHeadBefore = resolveLeaderHead(repoRoot, leaderCwd);
+    let mergeOutcome = 'skipped';
+    let mergeDetail = 'worktree merge skipped';
+    let leaderHeadAfter = leaderHeadBefore;
+    if (sourceRef) {
+        const alreadyMerged = runGitCommand(repoRoot, ['merge-base', '--is-ancestor', sourceRef, 'HEAD'], leaderCwd);
+        if (alreadyMerged.ok) {
+            mergeOutcome = 'noop';
+            mergeDetail = 'source already reachable from leader HEAD';
+        }
+        else {
+            const mergeResult = runGitCommand(repoRoot, ['merge', '--no-ff', '--no-edit', sourceRef], leaderCwd);
+            if (mergeResult.ok) {
+                mergeOutcome = 'merged';
+                mergeDetail = mergeResult.stdout || 'merged successfully';
+                leaderHeadAfter = resolveLeaderHead(repoRoot, leaderCwd) ?? leaderHeadBefore;
+            }
+            else {
+                mergeOutcome = 'conflict';
+                mergeDetail = mergeResult.stderr || mergeResult.stdout || 'merge failed';
+                runGitCommand(repoRoot, ['merge', '--abort'], leaderCwd);
+                leaderHeadAfter = resolveLeaderHead(repoRoot, leaderCwd) ?? leaderHeadBefore;
+            }
+        }
+    }
+    const report = {
+        workerName: worker.name,
+        worktreePath,
+        reportPath,
+        sourceRef,
+        syntheticCommit,
+        diffText,
+        summaryText,
+        mergeOutcome,
+        mergeDetail,
+        leaderHeadBefore,
+        leaderHeadAfter,
+    };
+    await mkdir(join(worktreePath, '.rcs'), { recursive: true });
+    await writeFile(reportPath, renderWorktreeMergeReport(report), 'utf-8');
+    process.stdout.write(`${renderWorktreeMergeReport(report)}\n`);
+    return report;
+}
+async function prepareWorkerWorktreeShutdownReports(config, leaderCwd) {
+    const reports = [];
+    for (const worker of config.workers) {
+        if (!worker.worktree_path || !worker.worktree_repo_root)
+            continue;
+        try {
+            const report = await prepareShutdownMergeReport(worker, leaderCwd);
+            if (report)
+                reports.push(report);
+        }
+        catch (error) {
+            const worktreePath = resolve(worker.worktree_path);
+            const reportPath = join(worktreePath, '.rcs', 'diff.md');
+            const fallback = [
+                `# Worker ${worker.name} shutdown report`,
+                '',
+                `- worktree: ${worktreePath}`,
+                `- report_path: ${reportPath}`,
+                '- merge_outcome: skipped',
+                `- merge_detail: ${String(error)}`,
+                '',
+            ].join('\n');
+            await mkdir(join(worktreePath, '.rcs'), { recursive: true }).catch(() => { });
+            await writeFile(reportPath, fallback, 'utf-8').catch(() => { });
+            process.stdout.write(`${fallback}\n`);
+        }
+    }
+    return reports;
+}
+function listDirtyShutdownWorkers(config) {
+    const dirtyWorkers = [];
+    for (const worker of config.workers) {
+        if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path))
+            continue;
+        const worktreePath = resolve(worker.worktree_path);
+        const repoRoot = resolve(worker.worktree_repo_root);
+        const status = runGitCommand(repoRoot, ['status', '--porcelain'], worktreePath);
+        if (!status.ok || status.stdout.trim().length > 0) {
+            dirtyWorkers.push(worker.name);
+        }
+    }
+    return dirtyWorkers;
+}
+async function classifyShutdown(params) {
+    const { teamName, cwd, config, governance, confirmIssues } = params;
+    const allTasks = await listTasks(teamName, cwd);
+    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,
+    };
+    const dirtyWorkers = listDirtyShutdownWorkers(config);
+    const hasBlockingBacklog = gate.pending > 0 || gate.blocked > 0 || gate.in_progress > 0;
+    const requiresIssueConfirmation = gate.failed > 0 && dirtyWorkers.length === 0 && !confirmIssues;
+    gate.allowed = governance.cleanup_requires_all_workers_inactive !== true
+        || (!hasBlockingBacklog && !requiresIssueConfirmation);
+    return {
+        gate,
+        dirtyWorkers,
+        requiresIssueConfirmation,
+        useCleanFastPath: dirtyWorkers.length === 0 && !hasBlockingBacklog && (gate.failed === 0 || confirmIssues),
+    };
+}
+function resolveEffectiveTeamWorktreeMode(leaderCwd, requestedMode) {
+    if (!isGitRepository(leaderCwd)) {
+        return { enabled: false };
+    }
+    if (requestedMode?.enabled)
+        return requestedMode;
+    try {
+        const probe = planWorktreeTarget({
+            cwd: leaderCwd,
+            scope: 'team',
+            mode: { enabled: true, detached: true, name: null },
+            teamName: 'probe',
+            workerName: 'worker-1',
+        });
+        if (probe.enabled) {
+            return { enabled: true, detached: true, name: null };
+        }
+    }
+    catch {
+        // Non-git directories should keep legacy single-workspace behavior.
+    }
+    return { enabled: false };
+}
+const MODEL_INSTRUCTIONS_FILE_ENV = 'RCS_MODEL_INSTRUCTIONS_FILE';
+const TEAM_STATE_ROOT_ENV = 'RCS_TEAM_STATE_ROOT';
+const TEAM_LEADER_CWD_ENV = 'RCS_TEAM_LEADER_CWD';
+const WORKTREE_TRIGGER_STATE_ROOT = '$RCS_TEAM_STATE_ROOT';
+const STARTUP_EVIDENCE_TIMEOUT_MS = 15_000;
+const STARTUP_EVIDENCE_POLL_MS = 100;
+const STARTUP_EVIDENCE_LAUNCH_TIMEOUT_MS = 45_000;
+const STARTUP_TIMING_LOG_VERSION = 1;
+function createStartupTimingRecorder(teamName, cwd) {
+    const startedAt = performance.now();
+    const events = [];
+    return {
+        mark: (phase, details = {}) => {
+            events.push({
+                phase,
+                at: new Date().toISOString(),
+                elapsed_ms: Math.round((performance.now() - startedAt) * 1000) / 1000,
+                ...details,
+            });
+        },
+        flush: async () => {
+            const timingPath = join(cwd, '.rcs', 'state', 'team', teamName, 'startup-timing.json');
+            await writeAtomic(timingPath, JSON.stringify({ schema_version: STARTUP_TIMING_LOG_VERSION, team_name: teamName, events }, null, 2)).catch(() => { });
+            for (const event of events) {
+                await appendTeamDeliveryLogForCwd(cwd, {
+                    event: 'dispatch_result',
+                    source: 'team.runtime.startup-timing',
+                    team: teamName,
+                    result: event.ok === false ? 'failed' : 'ok',
+                    phase: event.phase,
+                    elapsed_ms: event.elapsed_ms,
+                    to_worker: event.worker,
+                    pane_id: event.pane_id,
+                    reason: event.reason,
+                    transport: event.transport,
+                    request_id: event.request_id,
+                });
+            }
+        },
+    };
+}
+const promptWorkerRegistry = new Map();
+const previousModelInstructionsFileByTeam = new Map();
+const PROMPT_WORKER_SIGTERM_WAIT_MS = 3_000;
+const PROMPT_WORKER_SIGKILL_WAIT_MS = 2_000;
+const PROMPT_WORKER_EXIT_POLL_MS = 100;
+const STARTUP_DISPATCH_RETRIES = 3;
+const STARTUP_DISPATCH_RETRY_DELAY_S = 3;
+const PROMPT_MODE_CODEX_UNSUPPORTED_REASON = 'prompt_mode_codex_requires_tty';
+// Test-only escape hatch for fake prompt workers that intentionally do not require a real TTY.
+const PROMPT_MODE_CODEX_TEST_ALLOW_ENV = 'RCS_TEST_ALLOW_NONTTY_CODEX_PROMPT';
+function resolveInstructionStateRoot(worktreePath) {
+    return worktreePath ? WORKTREE_TRIGGER_STATE_ROOT : undefined;
+}
+function assertPromptModeWorkerCliSupported(workerCliPlan) {
+    if (workerCliPlan.some((workerCli) => workerCli === 'codex')
+        && process.env[PROMPT_MODE_CODEX_TEST_ALLOW_ENV] !== '1') {
+        throw new Error(`${PROMPT_MODE_CODEX_UNSUPPORTED_REASON}: Codex prompt workers require a terminal; use interactive team mode or set RCS_TEAM_WORKER_CLI=claude/gemini for prompt-mode teammates.`);
+    }
+}
+function resolveWorkerReadyTimeoutMs(env) {
+    const raw = env.RCS_TEAM_READY_TIMEOUT_MS;
+    const parsed = Number.parseInt(String(raw ?? ''), 10);
+    if (Number.isFinite(parsed) && parsed >= 5_000)
+        return parsed;
+    return 45_000;
+}
+function resolveWorkerStartupEvidenceTimeoutMs(env, workerReadyTimeoutMs) {
+    const raw = Number.parseInt(String(env.RCS_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS ?? ''), 10);
+    if (Number.isFinite(raw) && raw >= 500)
+        return raw;
+    return Math.max(STARTUP_EVIDENCE_TIMEOUT_MS, Math.min(workerReadyTimeoutMs, STARTUP_EVIDENCE_LAUNCH_TIMEOUT_MS));
+}
+function resolveStartupDispatchRetries(env) {
+    const parsed = Number.parseInt(String(env.RCS_TEAM_STARTUP_DISPATCH_RETRIES ?? ''), 10);
+    if (!Number.isFinite(parsed))
+        return STARTUP_DISPATCH_RETRIES;
+    return Math.max(1, Math.min(STARTUP_DISPATCH_RETRIES, Math.floor(parsed)));
+}
+function resolveStartupDispatchRetryDelayS(env) {
+    const parsed = Number.parseInt(String(env.RCS_TEAM_STARTUP_DISPATCH_RETRY_DELAY_MS ?? ''), 10);
+    if (!Number.isFinite(parsed))
+        return STARTUP_DISPATCH_RETRY_DELAY_S;
+    return Math.max(0, Math.min(STARTUP_DISPATCH_RETRY_DELAY_S, Math.floor(parsed) / 1000));
+}
+function parseTeamWorkerContext(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return null;
+    const [teamName, workerName] = raw.trim().split('/');
+    if (!teamName || !workerName)
+        return null;
+    return { teamName, workerName };
+}
+function resolveManifestLookupCwds(cwd) {
+    const candidates = new Set([resolve(cwd)]);
+    const leaderCwd = process.env[TEAM_LEADER_CWD_ENV];
+    if (typeof leaderCwd === 'string' && leaderCwd.trim() !== '') {
+        candidates.add(resolve(leaderCwd));
+    }
+    const teamStateRoot = process.env[TEAM_STATE_ROOT_ENV];
+    if (typeof teamStateRoot === 'string' && teamStateRoot.trim() !== '') {
+        candidates.add(resolve(teamStateRoot, '..', '..'));
+    }
+    return [...candidates];
+}
+function resolveGovernancePolicy(governance, legacyPolicy) {
+    return normalizeTeamGovernance(governance, legacyPolicy);
+}
+async function assertNestedTeamAllowed(cwd) {
+    const workerContext = parseTeamWorkerContext(process.env.RCS_TEAM_INTERNAL_WORKER || process.env.RCS_TEAM_WORKER);
+    if (!workerContext)
+        return;
+    for (const candidateCwd of resolveManifestLookupCwds(cwd)) {
+        const manifest = await readTeamManifestV2(workerContext.teamName, candidateCwd);
+        const governance = resolveGovernancePolicy(manifest?.governance);
+        if (governance.nested_teams_allowed)
+            return;
+        if (manifest)
+            break;
+    }
+    throw new Error('nested_team_disallowed');
+}
+async function readWorkerStartupEvidence(teamName, workerName, cwd) {
+    const status = await readWorkerStatus(teamName, workerName, cwd);
+    if (typeof status.current_task_id === 'string' && status.current_task_id.trim() !== '') {
+        return 'task_claim';
+    }
+    if (status.state === 'working' || status.state === 'blocked' || status.state === 'done' || status.state === 'failed') {
+        return 'worker_progress';
+    }
+    const leaderMailbox = await listMailboxMessages(teamName, 'leader-fixed', cwd).catch(() => []);
+    if (leaderMailbox.some((message) => message?.from_worker === workerName)) {
+        return 'leader_ack';
+    }
+    return 'none';
+}
+function doesStartupEvidenceSettle(workerCli, evidence) {
+    if (evidence === 'none')
+        return false;
+    if (workerCli === 'codex' && evidence === 'leader_ack')
+        return false;
+    return true;
+}
+export async function waitForWorkerStartupEvidence(params) {
+    const timeoutMs = Math.max(0, Math.floor(params.timeoutMs ?? STARTUP_EVIDENCE_TIMEOUT_MS));
+    const pollMs = Math.max(25, Math.floor(params.pollMs ?? STARTUP_EVIDENCE_POLL_MS));
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const evidence = await readWorkerStartupEvidence(params.teamName, params.workerName, params.cwd);
+        if (doesStartupEvidenceSettle(params.workerCli, evidence))
+            return evidence;
+        if (Date.now() >= deadline)
+            return 'none';
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}
+export async function waitForClaudeStartupEvidence(params) {
+    return await waitForWorkerStartupEvidence({ ...params, workerCli: 'claude' });
+}
+function shouldSkipWorkerReadyWait(env) {
+    return env.RCS_TEAM_SKIP_READY_WAIT === '1';
+}
+function isRecoverableInteractiveStartupReason(reason) {
+    const normalized = reason.trim().toLowerCase();
+    return normalized.includes('startup_no_evidence')
+        || normalized.includes('fallback_attempted_but_unconfirmed')
+        || normalized.includes('ready_prompt_timeout');
+}
+async function recordRecoverableStartupIssue(params) {
+    const { teamName, workerName, taskIds, reason, cwd } = params;
+    const updatedAt = new Date().toISOString();
+    await writeWorkerStatus(teamName, workerName, {
+        state: 'unknown',
+        current_task_id: taskIds[0],
+        reason,
+        updated_at: updatedAt,
+    }, cwd).catch(() => { });
+    await appendTeamEvent(teamName, {
+        type: 'worker_state_changed',
+        worker: workerName,
+        state: 'unknown',
+        prev_state: 'unknown',
+        task_id: taskIds[0],
+        reason,
+    }, cwd).catch(() => { });
+}
+async function recordPromptStartupWorkerStopped(params) {
+    const { teamName, workerName, taskIds, reason, cwd } = params;
+    const updatedAt = new Date().toISOString();
+    await writeWorkerStatus(teamName, workerName, {
+        state: 'failed',
+        current_task_id: taskIds[0],
+        reason,
+        updated_at: updatedAt,
+    }, cwd).catch(() => { });
+    await appendTeamEvent(teamName, {
+        type: 'worker_stopped',
+        worker: workerName,
+        task_id: taskIds[0],
+        reason,
+    }, cwd).catch(() => { });
+}
+function setTeamModelInstructionsFile(teamName, filePath) {
+    if (!previousModelInstructionsFileByTeam.has(teamName)) {
+        previousModelInstructionsFileByTeam.set(teamName, process.env[MODEL_INSTRUCTIONS_FILE_ENV]);
+    }
+    process.env[MODEL_INSTRUCTIONS_FILE_ENV] = filePath;
+}
+function restoreTeamModelInstructionsFile(teamName) {
+    if (!previousModelInstructionsFileByTeam.has(teamName))
+        return;
+    const previous = previousModelInstructionsFileByTeam.get(teamName);
+    previousModelInstructionsFileByTeam.delete(teamName);
+    if (typeof previous === 'string') {
+        process.env[MODEL_INSTRUCTIONS_FILE_ENV] = previous;
+        return;
+    }
+    delete process.env[MODEL_INSTRUCTIONS_FILE_ENV];
+}
+function registerPromptWorkerHandle(teamName, workerName, child) {
+    const { pid } = child;
+    if (!Number.isFinite(pid) || (pid ?? 0) < 1) {
+        throw new Error(`failed to spawn prompt worker process for ${workerName}`);
+    }
+    const processPid = pid;
+    const existingTeamHandles = promptWorkerRegistry.get(teamName) ?? new Map();
+    existingTeamHandles.set(workerName, {
+        child,
+        pid: processPid,
+        processGroupId: process.platform !== 'win32' ? processPid : null,
+    });
+    promptWorkerRegistry.set(teamName, existingTeamHandles);
+    child.on('exit', () => {
+        const teamHandles = promptWorkerRegistry.get(teamName);
+        if (!teamHandles)
+            return;
+        const handle = teamHandles.get(workerName);
+        if (handle?.processGroupId && isProcessGroupAlive(handle.processGroupId)) {
+            return;
+        }
+        teamHandles.delete(workerName);
+        if (teamHandles.size === 0)
+            promptWorkerRegistry.delete(teamName);
+    });
+}
+function getPromptWorkerHandle(teamName, workerName) {
+    return promptWorkerRegistry.get(teamName)?.get(workerName) ?? null;
+}
+function removePromptWorkerHandle(teamName, workerName) {
+    const teamHandles = promptWorkerRegistry.get(teamName);
+    if (!teamHandles)
+        return;
+    teamHandles.delete(workerName);
+    if (teamHandles.size === 0)
+        promptWorkerRegistry.delete(teamName);
+}
+function isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ESRCH')
+            return false;
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        return false;
+    }
+}
+function isProcessGroupAlive(processGroupId) {
+    if (process.platform === 'win32')
+        return false;
+    if (!Number.isFinite(processGroupId) || processGroupId <= 0)
+        return false;
+    try {
+        process.kill(-processGroupId, 0);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ESRCH')
+            return false;
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        return false;
+    }
+}
+function listProcessTreeEntries() {
+    if (process.platform === 'win32')
+        return [];
+    const result = spawnSync('ps', ['axww', '-o', 'pid=,ppid='], {
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    if (result.status !== 0 || typeof result.stdout !== 'string')
+        return [];
+    return result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const match = line.match(/^(\d+)\s+(\d+)$/);
+        if (!match)
+            return null;
+        const pid = Number.parseInt(match[1], 10);
+        const ppid = Number.parseInt(match[2], 10);
+        if (!Number.isFinite(pid) || pid <= 0)
+            return null;
+        if (!Number.isFinite(ppid) || ppid < 0)
+            return null;
+        return { pid, ppid };
+    })
+        .filter((entry) => entry !== null);
+}
+function collectProcessTreePids(rootPid) {
+    if (!Number.isFinite(rootPid) || rootPid <= 0)
+        return [];
+    const childrenByPid = new Map();
+    for (const entry of listProcessTreeEntries()) {
+        const siblings = childrenByPid.get(entry.ppid) ?? [];
+        siblings.push(entry.pid);
+        childrenByPid.set(entry.ppid, siblings);
+    }
+    const ordered = [];
+    const stack = [rootPid];
+    const seen = new Set();
+    while (stack.length > 0) {
+        const pid = stack.pop();
+        if (seen.has(pid))
+            continue;
+        seen.add(pid);
+        ordered.push(pid);
+        for (const childPid of childrenByPid.get(pid) ?? []) {
+            if (!seen.has(childPid))
+                stack.push(childPid);
+        }
+    }
+    return ordered.reverse();
+}
+async function waitForTrackedPidsExit(pids, timeoutMs) {
+    const tracked = [...new Set(pids.filter((pid) => Number.isFinite(pid) && pid > 0))];
+    if (tracked.length === 0)
+        return true;
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    while (Date.now() < deadline) {
+        if (tracked.every((pid) => !isPidAlive(pid)))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, PROMPT_WORKER_EXIT_POLL_MS));
+    }
+    return tracked.every((pid) => !isPidAlive(pid));
+}
+async function terminateTrackedProcessTree(rootPid, processGroupId = null, graceMs = PROMPT_WORKER_SIGTERM_WAIT_MS, killWaitMs = PROMPT_WORKER_SIGKILL_WAIT_MS) {
+    if (processGroupId && process.platform !== 'win32') {
+        const trackedPids = collectProcessTreePids(rootPid);
+        try {
+            process.kill(-processGroupId, 'SIGTERM');
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
+        }
+        for (const pid of trackedPids) {
+            if (pid === rootPid)
+                continue;
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch (err) {
+                if (err.code !== 'ESRCH') {
+                    process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+                }
+            }
+        }
+        const groupDeadline = Date.now() + Math.max(0, graceMs);
+        while (Date.now() < groupDeadline) {
+            const groupAlive = isProcessGroupAlive(processGroupId);
+            const descendantsAlive = trackedPids.some((pid) => isPidAlive(pid));
+            if (!groupAlive && !descendantsAlive) {
+                return { terminated: true, forcedKill: false, trackedPids };
+            }
+            await new Promise((resolve) => setTimeout(resolve, PROMPT_WORKER_EXIT_POLL_MS));
+        }
+        try {
+            process.kill(-processGroupId, 'SIGKILL');
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
+        }
+        for (const pid of trackedPids) {
+            if (!isPidAlive(pid))
+                continue;
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch (err) {
+                if (err.code !== 'ESRCH') {
+                    process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+                }
+            }
+        }
+        const killDeadline = Date.now() + Math.max(0, killWaitMs);
+        while (Date.now() < killDeadline) {
+            const groupAlive = isProcessGroupAlive(processGroupId);
+            const descendantsAlive = trackedPids.some((pid) => isPidAlive(pid));
+            if (!groupAlive && !descendantsAlive) {
+                return { terminated: true, forcedKill: true, trackedPids };
+            }
+            await new Promise((resolve) => setTimeout(resolve, PROMPT_WORKER_EXIT_POLL_MS));
+        }
+        return {
+            terminated: !isProcessGroupAlive(processGroupId) && trackedPids.every((pid) => !isPidAlive(pid)),
+            forcedKill: true,
+            trackedPids,
+        };
+    }
+    const trackedPids = collectProcessTreePids(rootPid);
+    if (trackedPids.length === 0) {
+        return {
+            terminated: !isPidAlive(rootPid),
+            forcedKill: false,
+            trackedPids: [],
+        };
+    }
+    for (const pid of trackedPids) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
+        }
+    }
+    if (await waitForTrackedPidsExit(trackedPids, graceMs)) {
+        return { terminated: true, forcedKill: false, trackedPids };
+    }
+    for (const pid of trackedPids) {
+        if (!isPidAlive(pid))
+            continue;
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
+        }
+    }
+    return {
+        terminated: await waitForTrackedPidsExit(trackedPids, killWaitMs),
+        forcedKill: true,
+        trackedPids,
+    };
+}
+async function teardownPromptWorker(teamName, workerName, fallbackPid, cwd, context) {
+    const handle = getPromptWorkerHandle(teamName, workerName);
+    const handlePid = handle?.pid;
+    const processGroupId = handle?.processGroupId ?? null;
+    const pid = (typeof handlePid === 'number' && Number.isFinite(handlePid))
+        ? handlePid
+        : (Number.isFinite(fallbackPid) && (fallbackPid ?? 0) > 0 ? fallbackPid : null);
+    if (pid === null && processGroupId === null) {
+        removePromptWorkerHandle(teamName, workerName);
+        return { terminated: true, forcedKill: false, pid: null };
+    }
+    const teardown = await terminateTrackedProcessTree(pid ?? 0, processGroupId);
+    const processGone = processGroupId ? !isProcessGroupAlive(processGroupId) : !isPidAlive(pid);
+    if (teardown.terminated && processGone) {
+        removePromptWorkerHandle(teamName, workerName);
+        return { terminated: true, forcedKill: teardown.forcedKill, pid };
+    }
+    await appendTeamEvent(teamName, {
+        type: 'worker_stopped',
+        worker: workerName,
+        reason: `prompt_force_kill:${context}:pid=${pid}`,
+    }, cwd).catch(() => { });
+    if (!teardown.terminated) {
+        await appendTeamEvent(teamName, {
+            type: 'worker_stopped',
+            worker: workerName,
+            reason: `prompt_teardown_failed:${context}:pid=${pid}`,
+        }, cwd).catch(() => { });
+        return {
+            terminated: false,
+            forcedKill: teardown.forcedKill,
+            pid,
+            error: 'still_alive_after_sigkill',
+        };
+    }
+    removePromptWorkerHandle(teamName, workerName);
+    return { terminated: true, forcedKill: teardown.forcedKill, pid };
+}
+function isPromptWorkerAlive(config, worker) {
+    const handle = getPromptWorkerHandle(config.name, worker.name);
+    if (handle?.child.exitCode === null && !handle.child.killed)
+        return true;
+    if (handle?.processGroupId && isProcessGroupAlive(handle.processGroupId))
+        return true;
+    if (process.platform !== 'win32' && isProcessGroupAlive(worker.pid))
+        return true;
+    return isPidAlive(worker.pid);
+}
+export { TEAM_LOW_COMPLEXITY_DEFAULT_MODEL };
+export { resolveCanonicalTeamStateRoot };
+function spawnPromptWorker(teamName, workerName, workerIndex, workerCwd, launchArgs, workerEnv, workerCli, initialPrompt, workerRole) {
+    const processSpec = buildWorkerProcessLaunchSpec(teamName, workerIndex, launchArgs, workerCwd, workerEnv, workerCli, initialPrompt, workerRole);
+    const child = spawn(processSpec.command, processSpec.args, {
+        cwd: workerCwd,
+        detached: process.platform !== 'win32',
+        env: { ...process.env, ...processSpec.env },
+        stdio: ['pipe', 'ignore', 'ignore'],
+    });
+    registerPromptWorkerHandle(teamName, workerName, child);
+    return child;
+}
+export function resolveWorkerLaunchArgsFromEnv(env, agentType, inheritedLeaderModel, preferredReasoning, workerCliOverride) {
+    const inheritedArgs = (typeof inheritedLeaderModel === 'string' && inheritedLeaderModel.trim() !== '')
+        ? ['--model', inheritedLeaderModel.trim()]
+        : [];
+    const fallbackModel = resolveAgentDefaultModel(agentType, env.CODEX_HOME);
+    // Detect if an explicit reasoning override exists before resolving (for log source labelling)
+    const preEnvArgs = splitWorkerLaunchArgs(env.RCS_TEAM_WORKER_LAUNCH_ARGS);
+    const preAllArgs = [...preEnvArgs, ...inheritedArgs];
+    const hasExplicitReasoning = parseTeamWorkerLaunchArgs(preAllArgs).reasoningOverride !== null;
+    const resolved = resolveTeamWorkerLaunchArgs({
+        existingRaw: env.RCS_TEAM_WORKER_LAUNCH_ARGS,
+        inheritedArgs,
+        fallbackModel,
+        preferredReasoning,
+    });
+    // Extract resolved model and thinking level from result args for startup log
+    const resolvedParsed = parseTeamWorkerLaunchArgs(resolved);
+    const resolvedModel = resolvedParsed.modelOverride ?? fallbackModel ?? 'default';
+    const reasoningMatch = resolvedParsed.reasoningOverride?.match(/model_reasoning_effort\s*=\s*"?(\w+)"?/);
+    const thinkingLevel = reasoningMatch?.[1] ?? 'none';
+    const source = hasExplicitReasoning
+        ? 'explicit'
+        : (preferredReasoning ? 'role-default' : 'none/default-none');
+    const effectiveWorkerCli = workerCliOverride ?? resolveEffectiveWorkerCliForStartupLog(resolved, env);
+    if (effectiveWorkerCli === 'claude') {
+        console.log('[rcs:team] worker startup resolution: model=claude source=local-settings');
+    }
+    else if (effectiveWorkerCli === 'gemini') {
+        console.log('[rcs:team] worker startup resolution: model=gemini source=local-settings');
+    }
+    else {
+        console.log(`[rcs:team] worker startup resolution: model=${resolvedModel} thinking_level=${thinkingLevel} source=${source}`);
+    }
+    return resolved;
+}
+function resolveEffectiveWorkerCliForStartupLog(resolvedLaunchArgs, env) {
+    const rawCliMap = String(env.RCS_TEAM_WORKER_CLI_MAP ?? '').trim();
+    if (rawCliMap !== '') {
+        const entries = rawCliMap
+            .split(',')
+            .map((entry) => entry.trim().toLowerCase())
+            .filter((entry) => entry.length > 0);
+        if (entries.length > 0) {
+            const autoCli = resolveTeamWorkerCli(resolvedLaunchArgs, {
+                ...env,
+                RCS_TEAM_WORKER_CLI: 'auto',
+            });
+            const resolvedMap = entries.map((entry) => {
+                if (entry === 'auto')
+                    return autoCli;
+                if (entry === 'codex' || entry === 'claude' || entry === 'gemini')
+                    return entry;
+                return null;
+            });
+            if (resolvedMap.every((entry) => entry === 'claude'))
+                return 'claude';
+            if (resolvedMap.every((entry) => entry === 'gemini'))
+                return 'gemini';
+            if (resolvedMap.some((entry) => entry === 'codex'))
+                return 'codex';
+        }
+    }
+    return resolveTeamWorkerCli(resolvedLaunchArgs, env);
+}
+async function writeDecompositionArtifacts(teamName, cwd, metadata) {
+    const root = join(resolveCanonicalTeamStateRoot(cwd), 'team', teamName);
+    await mkdir(root, { recursive: true });
+    await writeFile(join(root, 'decomposition-report.json'), JSON.stringify(metadata, null, 2), 'utf8');
+    const manifest = await readTeamManifestV2(teamName, cwd);
+    if (manifest) {
+        await writeFile(join(root, 'manifest.v2.json'), JSON.stringify({ ...manifest, team_decomposition: metadata }, null, 2), 'utf8');
+    }
+}
+export async function settleStartupAttemptResults(attempts) {
+    const settled = await Promise.allSettled(attempts.map((attempt) => attempt.attempt));
+    return settled.map((result, index) => {
+        if (result.status === 'fulfilled')
+            return result.value;
+        const descriptor = attempts[index];
+        const workerIndex = descriptor?.workerIndex ?? index + 1;
+        const workerName = descriptor?.workerName ?? `worker-${workerIndex}`;
+        const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        return { ok: false, workerIndex, workerName, error };
+    });
+}
+export async function startTeam(teamName, task, agentType, workerCount, tasks, cwd, options = {}) {
+    const leaderCwd = resolve(cwd);
+    await assertNestedTeamAllowed(leaderCwd);
+    const effectiveWorktreeMode = resolveEffectiveTeamWorktreeMode(leaderCwd, options.worktreeMode);
+    const displayName = sanitizeTeamName(teamName);
+    const workerLaunchMode = resolveTeamWorkerLaunchMode(process.env);
+    const displayMode = workerLaunchMode === 'interactive' ? 'split_pane' : 'auto';
+    const rawIdentityScope = resolveTeamIdentityScope(process.env);
+    const resolvedLeaderSessionId = await resolveLeaderSessionId(leaderCwd);
+    const identityScope = rawIdentityScope.source === 'run-id'
+        ? (resolvedLeaderSessionId
+            ? { ...rawIdentityScope, sessionId: resolvedLeaderSessionId, runId: '' }
+            : {
+                ...rawIdentityScope,
+                // Prompt-mode starts can run outside tmux/native session metadata. A fresh
+                // random run id would give every start a new leader identity and bypass
+                // one-active-team protection, so scope that fallback to the leader cwd.
+                runId: `cwd:${leaderCwd}`,
+            })
+        : rawIdentityScope;
+    const sanitized = buildInternalTeamName(displayName, identityScope);
+    const leaderSessionId = identityScope.sessionId || identityScope.paneId || identityScope.tmuxTarget || identityScope.runId;
+    await assertTeamStartupIsNonDestructive(sanitized, leaderCwd, leaderSessionId);
+    if (displayName !== sanitized) {
+        await assertTeamStartupIsNonDestructive(displayName, leaderCwd, leaderSessionId);
+    }
+    if (workerLaunchMode === 'interactive') {
+        if (!isTmuxAvailable()) {
+            throw new Error('Team mode requires tmux. Install with: apt install tmux / brew install tmux');
+        }
+        if (!hasCurrentTmuxClientContext()) {
+            throw new Error('Team mode requires running inside tmux current leader pane');
+        }
+    }
+    const teamStateRoot = resolveCanonicalTeamStateRoot(leaderCwd);
+    const activeWorktreeMode = effectiveWorktreeMode.enabled
+        ? (effectiveWorktreeMode.detached ? 'detached' : 'named')
+        : null;
+    const workspaceMode = activeWorktreeMode ? 'worktree' : 'single';
+    const workerWorkspaceByName = new Map();
+    const provisionedWorktrees = [];
+    for (let i = 1; i <= workerCount; i++) {
+        workerWorkspaceByName.set(`worker-${i}`, { cwd: leaderCwd });
+    }
+    await detectAndCleanStaleTeam(sanitized, leaderCwd, workerCount, options.confirmStaleCleanup);
+    if (activeWorktreeMode) {
+        assertCleanLeaderWorkspaceForWorkerWorktrees(leaderCwd);
+        for (let i = 1; i <= workerCount; i++) {
+            const workerName = `worker-${i}`;
+            const planned = planWorktreeTarget({
+                cwd: leaderCwd,
+                scope: 'team',
+                mode: effectiveWorktreeMode,
+                teamName: sanitized,
+                workerName,
+            });
+            const ensured = ensureWorktree(planned);
+            provisionedWorktrees.push(ensured);
+            if (ensured.enabled) {
+                workerWorkspaceByName.set(workerName, {
+                    cwd: ensured.worktreePath,
+                    worktreeRepoRoot: ensured.repoRoot,
+                    worktreePath: ensured.worktreePath,
+                    worktreeBranch: ensured.branchName ?? undefined,
+                    worktreeDetached: ensured.detached,
+                    worktreeCreated: ensured.created,
+                });
+            }
+        }
+    }
+    // 2. Team name is already sanitized above.
+    let sessionName = `rcs-team-${sanitized}`;
+    const overlay = generateWorkerOverlay(sanitized);
+    let workerInstructionsPath = null;
+    let sessionCreated = false;
+    const createdWorkerPaneIds = [];
+    let createdLeaderPaneId;
+    let config = null;
+    const sharedWorkerLaunchArgs = resolveTeamWorkerLaunchArgs({
+        existingRaw: process.env.RCS_TEAM_WORKER_LAUNCH_ARGS,
+        fallbackModel: resolveAgentDefaultModel(agentType, process.env.CODEX_HOME),
+    });
+    const workerCliPlan = resolveTeamWorkerCliPlan(workerCount, sharedWorkerLaunchArgs, process.env);
+    if (workerLaunchMode === 'prompt') {
+        assertPromptModeWorkerCliSupported(workerCliPlan);
+    }
+    const workerReadyTimeoutMs = resolveWorkerReadyTimeoutMs(process.env);
+    const workerStartupEvidenceTimeoutMs = resolveWorkerStartupEvidenceTimeoutMs(process.env, workerReadyTimeoutMs);
+    const startupDispatchRetries = resolveStartupDispatchRetries(process.env);
+    const startupRetryDelayS = resolveStartupDispatchRetryDelayS(process.env);
+    const skipWorkerReadyWait = shouldSkipWorkerReadyWait(process.env);
+    try {
+        // 3. Init state directory + config
+        config = await initTeamState(sanitized, task, agentType, workerCount, leaderCwd, DEFAULT_MAX_WORKERS, {
+            ...process.env,
+            RCS_SESSION_ID: leaderSessionId,
+            RCS_TEAM_DISPLAY_MODE: displayMode,
+            RCS_TEAM_WORKER_LAUNCH_MODE: workerLaunchMode,
+        }, {
+            leader_cwd: leaderCwd,
+            team_state_root: teamStateRoot,
+            workspace_mode: workspaceMode,
+            display_name: displayName,
+            requested_name: displayName,
+            identity_source: identityScope.source,
+            worktree_mode: effectiveWorktreeMode,
+        }, 'default');
+        if (!config) {
+            throw new Error('failed to initialize team config');
+        }
+        config.leader_cwd = leaderCwd;
+        config.team_state_root = teamStateRoot;
+        config.workspace_mode = workspaceMode;
+        config.display_name = displayName;
+        config.requested_name = displayName;
+        config.identity_source = identityScope.source;
+        config.worktree_mode = effectiveWorktreeMode;
+        // 4. Create tasks. Repo-aware DAG dependencies are symbolic until the
+        // state layer returns concrete task IDs, so create those tasks dependency
+        // free and patch runtime dependency fields after ID assignment.
+        const createdTasks = [];
+        for (const t of tasks) {
+            const hasSymbolicDagIdentity = Boolean(t.symbolic_id);
+            const created = await createStateTask(sanitized, {
+                subject: t.subject,
+                description: t.description,
+                status: 'pending',
+                owner: t.owner,
+                blocked_by: hasSymbolicDagIdentity ? undefined : t.blocked_by ?? t.depends_on,
+                depends_on: hasSymbolicDagIdentity ? undefined : t.depends_on ?? t.blocked_by,
+                role: t.role,
+                delegation: t.delegation ?? synthesizeDelegationPlan(t),
+                requires_code_change: t.requires_code_change,
+                filePaths: t.filePaths,
+                domains: t.domains,
+                lane: t.lane,
+                allocation_reason: t.allocation_reason,
+            }, leaderCwd);
+            createdTasks.push(created);
+        }
+        const effectiveDecompositionMetadata = options.decompositionMetadata
+            ? remapRepoAwareDecompositionMetadataToCreatedTasks(options.decompositionMetadata, tasks, createdTasks)
+            : undefined;
+        const nodeIdToTaskId = effectiveDecompositionMetadata?.node_id_to_task_id ?? {};
+        for (let index = 0; index < tasks.length; index += 1) {
+            const planned = tasks[index];
+            if (!planned?.symbolic_id)
+                continue;
+            const created = createdTasks[index];
+            if (!created)
+                continue;
+            const symbolicDeps = planned.symbolic_depends_on
+                ?? effectiveDecompositionMetadata?.node_dependencies?.[planned.symbolic_id]
+                ?? [];
+            const concreteDeps = symbolicDeps.map((dep) => nodeIdToTaskId[dep]).filter(Boolean);
+            if (concreteDeps.length === 0)
+                continue;
+            await updateTask(sanitized, created.id, {
+                blocked_by: concreteDeps,
+                depends_on: concreteDeps,
+            }, leaderCwd);
+        }
+        // 5. Write team-scoped worker instructions file only for single-workspace mode.
+        if (workspaceMode !== 'worktree') {
+            workerInstructionsPath = await writeTeamWorkerInstructionsFile(sanitized, leaderCwd, overlay);
+            setTeamModelInstructionsFile(sanitized, workerInstructionsPath);
+        }
+        const allTasks = await listTasks(sanitized, leaderCwd);
+        if (effectiveDecompositionMetadata) {
+            await writeDecompositionArtifacts(sanitized, leaderCwd, effectiveDecompositionMetadata);
+        }
+        const workerBootstrapPlans = [];
+        for (let i = 1; i <= workerCount; i++) {
+            const workerName = `worker-${i}`;
+            const workerWorkspace = workerWorkspaceByName.get(workerName) ?? { cwd: leaderCwd };
+            const workerTasks = allTasks.filter(t => t.owner === workerName);
+            const taskRoles = workerTasks.map(t => t.role).filter(Boolean);
+            const uniqueTaskRoles = new Set(taskRoles);
+            const workerRole = taskRoles.length > 0 && uniqueTaskRoles.size === 1
+                ? taskRoles[0]
+                : agentType;
+            const runtimeRole = workerRole;
+            const rawRolePromptContent = await loadRolePrompt(runtimeRole, join(leaderCwd, '.codex', 'prompts'))
+                ?? await loadRolePrompt(runtimeRole, codexPromptsDir());
+            const preferredReasoning = resolveAgentReasoningEffort(runtimeRole) ?? resolveAgentReasoningEffort(agentType);
+            const workerLaunchArgs = resolveWorkerLaunchArgsFromEnv(process.env, runtimeRole, undefined, preferredReasoning, workerCliPlan[i - 1]);
+            const resolvedWorkerModel = parseTeamWorkerLaunchArgs(workerLaunchArgs).modelOverride ?? undefined;
+            const rolePromptContent = rawRolePromptContent
+                ? composeRoleInstructionsForRole(runtimeRole, rawRolePromptContent, resolvedWorkerModel)
+                : null;
+            const workerWorktreePath = workerWorkspace.worktreePath ?? undefined;
+            const fallbackInstructionsPath = workerInstructionsPath ?? join(leaderCwd, 'AGENTS.md');
+            const instructionsFilePath = workerWorktreePath
+                ? await writeWorkerWorktreeRootAgentsFile({
+                    teamName: sanitized,
+                    workerName,
+                    workerRole: runtimeRole,
+                    rolePromptContent: rolePromptContent ?? "",
+                    teamStateRoot,
+                    leaderCwd,
+                    worktreePath: workerWorktreePath,
+                })
+                : rolePromptContent
+                    ? await writeWorkerRoleInstructionsFile(sanitized, workerName, leaderCwd, fallbackInstructionsPath, runtimeRole, rolePromptContent)
+                    : fallbackInstructionsPath;
+            const inbox = generateInitialInbox(workerName, sanitized, agentType, workerTasks, {
+                teamStateRoot,
+                leaderCwd,
+                workerRole: runtimeRole,
+                rolePromptContent: rawRolePromptContent ?? undefined,
+                worktreeRootAgentsCanonical: Boolean(workerWorkspace.worktreePath),
+                taskHints: effectiveDecompositionMetadata?.task_hints,
+                approvedContextSummary: effectiveDecompositionMetadata?.approved_context_summary,
+            });
+            const triggerDirective = buildTriggerDirective(workerName, sanitized, resolveInstructionStateRoot(workerWorkspace.worktreePath));
+            const trigger = triggerDirective.text;
+            const initialPrompt = workerCliPlan[i - 1] === 'gemini' ? trigger : undefined;
+            if (initialPrompt) {
+                await writeWorkerInbox(sanitized, workerName, inbox, leaderCwd);
+            }
+            workerBootstrapPlans.push({
+                workerName,
+                workerWorkspace,
+                workerTasks,
+                workerRole,
+                rolePromptContent,
+                instructionsFilePath,
+                inbox,
+                trigger,
+                triggerIntent: triggerDirective.intent,
+                initialPrompt,
+                workerLaunchArgs,
+                workerCli: workerCliPlan[i - 1],
+            });
+        }
+        const workerStartups = workerBootstrapPlans.map((plan) => {
+            const env = {
+                [TEAM_STATE_ROOT_ENV]: teamStateRoot,
+                [TEAM_LEADER_CWD_ENV]: leaderCwd,
+                [MODEL_INSTRUCTIONS_FILE_ENV]: plan.instructionsFilePath,
+                RCS_TEAM_DISPLAY_NAME: displayName,
+            };
+            if (plan.workerWorkspace.worktreePath) {
+                env.RCS_TEAM_WORKTREE_PATH = plan.workerWorkspace.worktreePath;
+            }
+            if (plan.workerWorkspace.worktreeBranch) {
+                env.RCS_TEAM_WORKTREE_BRANCH = plan.workerWorkspace.worktreeBranch;
+            }
+            if (typeof plan.workerWorkspace.worktreeDetached === 'boolean') {
+                env.RCS_TEAM_WORKTREE_DETACHED = plan.workerWorkspace.worktreeDetached ? '1' : '0';
+            }
+            return {
+                cwd: plan.workerWorkspace.cwd,
+                env,
+                initialPrompt: plan.initialPrompt,
+                launchArgs: plan.workerLaunchArgs,
+                workerCli: plan.workerCli,
+                workerRole: plan.workerRole,
+            };
+        });
+        const workerPaneIds = Array.from({ length: workerCount }, () => undefined);
+        const materializeWorkerStartupState = async (bootstrapPlan, workerIndex, paneId) => {
+            const workerWorkspace = bootstrapPlan.workerWorkspace;
+            const identity = {
+                name: bootstrapPlan.workerName,
+                index: workerIndex,
+                role: bootstrapPlan.workerRole,
+                worker_cli: bootstrapPlan.workerCli,
+                assigned_tasks: bootstrapPlan.workerTasks.map((task) => task.id),
+                working_dir: workerWorkspace.cwd,
+                worktree_repo_root: workerWorkspace.worktreeRepoRoot,
+                worktree_path: workerWorkspace.worktreePath,
+                worktree_branch: workerWorkspace.worktreeBranch,
+                worktree_detached: workerWorkspace.worktreeDetached,
+                worktree_created: workerWorkspace.worktreeCreated,
+                team_state_root: teamStateRoot,
+            };
+            if (workerLaunchMode === 'interactive') {
+                const panePid = getWorkerPanePid(sessionName, workerIndex, paneId);
+                if (panePid)
+                    identity.pid = panePid;
+            }
+            else if (config?.workers[workerIndex - 1]?.pid) {
+                identity.pid = config.workers[workerIndex - 1].pid;
+            }
+            if (paneId)
+                identity.pane_id = paneId;
+            if (config?.workers[workerIndex - 1]) {
+                config.workers[workerIndex - 1].pid = identity.pid;
+                config.workers[workerIndex - 1].pane_id = paneId;
+                config.workers[workerIndex - 1].role = bootstrapPlan.workerRole;
+                config.workers[workerIndex - 1].worker_cli = bootstrapPlan.workerCli;
+                config.workers[workerIndex - 1].assigned_tasks = bootstrapPlan.workerTasks.map((task) => task.id);
+                config.workers[workerIndex - 1].working_dir = workerWorkspace.cwd;
+                config.workers[workerIndex - 1].worktree_repo_root = workerWorkspace.worktreeRepoRoot;
+                config.workers[workerIndex - 1].worktree_path = workerWorkspace.worktreePath;
+                config.workers[workerIndex - 1].worktree_branch = workerWorkspace.worktreeBranch;
+                config.workers[workerIndex - 1].worktree_detached = workerWorkspace.worktreeDetached;
+                config.workers[workerIndex - 1].worktree_created = workerWorkspace.worktreeCreated;
+                config.workers[workerIndex - 1].team_state_root = teamStateRoot;
+            }
+            await writeWorkerIdentity(sanitized, bootstrapPlan.workerName, identity, leaderCwd);
+            await writeWorkerInbox(sanitized, bootstrapPlan.workerName, bootstrapPlan.inbox, leaderCwd);
+        };
+        // 6. Create worker runtime (interactive tmux panes or prompt-mode child processes)
+        await cleanupTeamWorkerLaunchOrphanedMcpProcesses({
+            cleanup: options.cleanupLaunchOrphanedMcpProcesses,
+            writeWarning: options.writeCleanupWarning,
+        });
+        const startupTiming = createStartupTimingRecorder(sanitized, leaderCwd);
+        if (workerLaunchMode === 'interactive') {
+            const createdSession = createTeamSession(sanitized, workerCount, leaderCwd, sharedWorkerLaunchArgs, workerStartups);
+            sessionName = createdSession.name;
+            sessionCreated = true;
+            createdWorkerPaneIds.push(...createdSession.workerPaneIds);
+            createdLeaderPaneId = createdSession.leaderPaneId;
+            applyCreatedInteractiveSessionToConfig(config, createdSession, workerPaneIds);
+            for (const [index, paneId] of createdSession.workerPaneIds.entries()) {
+                startupTiming.mark('split_returned', { worker: `worker-${index + 1}`, pane_id: paneId });
+            }
+        }
+        else {
+            config.tmux_session = `prompt-${sanitized}`;
+            config.leader_pane_id = null;
+            config.hud_pane_id = null;
+            config.resize_hook_name = null;
+            config.resize_hook_target = null;
+            for (let i = 1; i <= workerCount; i++) {
+                const startup = workerStartups[i - 1] || {};
+                const workerName = `worker-${i}`;
+                const child = spawnPromptWorker(sanitized, workerName, i, startup.cwd || leaderCwd, startup.launchArgs || sharedWorkerLaunchArgs, startup.env || {}, startup.workerCli || workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole);
+                if (config.workers[i - 1]) {
+                    config.workers[i - 1].pid = child.pid;
+                }
+            }
+        }
+        // Materialize durable startup state for every worker before any per-worker
+        // readiness wait or startup-evidence gate can block later workers.
+        for (let i = 1; i <= workerCount; i++) {
+            const bootstrapPlan = workerBootstrapPlans[i - 1];
+            if (!bootstrapPlan) {
+                throw new Error(`missing bootstrap plan for worker-${i}`);
+            }
+            await materializeWorkerStartupState(bootstrapPlan, i, workerPaneIds[i - 1]);
+            startupTiming.mark('identity_inbox_written', { worker: bootstrapPlan.workerName, pane_id: workerPaneIds[i - 1] });
+        }
+        await saveTeamConfig(config, leaderCwd);
+        // 7. Start all safe per-worker readiness/dispatch attempts concurrently.
+        // Pane creation and worktree provisioning above remain dependency-bound and
+        // ordered; readiness polling and startup dispatch must not let worker-1
+        // block later workers from receiving their own startup attempts.
+        const manifest = await readTeamManifestV2(sanitized, leaderCwd);
+        const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, workerLaunchMode);
+        const runWorkerStartupAttempt = async (workerIndex) => {
+            const bootstrapPlan = workerBootstrapPlans[workerIndex - 1];
+            if (!bootstrapPlan) {
+                return {
+                    ok: false,
+                    workerIndex,
+                    workerName: `worker-${workerIndex}`,
+                    error: new Error(`missing bootstrap plan for worker-${workerIndex}`),
+                };
+            }
+            const workerName = bootstrapPlan.workerName;
+            const paneId = workerPaneIds[workerIndex - 1];
+            const workerTasks = bootstrapPlan.workerTasks;
+            const inbox = bootstrapPlan.inbox;
+            const trigger = bootstrapPlan.trigger;
+            const triggerIntent = bootstrapPlan.triggerIntent;
+            const initialPrompt = bootstrapPlan.initialPrompt;
+            const startupStartedAt = performance.now();
+            const taskRoles = workerTasks
+                .map((task) => task.role)
+                .filter((role) => Boolean(role));
+            const uniqueTaskRoles = [...new Set(taskRoles)];
+            if (uniqueTaskRoles.length > 1) {
+                console.log(`[rcs:team] ${workerName}: mixed task roles [${uniqueTaskRoles.join(', ')}], falling back to ${agentType}`);
+            }
+            const startupDirectOutcome = workerLaunchMode === 'interactive' && !initialPrompt
+                ? await attemptStartupDirectTrigger({
+                    teamName: sanitized,
+                    config: config,
+                    workerName,
+                    workerIndex,
+                    paneId,
+                    workerCli: workerCliPlan[workerIndex - 1],
+                    inbox,
+                    triggerMessage: trigger,
+                    intent: triggerIntent,
+                    taskIds: workerTasks.map((task) => task.id),
+                    cwd: leaderCwd,
+                    timing: startupTiming,
+                })
+                : null;
+            if (workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt && !startupDirectOutcome?.ok) {
+                startupTiming.mark('ready_wait_start', { worker: workerName, pane_id: paneId });
+                const ready = await waitForWorkerReadyAsync(sessionName, workerIndex, workerReadyTimeoutMs, paneId);
+                startupTiming.mark('ready_wait_end', { worker: workerName, pane_id: paneId, ok: ready });
+                if (!ready) {
+                    const workerAlive = isWorkerPaneOpen(sessionName, workerIndex, paneId);
+                    if (workerAlive) {
+                        await recordRecoverableStartupIssue({
+                            teamName: sanitized,
+                            workerName,
+                            taskIds: workerTasks.map((task) => task.id),
+                            reason: 'ready_prompt_timeout',
+                            cwd: leaderCwd,
+                        });
+                        return { ok: true, workerIndex, workerName };
+                    }
+                    return {
+                        ok: false,
+                        workerIndex,
+                        workerName,
+                        error: new Error(`Worker ${workerName} did not become ready in tmux session ${sessionName}`),
+                    };
+                }
+            }
+            const startupReadyPromptObserved = workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt;
+            let dispatchOutcome = initialPrompt
+                ? { ok: true, transport: 'none', reason: 'startup_prompt_delivered_at_launch' }
+                : (startupDirectOutcome ?? { ok: false, transport: 'none', reason: 'not_attempted' });
+            if (!initialPrompt && !startupDirectOutcome?.ok) {
+                for (let attempt = 1; attempt <= startupDispatchRetries; attempt++) {
+                    dispatchOutcome = await dispatchCriticalInboxInstruction({
+                        teamName: sanitized,
+                        config: config,
+                        workerName,
+                        workerIndex,
+                        paneId,
+                        workerCli: workerCliPlan[workerIndex - 1],
+                        inbox,
+                        triggerMessage: trigger,
+                        intent: triggerIntent,
+                        cwd: leaderCwd,
+                        dispatchPolicy,
+                        inboxCorrelationKey: `startup:${workerName}`,
+                        requireWorkerStartupEvidence: true,
+                        startupEvidenceTimeoutMs: workerStartupEvidenceTimeoutMs,
+                        startupReadyPromptObserved,
+                        startupTiming,
+                    });
+                    await logStartupTiming({
+                        cwd: leaderCwd,
+                        teamName: sanitized,
+                        workerName,
+                        event: dispatchOutcome.ok ? 'startup_evidence' : 'startup_attempt_failed',
+                        paneId,
+                        elapsedMs: performance.now() - startupStartedAt,
+                        reason: dispatchOutcome.reason,
+                        requestId: dispatchOutcome.request_id,
+                        transport: dispatchOutcome.transport,
+                    }).catch(() => { });
+                    if (dispatchOutcome.ok)
+                        break;
+                    if (attempt < startupDispatchRetries) {
+                        if (workerLaunchMode === 'interactive') {
+                            if (dismissTrustPromptIfPresent(sessionName, workerIndex, paneId)) {
+                                await waitForWorkerReadyAsync(sessionName, workerIndex, workerReadyTimeoutMs, paneId);
+                            }
+                            else {
+                                await new Promise((resolve) => setTimeout(resolve, Math.max(0, startupRetryDelayS * 1000)));
+                            }
+                        }
+                        else {
+                            await new Promise((resolve) => setTimeout(resolve, Math.max(0, startupRetryDelayS * 1000)));
+                        }
+                    }
+                }
+            }
+            if (!dispatchOutcome.ok) {
+                const workerAlive = workerLaunchMode === 'prompt'
+                    ? isPromptWorkerAlive(config, config.workers[workerIndex - 1])
+                    : isWorkerPaneOpen(sessionName, workerIndex, paneId);
+                if (workerLaunchMode === 'interactive'
+                    && workerAlive
+                    && isRecoverableInteractiveStartupReason(dispatchOutcome.reason)) {
+                    await recordRecoverableStartupIssue({
+                        teamName: sanitized,
+                        workerName,
+                        taskIds: workerTasks.map((task) => task.id),
+                        reason: dispatchOutcome.reason,
+                        cwd: leaderCwd,
+                    });
+                    return { ok: true, workerIndex, workerName };
+                }
+                if (workerLaunchMode === 'prompt' && !workerAlive) {
+                    await recordPromptStartupWorkerStopped({
+                        teamName: sanitized,
+                        workerName,
+                        taskIds: workerTasks.map((task) => task.id),
+                        reason: dispatchOutcome.reason,
+                        cwd: leaderCwd,
+                    });
+                    return { ok: true, workerIndex, workerName };
+                }
+                return {
+                    ok: false,
+                    workerIndex,
+                    workerName,
+                    error: new Error(`worker_notify_failed:${workerName}:${dispatchOutcome.reason}`),
+                };
+            }
+            return { ok: true, workerIndex, workerName };
+        };
+        const startupAttemptResults = await settleStartupAttemptResults(Array.from({ length: workerCount }, (_, index) => {
+            const workerIndex = index + 1;
+            const bootstrapPlan = workerBootstrapPlans[index];
+            const workerName = bootstrapPlan?.workerName ?? `worker-${workerIndex}`;
+            return {
+                workerIndex,
+                workerName,
+                attempt: runWorkerStartupAttempt(workerIndex),
+            };
+        }));
+        const firstStartupError = startupAttemptResults
+            .filter((result) => !result.ok)
+            .sort((a, b) => a.workerIndex - b.workerIndex)[0];
+        if (firstStartupError) {
+            throw firstStartupError.error;
+        }
+        await saveTeamConfig(config, leaderCwd);
+        await startupTiming.flush();
+        return {
+            teamName: sanitized,
+            sanitizedName: sanitized,
+            sessionName,
+            config,
+            cwd: leaderCwd,
+        };
+    }
+    catch (error) {
+        const rollbackErrors = [];
+        if (sessionCreated) {
+            if (config?.resize_hook_name && config.resize_hook_target) {
+                try {
+                    const unregistered = unregisterResizeHook(config.resize_hook_target, config.resize_hook_name);
+                    if (!unregistered) {
+                        rollbackErrors.push('unregisterResizeHook: returned false');
+                    }
+                }
+                catch (cleanupError) {
+                    rollbackErrors.push(`unregisterResizeHook: ${String(cleanupError)}`);
+                }
+            }
+            if (config) {
+                config.resize_hook_name = null;
+                config.resize_hook_target = null;
+                try {
+                    await saveTeamConfig(config, leaderCwd);
+                }
+                catch (cleanupError) {
+                    rollbackErrors.push(`saveTeamConfig(clear resize hook): ${String(cleanupError)}`);
+                }
+            }
+            // In split-pane topology, we must not kill the entire tmux session; kill only created panes.
+            if (sessionName.includes(':')) {
+                for (const [index, paneId] of createdWorkerPaneIds.entries()) {
+                    const panePid = getWorkerPanePid(sessionName, index + 1, paneId);
+                    if (panePid) {
+                        await terminateTrackedProcessTree(panePid);
+                    }
+                    try {
+                        await killWorkerByPaneIdAsync(paneId, createdLeaderPaneId);
+                    }
+                    catch (err) {
+                        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+                    }
+                }
+                if (config?.hud_pane_id) {
+                    try {
+                        await killWorkerByPaneIdAsync(config.hud_pane_id, createdLeaderPaneId);
+                    }
+                    catch (err) {
+                        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+                    }
+                }
+            }
+            else {
+                try {
+                    destroyTeamSession(sessionName);
+                }
+                catch (cleanupError) {
+                    rollbackErrors.push(`destroyTeamSession: ${String(cleanupError)}`);
+                }
+            }
+        }
+        if (workerLaunchMode === 'prompt' && config) {
+            const promptTeardownFailures = [];
+            for (const worker of config.workers) {
+                const teardown = await teardownPromptWorker(sanitized, worker.name, worker.pid, leaderCwd, 'startup_rollback');
+                if (!teardown.terminated) {
+                    promptTeardownFailures.push(`${worker.name}:${teardown.error || 'unknown_error'}`);
+                }
+            }
+            if (promptTeardownFailures.length > 0) {
+                rollbackErrors.push(`promptTeardown:${promptTeardownFailures.join(',')}`);
+            }
+        }
+        if (config) {
+            for (const worker of config.workers) {
+                if (!worker.worktree_path || !worker.team_state_root)
+                    continue;
+                try {
+                    await removeWorkerWorktreeRootAgentsFile(sanitized, worker.name, worker.team_state_root, worker.worktree_path);
+                }
+                catch (cleanupError) {
+                    rollbackErrors.push(`removeWorkerWorktreeRootAgentsFile(${worker.name}): ${String(cleanupError)}`);
+                }
+            }
+        }
+        if (workerInstructionsPath) {
+            try {
+                await removeTeamWorkerInstructionsFile(sanitized, leaderCwd);
+            }
+            catch (cleanupError) {
+                rollbackErrors.push(`removeTeamWorkerInstructionsFile: ${String(cleanupError)}`);
+            }
+        }
+        restoreTeamModelInstructionsFile(sanitized);
+        try {
+            await cleanupTeamState(sanitized, leaderCwd);
+        }
+        catch (cleanupError) {
+            rollbackErrors.push(`cleanupTeamState: ${String(cleanupError)}`);
+        }
+        if (provisionedWorktrees.length > 0) {
+            try {
+                await rollbackProvisionedWorktrees(provisionedWorktrees, {
+                    skipBranchDeletion: false,
+                });
+            }
+            catch (cleanupError) {
+                rollbackErrors.push(`rollbackProvisionedWorktrees: ${String(cleanupError)}`);
+            }
+        }
+        if (rollbackErrors.length > 0) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`${message}; rollback encountered errors: ${rollbackErrors.join(' | ')}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Monitor team state by polling files. Returns a snapshot.
+ */
+export async function monitorTeam(teamName, cwd) {
+    const monitorStartMs = performance.now();
+    const sanitized = resolveTeamNameForCurrentContext(teamName, cwd);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        return null;
+    const manifest = await readTeamManifestV2(sanitized, cwd);
+    const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, config.worker_launch_mode);
+    const previousSnapshot = await readMonitorSnapshot(sanitized, cwd);
+    const sessionName = config.tmux_session;
+    const listTasksStartMs = performance.now();
+    const allTasks = await listTasks(sanitized, cwd);
+    const listTasksMs = performance.now() - listTasksStartMs;
+    const reclaimedTaskIds = [];
+    for (const task of allTasks) {
+        if (task.status !== 'in_progress' || !task.claim?.leased_until)
+            continue;
+        if (new Date(task.claim.leased_until) > new Date())
+            continue;
+        const reclaimed = await reclaimExpiredTaskClaim(sanitized, task.id, cwd);
+        if (reclaimed.ok && reclaimed.reclaimed)
+            reclaimedTaskIds.push(task.id);
+    }
+    let taskView = reclaimedTaskIds.length > 0 ? await listTasks(sanitized, cwd) : allTasks;
+    const taskById = new Map(taskView.map((task) => [task.id, task]));
+    const inProgressByOwner = new Map();
+    for (const task of taskView) {
+        if (task.status !== 'in_progress' || !task.owner)
+            continue;
+        const existing = inProgressByOwner.get(task.owner) || [];
+        existing.push(task);
+        inProgressByOwner.set(task.owner, existing);
+    }
+    const workers = [];
+    const deadWorkers = [];
+    const nonReportingWorkers = [];
+    const recommendations = [];
+    const workerScanStartMs = performance.now();
+    const workerSignals = await Promise.all(config.workers.map(async (worker) => {
+        const alive = config.worker_launch_mode === 'prompt'
+            ? isPromptWorkerAlive(config, worker)
+            : isWorkerAlive(sessionName, worker.index, worker.pane_id);
+        const [status, heartbeat] = await Promise.all([
+            readWorkerStatus(sanitized, worker.name, cwd),
+            readWorkerHeartbeat(sanitized, worker.name, cwd),
+        ]);
+        return { worker, alive, status, heartbeat };
+    }));
+    const workerScanMs = performance.now() - workerScanStartMs;
+    for (const { worker: w, alive, status, heartbeat } of workerSignals) {
+        const currentTask = status.current_task_id ? taskById.get(status.current_task_id) ?? null : null;
+        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);
+            // Find in-progress tasks owned by this dead worker
+            const deadWorkerTasks = inProgressByOwner.get(w.name) || [];
+            for (const t of deadWorkerTasks) {
+                recommendations.push(`Reassign task-${t.id} from dead ${w.name}`);
+            }
+        }
+        if (alive && turnsWithoutProgress > 5) {
+            nonReportingWorkers.push(w.name);
+            recommendations.push(`Send reminder to non-reporting ${w.name}`);
+        }
+    }
+    for (const taskId of reclaimedTaskIds) {
+        recommendations.push(`Reclaimed expired claim for task-${taskId}`);
+    }
+    const rebalanceDecisions = buildRebalanceDecisions({
+        tasks: taskView,
+        workers: workers.map((worker) => ({
+            name: worker.name,
+            role: config.workers.find((entry) => entry.name === worker.name)?.role,
+            alive: worker.alive,
+            status: worker.status,
+        })),
+        reclaimedTaskIds,
+    });
+    let assignedDuringMonitor = false;
+    for (const decision of rebalanceDecisions) {
+        if (decision.type === 'assign' && decision.taskId && decision.workerName) {
+            try {
+                await assignTask(sanitized, decision.workerName, decision.taskId, cwd);
+                recommendations.push(`Assigned task-${decision.taskId} to ${decision.workerName}: ${decision.reason}`);
+                assignedDuringMonitor = true;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                recommendations.push(`Unable to assign task-${decision.taskId} to ${decision.workerName}: ${message}`);
+            }
+        }
+        else {
+            recommendations.push(decision.reason);
+        }
+    }
+    if (assignedDuringMonitor) {
+        taskView = await listTasks(sanitized, cwd);
+    }
+    // Count tasks
+    const taskCounts = {
+        total: taskView.length,
+        pending: taskView.filter(t => t.status === 'pending').length,
+        blocked: taskView.filter(t => t.status === 'blocked').length,
+        in_progress: taskView.filter(t => t.status === 'in_progress').length,
+        completed: taskView.filter(t => t.status === 'completed').length,
+        failed: taskView.filter(t => t.status === 'failed').length,
+    };
+    const verificationPendingTasks = taskView.filter((task) => task.status === 'completed'
+        && task.requires_code_change === true
+        && !hasStructuredVerificationEvidence(task.result));
+    if (verificationPendingTasks.length > 0) {
+        for (const task of verificationPendingTasks) {
+            recommendations.push(`Verification evidence missing for task-${task.id}; require structured PASS/FAIL evidence before terminal success`);
+        }
+    }
+    const allTasksTerminal = taskCounts.pending === 0 && taskCounts.blocked === 0 && taskCounts.in_progress === 0;
+    const deadWorkerStall = config.worker_launch_mode === 'prompt'
+        && config.workers.length > 0
+        && deadWorkers.length >= config.workers.length
+        && !allTasksTerminal;
+    const persistedPhase = await readTeamPhaseState(sanitized, cwd);
+    const targetPhase = deadWorkerStall
+        ? 'failed'
+        : inferPhaseTargetFromTaskCounts(taskCounts, {
+            verificationPending: verificationPendingTasks.length > 0,
+        });
+    const phaseState = reconcilePhaseStateForMonitor(persistedPhase, targetPhase);
+    await writeTeamPhaseState(sanitized, phaseState, cwd);
+    const phase = phaseState.current_phase;
+    await syncRootTeamModeStateOnTerminalPhase(sanitized, phase, cwd);
+    if (deadWorkerStall) {
+        recommendations.push('All workers are dead while work remains; mark the team failed or restart with fresh workers.');
+    }
+    await emitMonitorDerivedEvents(sanitized, taskView, workers, previousSnapshot, config.worker_launch_mode, cwd);
+    const integrationByWorker = await integrateWorkerCommitsIntoLeader({
+        teamName: sanitized,
+        config,
+        previous: previousSnapshot,
+        cwd,
+    });
+    const mailboxDeliveryStartMs = performance.now();
+    const mailboxNotifiedByMessageId = await deliverPendingMailboxMessages(sanitized, config, workers, previousSnapshot?.mailboxNotifiedByMessageId ?? {}, dispatchPolicy, cwd);
+    const mailboxDeliveryMs = performance.now() - mailboxDeliveryStartMs;
+    // Prune ephemeral status messages from leader mailbox (TTL: 60s)
+    try {
+        const leaderMailbox = await listMailboxMessages(sanitized, 'leader-fixed', cwd);
+        const now = Date.now();
+        for (const msg of leaderMailbox) {
+            if (msg.from_worker === 'system' && msg.created_at) {
+                const age = now - new Date(msg.created_at).getTime();
+                if (age > 60_000) {
+                    await markMessageDelivered(sanitized, 'leader-fixed', msg.message_id, cwd);
+                }
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+    }
+    const updatedAt = new Date().toISOString();
+    const totalMs = performance.now() - monitorStartMs;
+    await writeMonitorSnapshot(sanitized, {
+        taskStatusById: Object.fromEntries(taskView.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,
+        completedEventTaskIds: previousSnapshot?.completedEventTaskIds ?? {},
+        integrationByWorker,
+        monitorTimings: {
+            list_tasks_ms: Number(listTasksMs.toFixed(2)),
+            worker_scan_ms: Number(workerScanMs.toFixed(2)),
+            mailbox_delivery_ms: Number(mailboxDeliveryMs.toFixed(2)),
+            total_ms: Number(totalMs.toFixed(2)),
+            updated_at: updatedAt,
+        },
+    }, cwd);
+    return {
+        teamName: sanitized,
+        phase,
+        workers,
+        tasks: {
+            ...taskCounts,
+            items: taskView,
+        },
+        allTasksTerminal,
+        deadWorkers,
+        nonReportingWorkers,
+        recommendations,
+        performance: {
+            list_tasks_ms: Number(listTasksMs.toFixed(2)),
+            worker_scan_ms: Number(workerScanMs.toFixed(2)),
+            mailbox_delivery_ms: Number(mailboxDeliveryMs.toFixed(2)),
+            total_ms: Number(totalMs.toFixed(2)),
+            updated_at: updatedAt,
+        },
+    };
+}
+/**
+ * Assign a task to a worker by writing inbox and sending trigger.
+ */
+export async function assignTask(teamName, workerName, taskId, cwd) {
+    const sanitized = sanitizeTeamName(teamName);
+    const task = await readTask(sanitized, taskId, cwd);
+    if (!task)
+        throw new Error(`Task ${taskId} not found`);
+    const manifest = await readTeamManifestV2(sanitized, cwd);
+    const governance = resolveGovernancePolicy(manifest?.governance);
+    if (governance.delegation_only && workerName === 'leader-fixed') {
+        throw new Error('delegation_only_violation');
+    }
+    if (governance.plan_approval_required && task.requires_code_change === true) {
+        const approved = await isTaskApprovedForExecution(sanitized, taskId, cwd);
+        if (!approved) {
+            throw new Error('plan_approval_required');
+        }
+    }
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        throw new Error(`Team ${sanitized} not found`);
+    const workerInfo = config.workers.find(w => w.name === workerName);
+    if (!workerInfo)
+        throw new Error(`Worker ${workerName} not found in team`);
+    const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, config.worker_launch_mode);
+    const claim = await claimTask(sanitized, taskId, workerName, task.version ?? 1, cwd);
+    if (!claim.ok) {
+        if (claim.error === 'blocked_dependency') {
+            throw new Error(`blocked_dependency:${(claim.dependencies ?? []).join(',')}`);
+        }
+        throw new Error(claim.error);
+    }
+    try {
+        // Retry dispatch up to 2 times to handle trust prompts during assignment (fixes #393).
+        const taskForInbox = task.delegation
+            ? task
+            : (await updateTask(sanitized, taskId, { delegation: synthesizeDelegationPlan(task) }, cwd)) ?? task;
+        const inbox = generateTaskAssignmentInbox(workerName, sanitized, taskForInbox);
+        const maxAssignRetries = 2;
+        const assignRetryDelayS = 2;
+        let outcome = { ok: false, transport: 'none', reason: 'not_attempted' };
+        const triggerDirective = buildTriggerDirective(workerName, sanitized, resolveInstructionStateRoot(workerInfo.worktree_path));
+        for (let attempt = 1; attempt <= maxAssignRetries; attempt++) {
+            outcome = await dispatchCriticalInboxInstruction({
+                teamName: sanitized,
+                config,
+                workerName,
+                workerIndex: workerInfo.index,
+                paneId: workerInfo.pane_id,
+                inbox,
+                triggerMessage: triggerDirective.text,
+                intent: triggerDirective.intent,
+                cwd,
+                dispatchPolicy,
+                inboxCorrelationKey: `assign:${taskId}:${workerName}`,
+            });
+            if (outcome.ok)
+                break;
+            if (attempt < maxAssignRetries && config.worker_launch_mode === 'interactive' && config.tmux_session) {
+                if (dismissTrustPromptIfPresent(config.tmux_session, workerInfo.index, workerInfo.pane_id)) {
+                    waitForWorkerReady(config.tmux_session, workerInfo.index, resolveWorkerReadyTimeoutMs(process.env), workerInfo.pane_id);
+                }
+                else {
+                    await new Promise(r => setTimeout(r, assignRetryDelayS * 1000));
+                }
+            }
+        }
+        if (!outcome.ok) {
+            throw new Error('worker_notify_failed');
+        }
+    }
+    catch (error) {
+        // Roll back claim to avoid stuck in_progress tasks on any post-claim dispatch failure.
+        const released = await releaseTaskClaim(sanitized, taskId, claim.claimToken, workerName, cwd);
+        const reason = error instanceof Error && error.message.trim() !== ''
+            ? error.message
+            : 'worker_assignment_failed';
+        try {
+            await writeWorkerInbox(sanitized, workerName, `# Assignment Cancelled\n\nTask ${taskId} was not dispatched due to ${reason}.\nDo not execute this task from prior inbox content.`, cwd);
+        }
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            // best effort
+        }
+        if (!released.ok) {
+            throw new Error(`${reason}:${released.error}`);
+        }
+        if (reason === 'worker_notify_failed')
+            throw new Error('worker_notify_failed');
+        throw new Error(`worker_assignment_failed:${reason}`);
+    }
+}
+/**
+ * Reassign a task from one worker to another.
+ */
+export async function reassignTask(teamName, taskId, _fromWorker, toWorker, cwd) {
+    await assignTask(teamName, toWorker, taskId, cwd);
+}
+function resolveCommitHygieneArtifactTeamNames(config, internalTeamName) {
+    const names = [];
+    for (const value of [config.requested_name, config.display_name, internalTeamName]) {
+        if (typeof value !== 'string' || value.trim() === '')
+            continue;
+        try {
+            const sanitized = sanitizeTeamName(value);
+            if (!names.includes(sanitized))
+                names.push(sanitized);
+        }
+        catch {
+            // Persisted display/request names are best-effort aliases. If an older
+            // state file contains an invalid value, fall back to the internal name.
+        }
+    }
+    if (!names.includes(internalTeamName))
+        names.push(internalTeamName);
+    return names;
+}
+/**
+ * Graceful shutdown: send shutdown inbox to all workers, wait, force kill, cleanup.
+ */
+export async function shutdownTeam(teamName, cwd, options = {}) {
+    const force = options.force === true;
+    const confirmIssues = options.confirmIssues === true;
+    let skipWorkerAcks = false;
+    const sanitized = resolveTeamNameForCurrentContext(teamName, cwd);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config) {
+        // No config -- just try to kill tmux session and clean up
+        try {
+            destroyTeamSession(`rcs-team-${sanitized}`);
+        }
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        }
+        await cleanupTeamState(sanitized, cwd);
+        await syncTeamModeStateOnShutdown(sanitized, cwd);
+        restoreTeamModelInstructionsFile(sanitized);
+        return { commitHygieneArtifacts: null };
+    }
+    const manifest = await readTeamManifestV2(sanitized, cwd);
+    const leaderSessionId = typeof manifest?.leader?.session_id === 'string'
+        ? manifest.leader.session_id.trim()
+        : '';
+    const governance = resolveGovernancePolicy(manifest?.governance, manifest?.policy);
+    if (!force) {
+        const classification = await classifyShutdown({
+            teamName: sanitized,
+            cwd,
+            config,
+            governance,
+            confirmIssues,
+        });
+        const { gate, dirtyWorkers, requiresIssueConfirmation, useCleanFastPath } = classification;
+        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} cleanup_requires_all_workers_inactive=${governance.cleanup_requires_all_workers_inactive} dirty_workers=${dirtyWorkers.join('|') || 'none'} confirm_issues=${confirmIssues} clean_fast_path=${useCleanFastPath}`,
+        }, cwd).catch(() => { });
+        if (!gate.allowed) {
+            if (requiresIssueConfirmation) {
+                throw new Error(`shutdown_confirm_issues_required:failed=${gate.failed}:rerun=rcs team shutdown ${sanitized} --confirm-issues`);
+            }
+            throw new Error(`shutdown_gate_blocked:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`);
+        }
+        skipWorkerAcks = useCleanFastPath;
+    }
+    if (force) {
+        await appendTeamEvent(sanitized, {
+            type: 'shutdown_gate_forced',
+            worker: 'leader-fixed',
+            reason: 'force_bypass',
+        }, cwd).catch(() => { });
+    }
+    if (force && config.worker_launch_mode === 'prompt') {
+        // Prompt-mode workers are raw CLI children, not team-runtime workers that
+        // participate in the shutdown-ack handshake. Waiting the full ack window
+        // before force-killing them only adds deterministic suite slowness.
+        skipWorkerAcks = true;
+    }
+    const sessionName = config.tmux_session;
+    const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, config.worker_launch_mode);
+    const shutdownRequestTimes = new Map();
+    if (!skipWorkerAcks) {
+        // 1. Send shutdown inbox to each worker
+        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);
+                const triggerDirective = buildTriggerDirective(w.name, sanitized, resolveInstructionStateRoot(w.worktree_path));
+                await dispatchCriticalInboxInstruction({
+                    teamName: sanitized,
+                    config,
+                    workerName: w.name,
+                    workerIndex: w.index,
+                    paneId: w.pane_id,
+                    inbox: generateShutdownInbox(sanitized, w.name),
+                    triggerMessage: triggerDirective.text,
+                    intent: triggerDirective.intent,
+                    cwd,
+                    dispatchPolicy,
+                    inboxCorrelationKey: `shutdown:${w.name}`,
+                });
+            }
+            catch (err) {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
+        }
+        // 2. Wait up to 15s for workers to exit and collect acks
+        const deadline = Date.now() + 15_000;
+        const rejected = [];
+        const ackedWorkers = new Set();
+        while (Date.now() < deadline) {
+            for (const w of config.workers) {
+                const ack = await readShutdownAck(sanitized, w.name, cwd, shutdownRequestTimes.get(w.name));
+                if (ack && !ackedWorkers.has(w.name)) {
+                    ackedWorkers.add(w.name);
+                    await appendTeamEvent(sanitized, {
+                        type: 'shutdown_ack',
+                        worker: w.name,
+                        reason: ack.status === 'reject' ? `reject:${ack.reason || 'no_reason'}` : 'accept',
+                    }, cwd);
+                }
+                if (ack?.status === 'reject') {
+                    if (!rejected.some((r) => r.worker === w.name)) {
+                        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}`);
+            }
+            const anyAlive = config.workers.some((w) => (config.worker_launch_mode === 'prompt'
+                ? isPromptWorkerAlive(config, w)
+                : isWorkerAlive(sessionName, w.index, w.pane_id)));
+            if (!anyAlive)
+                break;
+            // Sleep 2s
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        const anyAliveAfterWait = config.workers.some((w) => (config.worker_launch_mode === 'prompt'
+            ? isPromptWorkerAlive(config, w)
+            : isWorkerAlive(sessionName, w.index, w.pane_id)));
+        if (anyAliveAfterWait && !force) {
+            // Workers may have accepted shutdown but not exited (Codex TUI requires explicit exit).
+            // In this case, proceed to force kill panes (next step) rather than failing and leaving state around.
+        }
+    }
+    // 3. Force kill remaining workers
+    const leaderPaneId = config.leader_pane_id;
+    const hudPaneId = config.hud_pane_id;
+    if (config.worker_launch_mode === 'interactive') {
+        const sharedSessionTopology = sessionName.includes(':')
+            ? resolveSharedSessionShutdownTopology(sessionName, leaderPaneId)
+            : null;
+        const effectiveLeaderPaneId = sharedSessionTopology?.leaderPaneId ?? leaderPaneId;
+        const effectiveHudPaneId = sharedSessionTopology?.hudPaneIds.find((paneId) => paneId === hudPaneId)
+            ?? sharedSessionTopology?.hudPaneIds[0]
+            ?? hudPaneId;
+        const livePaneIds = sharedSessionTopology?.livePaneIds ?? listPaneIds(sessionName);
+        let shutdownPaneIds = collectShutdownPaneIds({
+            config,
+            livePaneIds,
+            leaderPaneId: effectiveLeaderPaneId,
+            hudPaneId: effectiveHudPaneId,
+        });
+        if (shouldPrekillInteractiveShutdownProcessTrees(sessionName)) {
+            const workerPanePids = shutdownPaneIds
+                .map((paneId) => getWorkerPanePid(sessionName, 1, paneId))
+                .filter((pid) => typeof pid === 'number' && Number.isFinite(pid) && pid > 0);
+            for (const panePid of workerPanePids) {
+                await terminateTrackedProcessTree(panePid);
+            }
+        }
+        let resizeHookWarning = null;
+        if (config.resize_hook_name && config.resize_hook_target) {
+            const resizeHookName = config.resize_hook_name;
+            const unregistered = unregisterResizeHook(config.resize_hook_target, resizeHookName);
+            if (!unregistered && isTmuxAvailable()) {
+                const baseSession = sessionName.split(':')[0];
+                const sessionStillActive = listTeamSessions().includes(baseSession);
+                if (sessionStillActive) {
+                    resizeHookWarning = `failed to unregister resize hook ${resizeHookName}`;
+                }
+            }
+        }
+        config.resize_hook_name = null;
+        config.resize_hook_target = null;
+        await saveTeamConfig(config, cwd);
+        if (resizeHookWarning) {
+            console.warn(`[team shutdown] ${sanitized}: ${resizeHookWarning}; continuing teardown`);
+        }
+        let restoredHudPaneId = null;
+        if (effectiveHudPaneId) {
+            await killWorkerByPaneIdAsync(effectiveHudPaneId, effectiveLeaderPaneId ?? undefined);
+            if (sessionName.includes(':')) {
+                restoredHudPaneId = restoreStandaloneHudPane(effectiveLeaderPaneId, cwd);
+                if (!restoredHudPaneId) {
+                    console.warn(`[team shutdown] ${sanitized}: failed to restore standalone HUD pane`);
+                }
+            }
+        }
+        shutdownPaneIds = collectShutdownPaneIds({
+            config,
+            livePaneIds: listPaneIds(sessionName),
+            restoredStandaloneHudPaneId: restoredHudPaneId,
+            leaderPaneId: effectiveLeaderPaneId,
+            hudPaneId: effectiveHudPaneId,
+        });
+        await teardownWorkerPanes(shutdownPaneIds, {
+            leaderPaneId: effectiveLeaderPaneId,
+            hudPaneId: restoredHudPaneId ?? effectiveHudPaneId,
+        });
+        // 4. Destroy tmux session
+        if (!sessionName.includes(':')) {
+            try {
+                destroyTeamSession(sessionName);
+            }
+            catch (err) {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
+        }
+    }
+    else {
+        const promptTeardownFailures = [];
+        for (const w of config.workers) {
+            const teardown = await teardownPromptWorker(sanitized, w.name, w.pid, cwd, 'shutdown');
+            if (!teardown.terminated) {
+                promptTeardownFailures.push(`${w.name}:${teardown.error || 'unknown_error'}`);
+            }
+        }
+        if (promptTeardownFailures.length > 0) {
+            throw new Error(`shutdown_prompt_teardown_failed:${promptTeardownFailures.join(',')}`);
+        }
+    }
+    const shutdownReports = await prepareWorkerWorktreeShutdownReports(config, cwd);
+    const commitHygieneEntries = [];
+    for (const report of shutdownReports) {
+        const worker = config.workers.find((entry) => entry.name === report.workerName);
+        if (report.syntheticCommit) {
+            commitHygieneEntries.push({
+                recorded_at: new Date().toISOString(),
+                operation: 'shutdown_checkpoint',
+                worker_name: report.workerName,
+                task_id: worker?.assigned_tasks[0],
+                status: 'applied',
+                operational_commit: report.syntheticCommit,
+                source_commit: report.sourceRef,
+                worktree_path: report.worktreePath,
+                report_path: report.reportPath,
+                detail: 'Runtime created a shutdown checkpoint commit to preserve worker worktree changes.',
+            });
+        }
+        if (report.sourceRef && report.mergeOutcome !== 'skipped') {
+            commitHygieneEntries.push({
+                recorded_at: new Date().toISOString(),
+                operation: 'shutdown_merge',
+                worker_name: report.workerName,
+                task_id: worker?.assigned_tasks[0],
+                status: report.mergeOutcome === 'merged' ? 'applied' : report.mergeOutcome,
+                operational_commit: report.mergeOutcome === 'merged' ? report.leaderHeadAfter : null,
+                source_commit: report.sourceRef,
+                leader_head_before: report.leaderHeadBefore,
+                leader_head_after: report.leaderHeadAfter,
+                worktree_path: report.worktreePath,
+                report_path: report.reportPath,
+                detail: report.mergeDetail,
+            });
+        }
+    }
+    const artifactCwd = resolveTeamCommitHygieneArtifactCwd(config, cwd);
+    const taskView = await listTasks(sanitized, cwd).catch(() => []);
+    const internalLedger = await appendTeamCommitHygieneEntries(sanitized, commitHygieneEntries, artifactCwd);
+    const commitHygieneArtifactTeamNames = resolveCommitHygieneArtifactTeamNames(config, sanitized);
+    let commitHygieneArtifacts = null;
+    for (const artifactTeamName of commitHygieneArtifactTeamNames) {
+        const ledger = artifactTeamName === sanitized
+            ? internalLedger
+            : await appendTeamCommitHygieneEntries(artifactTeamName, internalLedger.entries, artifactCwd);
+        const commitHygieneContext = buildTeamCommitHygieneContext({
+            teamName: artifactTeamName,
+            tasks: taskView,
+            ledger,
+        });
+        const writtenArtifacts = await writeTeamCommitHygieneContext(artifactTeamName, commitHygieneContext, artifactCwd);
+        commitHygieneArtifacts ??= writtenArtifacts;
+    }
+    // 5. Remove worker worktree-root instructions and team-scoped fallback instructions.
+    for (const worker of config.workers) {
+        if (!worker.worktree_path || !worker.team_state_root)
+            continue;
+        try {
+            await removeWorkerWorktreeRootAgentsFile(sanitized, worker.name, worker.team_state_root, worker.worktree_path);
+        }
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        }
+    }
+    try {
+        await removeTeamWorkerInstructionsFile(sanitized, cwd);
+    }
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+    }
+    restoreTeamModelInstructionsFile(sanitized);
+    const cleanupErrors = [];
+    const provisionedWorktrees = collectProvisionedShutdownWorktrees(config);
+    if (provisionedWorktrees.length > 0) {
+        try {
+            await rollbackProvisionedWorktrees(provisionedWorktrees, {
+                skipBranchDeletion: false,
+            });
+        }
+        catch (err) {
+            cleanupErrors.push(`rollbackProvisionedWorktrees: ${String(err)}`);
+        }
+    }
+    // 7. Cleanup state
+    let teamStateCleaned = false;
+    try {
+        await cleanupTeamState(sanitized, cwd);
+        teamStateCleaned = true;
+    }
+    catch (err) {
+        cleanupErrors.push(`cleanupTeamState: ${String(err)}`);
+    }
+    if (teamStateCleaned) {
+        await syncTeamModeStateOnShutdown(sanitized, cwd, leaderSessionId);
+    }
+    if (cleanupErrors.length > 0) {
+        throw new Error(cleanupErrors.join(' | '));
+    }
+    return { commitHygieneArtifacts };
+}
+/**
+ * Resume monitoring an existing team.
+ */
+export async function resumeTeam(teamName, cwd) {
+    const sanitized = resolveTeamNameForCurrentContext(teamName, cwd);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        return null;
+    config.lifecycle_profile = 'default';
+    if (config.worker_launch_mode === 'prompt') {
+        const handleTeamConfig = { ...config, name: sanitized };
+        const hasLivePromptWorker = config.workers.some((worker) => isPromptWorkerAlive(handleTeamConfig, worker));
+        if (!hasLivePromptWorker)
+            return null;
+        const missingHandles = config.workers
+            .filter((worker) => {
+            if (!Number.isFinite(worker.pid) || (worker.pid ?? 0) <= 0)
+                return false;
+            return isPidAlive(worker.pid);
+        })
+            .filter((worker) => !getPromptWorkerHandle(sanitized, worker.name));
+        if (missingHandles.length > 0) {
+            const detail = missingHandles.map((worker) => `${worker.name}:${worker.pid ?? 'unknown'}`).join(',');
+            await appendTeamEvent(sanitized, {
+                type: 'worker_stopped',
+                worker: 'leader-fixed',
+                reason: `prompt_resume_unavailable:missing_handle:${detail}`,
+            }, cwd).catch(() => { });
+            return null;
+        }
+    }
+    else {
+        // Check if tmux session still exists
+        const baseSession = config.tmux_session.split(':')[0];
+        const teamSessions = getTeamTmuxSessions(sanitized);
+        if (!teamSessions.includes(baseSession))
+            return null;
+    }
+    return {
+        teamName: sanitized,
+        sanitizedName: sanitized,
+        sessionName: config.tmux_session,
+        config,
+        cwd,
+    };
+}
+async function findActiveTeams(cwd, leaderSessionId) {
+    const root = join(cwd, '.rcs', 'state', 'team');
+    if (!existsSync(root))
+        return [];
+    const sessions = new Set(listTeamSessions());
+    const entries = await readdir(root, { withFileTypes: true });
+    const active = [];
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const teamName = e.name;
+        const cfg = await readTeamConfig(teamName, cwd);
+        const manifest = await readTeamManifestV2(teamName, cwd);
+        const governance = resolveGovernancePolicy(manifest?.governance);
+        if (governance.one_team_per_leader_session === false)
+            continue;
+        const workerLaunchMode = cfg?.worker_launch_mode
+            ?? manifest?.policy?.worker_launch_mode
+            ?? 'interactive';
+        const tmuxSession = (manifest?.tmux_session || cfg?.tmux_session || `rcs-team-${teamName}`).split(':')[0];
+        if (leaderSessionId) {
+            const ownerSessionId = manifest?.leader?.session_id?.trim() ?? '';
+            if (ownerSessionId && ownerSessionId !== leaderSessionId)
+                continue;
+        }
+        if (workerLaunchMode === 'prompt') {
+            if ((cfg?.workers ?? []).some((worker) => isPromptWorkerAlive(cfg, worker))) {
+                active.push(teamName);
+            }
+            continue;
+        }
+        if (sessions.has(tmuxSession))
+            active.push(teamName);
+    }
+    return active;
+}
+async function detectAndCleanStaleTeam(teamName, leaderCwd, workerCount, confirmFn) {
+    const stateDir = join(leaderCwd, '.rcs', 'state', 'team', teamName);
+    if (!existsSync(stateDir))
+        return;
+    const sessions = new Set(listTeamSessions());
+    if (sessions.has(`rcs-team-${teamName}`))
+        return;
+    const repoRootResult = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd: leaderCwd, encoding: 'utf-8', windowsHide: true,
+    });
+    if (repoRootResult.status !== 0)
+        return;
+    const repoRoot = repoRootResult.stdout.trim();
+    const worktreePaths = [];
+    for (let i = 1; i <= workerCount; i++) {
+        const wtPath = join(repoRoot, '.rcs', 'team', teamName, 'worktrees', `worker-${i}`);
+        if (existsSync(wtPath))
+            worktreePaths.push(wtPath);
+    }
+    if (worktreePaths.length === 0) {
+        await cleanupTeamState(teamName, leaderCwd);
+        return;
+    }
+    const hasDirtyWorktrees = worktreePaths.some((p) => {
+        try {
+            return isWorktreeDirty(p);
+        }
+        catch {
+            return false;
+        }
+    });
+    const summary = { teamName, worktreePaths, statePath: stateDir, hasDirtyWorktrees };
+    if (!confirmFn) {
+        throw new Error(`stale_team_artifacts:${teamName}:${worktreePaths.length}_worktrees:` +
+            'pass_confirmStaleCleanup_or_manually_remove');
+    }
+    const confirmed = await confirmFn(summary);
+    if (!confirmed) {
+        throw new Error(`stale_team_cleanup_declined:${teamName}:` +
+            'manually_remove_worktrees_and_state_before_retrying');
+    }
+    for (const wtPath of worktreePaths) {
+        await removeWorktreeForce(repoRoot, wtPath);
+    }
+    await cleanupTeamState(teamName, leaderCwd);
+}
+async function resolveLeaderSessionId(cwd) {
+    const fromEnv = process.env.RCS_SESSION_ID || process.env.CODEX_SESSION_ID || process.env.SESSION_ID;
+    if (fromEnv && fromEnv.trim() !== '')
+        return fromEnv.trim();
+    const p = join(cwd, '.rcs', 'state', 'session.json');
+    if (!existsSync(p))
+        return '';
+    try {
+        const raw = await readFile(p, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.session_id === 'string' && parsed.session_id.trim() !== '')
+            return parsed.session_id.trim();
+    }
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        return '';
+    }
+    return '';
+}
+async function isTaskApprovedForExecution(teamName, taskId, cwd) {
+    const record = await readTaskApproval(teamName, taskId, cwd);
+    return record?.status === 'approved';
+}
+async function emitMonitorDerivedEvents(teamName, tasks, workers, previous, workerLaunchMode, cwd) {
+    for (const task of tasks) {
+        const prevStatus = previous?.taskStatusById[task.id];
+        if (prevStatus && prevStatus !== 'completed' && task.status === 'completed') {
+            // Skip if a task_completed event was already emitted by transitionTaskStatus (issue #161).
+            if (previous?.completedEventTaskIds?.[task.id])
+                continue;
+            await appendTeamEvent(teamName, {
+                type: 'task_completed',
+                worker: task.owner || 'unknown',
+                task_id: task.id,
+                message_id: null,
+                reason: undefined,
+            }, cwd);
+        }
+    }
+    for (const worker of workers) {
+        const prevAlive = previous?.workerAliveByName[worker.name];
+        const shouldEmitInitialPromptWorkerStop = workerLaunchMode === 'prompt' && prevAlive === undefined;
+        if ((prevAlive === true || shouldEmitInitialPromptWorkerStop) && worker.alive === false) {
+            await appendTeamEvent(teamName, {
+                type: 'worker_stopped',
+                worker: worker.name,
+                task_id: worker.status.current_task_id,
+                message_id: null,
+                reason: worker.status.reason,
+            }, cwd);
+            await emitCanonicalWorkerEvent(cwd, 'worker.stalled', {
+                worker: worker.name,
+                task_id: worker.status.current_task_id,
+                reason: worker.status.reason || 'worker_stopped',
+                status: 'worker.stalled',
+            });
+        }
+        const prevState = previous?.workerStateByName[worker.name];
+        if (prevState && prevState !== worker.status.state) {
+            await appendTeamEvent(teamName, {
+                type: 'worker_state_changed',
+                worker: worker.name,
+                task_id: worker.status.current_task_id,
+                message_id: null,
+                reason: worker.status.reason,
+                state: worker.status.state,
+                prev_state: prevState,
+            }, cwd);
+            if (worker.status.state === 'working' && (prevState === 'blocked' || prevState === 'failed' || prevState === 'unknown')) {
+                await emitCanonicalWorkerEvent(cwd, 'worker.recovered', {
+                    worker: worker.name,
+                    task_id: worker.status.current_task_id,
+                    reason: worker.status.reason || `state_transition:${prevState}->${worker.status.state}`,
+                    recovery: 'state_transition',
+                    status: 'worker.recovered',
+                });
+            }
+        }
+        if (prevState && prevState !== 'idle' && worker.status.state === 'idle') {
+            await appendTeamEvent(teamName, {
+                type: 'worker_idle',
+                worker: worker.name,
+                task_id: worker.status.current_task_id,
+                message_id: null,
+                reason: undefined,
+                prev_state: prevState,
+                state: 'idle',
+                source_type: 'worker_idle',
+            }, cwd);
+        }
+    }
+}
+async function notifyWorkerOutcome(config, workerIndex, message, workerPaneId) {
+    const worker = config.workers.find((candidate) => candidate.index === workerIndex);
+    if (!worker)
+        return { ok: false, transport: 'none', reason: 'worker_not_found' };
+    if (config.worker_launch_mode === 'prompt') {
+        const handle = getPromptWorkerHandle(config.name, worker.name);
+        if (!handle)
+            return { ok: false, transport: 'prompt_stdin', reason: 'prompt_worker_handle_missing' };
+        try {
+            sendToWorkerStdin(handle.child.stdin, message);
+            return { ok: true, transport: 'prompt_stdin', reason: 'prompt_stdin_sent' };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                transport: 'prompt_stdin',
+                reason: `prompt_stdin_failed:${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    if (!config.tmux_session || !isTmuxAvailable()) {
+        return { ok: false, transport: 'tmux_send_keys', reason: 'tmux_unavailable' };
+    }
+    try {
+        await sendToWorker(config.tmux_session, workerIndex, message, workerPaneId, worker.worker_cli);
+        return { ok: true, transport: 'tmux_send_keys', reason: 'tmux_send_keys_sent' };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            transport: 'tmux_send_keys',
+            reason: `tmux_send_keys_failed:${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function resolveDispatchPolicy(manifestPolicy, workerLaunchMode) {
+    return normalizeTeamPolicy(manifestPolicy, {
+        display_mode: manifestPolicy?.display_mode === 'split_pane' ? 'split_pane' : 'auto',
+        worker_launch_mode: workerLaunchMode,
+    });
+}
+function isLeaderPaneMissingMailboxPersistedOutcome(params) {
+    const { workerName, paneId, outcome } = params;
+    return workerName === 'leader-fixed'
+        && !paneId
+        && outcome.ok
+        && outcome.reason === 'leader_pane_missing_mailbox_persisted';
+}
+async function markDispatchRequestLeaderPaneMissingDeferred(params) {
+    const { teamName, requestId, messageId, cwd } = params;
+    const current = await readDispatchRequest(teamName, requestId, cwd);
+    if (!current)
+        return;
+    if (current.status !== 'pending')
+        return;
+    await transitionDispatchRequest(teamName, requestId, current.status, current.status, {
+        message_id: messageId ?? current.message_id,
+        last_reason: 'leader_pane_missing_deferred',
+    }, cwd).catch(() => { });
+}
+async function attemptStartupDirectTrigger(params) {
+    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, taskIds, cwd, timing, } = params;
+    const safety = await evaluateStartupDirectTriggerSafety(config.tmux_session, workerIndex, paneId, workerCli);
+    if (!safety.safe) {
+        timing.mark('startup_direct_bypass', {
+            worker: workerName,
+            pane_id: paneId,
+            ok: false,
+            reason: `startup_direct_unsafe:${safety.reason}`,
+        });
+        return null;
+    }
+    const queued = await queueInboxInstruction({
+        teamName,
+        workerName,
+        workerIndex,
+        paneId,
+        inbox,
+        triggerMessage,
+        intent,
+        cwd,
+        transportPreference: 'transport_direct',
+        fallbackAllowed: false,
+        inboxCorrelationKey: `startup-direct:${workerName}`,
+        notify: (_target, message) => notifyWorkerOutcome(config, workerIndex, message, paneId),
+    });
+    timing.mark('dispatch_queued', {
+        worker: workerName,
+        pane_id: paneId,
+        ok: queued.ok,
+        reason: queued.reason,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    timing.mark('direct_fallback', {
+        worker: workerName,
+        pane_id: paneId,
+        ok: queued.ok,
+        reason: queued.ok ? `startup_direct_trigger_sent:${safety.reason}` : queued.reason,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    if (!queued.ok)
+        return queued;
+    const effectiveWorkerCli = workerCli ?? 'codex';
+    const workerStartupEvidence = await waitForWorkerStartupEvidence({
+        teamName,
+        workerName,
+        workerCli: effectiveWorkerCli,
+        cwd,
+        timeoutMs: 0,
+        pollMs: STARTUP_EVIDENCE_POLL_MS,
+    });
+    timing.mark('startup_evidence', {
+        worker: workerName,
+        pane_id: paneId,
+        ok: workerStartupEvidence !== 'none',
+        reason: workerStartupEvidence,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    const reason = workerStartupEvidence === 'none'
+        ? `${effectiveWorkerCli}_startup_direct_no_evidence:${safety.reason}`
+        : `startup_direct_trigger_sent:${safety.reason}`;
+    if ((effectiveWorkerCli === 'codex' || effectiveWorkerCli === 'claude') && workerStartupEvidence === 'none') {
+        await recordRecoverableStartupIssue({
+            teamName,
+            workerName,
+            taskIds,
+            reason,
+            cwd,
+        });
+    }
+    return {
+        ...queued,
+        reason,
+    };
+}
+async function dispatchCriticalInboxInstruction(params) {
+    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, cwd, dispatchPolicy, inboxCorrelationKey, requireWorkerStartupEvidence, startupEvidenceTimeoutMs, startupReadyPromptObserved = false, startupTiming, } = params;
+    const noteTiming = (phase, details) => {
+        startupTiming?.mark(phase, { worker: workerName, pane_id: paneId, ...details });
+    };
+    if (config.worker_launch_mode === 'prompt') {
+        return await queueInboxInstruction({
+            teamName,
+            workerName,
+            workerIndex,
+            paneId,
+            inbox,
+            triggerMessage,
+            intent,
+            cwd,
+            transportPreference: 'prompt_stdin',
+            fallbackAllowed: false,
+            inboxCorrelationKey,
+            notify: (_target, message) => notifyWorkerOutcome(config, workerIndex, message, paneId),
+        });
+    }
+    if (dispatchPolicy.dispatch_mode === 'transport_direct') {
+        return await queueInboxInstruction({
+            teamName,
+            workerName,
+            workerIndex,
+            paneId,
+            inbox,
+            triggerMessage,
+            intent,
+            cwd,
+            transportPreference: 'transport_direct',
+            fallbackAllowed: false,
+            inboxCorrelationKey,
+            notify: (_target, message) => notifyWorkerOutcome(config, workerIndex, message, paneId),
+        });
+    }
+    const queued = await queueInboxInstruction({
+        teamName,
+        workerName,
+        workerIndex,
+        paneId,
+        inbox,
+        triggerMessage,
+        intent,
+        cwd,
+        transportPreference: 'hook_preferred_with_fallback',
+        fallbackAllowed: true,
+        inboxCorrelationKey,
+        notify: () => ({ ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }),
+    });
+    noteTiming('dispatch_queued', {
+        ok: queued.ok,
+        reason: queued.reason,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    if (!queued.request_id)
+        return { ...queued, ok: false, reason: 'dispatch_request_missing_id' };
+    const receipt = await waitForDispatchReceipt(teamName, queued.request_id, cwd, {
+        timeoutMs: dispatchPolicy.dispatch_ack_timeout_ms,
+        pollMs: 50,
+    });
+    if (receipt) {
+        noteTiming('hook_receipt', {
+            ok: receipt.status === 'delivered' || receipt.status === 'notified',
+            reason: receipt.status,
+            transport: 'hook',
+            request_id: queued.request_id,
+        });
+    }
+    if (receipt?.status === 'delivered') {
+        return { ok: true, transport: 'hook', reason: 'hook_receipt_delivered', request_id: queued.request_id };
+    }
+    const requiresObservedStartupEvidence = requireWorkerStartupEvidence === true
+        && (workerCli === 'claude' || workerCli === 'codex');
+    let startupEvidence = 'none';
+    if (receipt?.status === 'notified') {
+        if (!requiresObservedStartupEvidence) {
+            return { ok: true, transport: 'hook', reason: 'hook_receipt_notified', request_id: queued.request_id };
+        }
+        if (startupReadyPromptObserved) {
+            return {
+                ok: true,
+                transport: 'hook',
+                reason: 'hook_receipt_notified_with_ready_prompt',
+                request_id: queued.request_id,
+            };
+        }
+        startupEvidence = await waitForWorkerStartupEvidence({
+            teamName,
+            workerName,
+            workerCli,
+            cwd,
+            timeoutMs: startupEvidenceTimeoutMs,
+        });
+        noteTiming('startup_evidence', {
+            ok: startupEvidence !== 'none',
+            reason: startupEvidence,
+            transport: 'hook',
+            request_id: queued.request_id,
+        });
+        if (startupEvidence !== 'none') {
+            return {
+                ok: true,
+                transport: 'hook',
+                reason: `hook_receipt_notified_with_${startupEvidence}`,
+                request_id: queued.request_id,
+            };
+        }
+    }
+    if (receipt?.status === 'failed') {
+        const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
+        if (fallback.ok) {
+            const fallbackStartupEvidence = startupReadyPromptObserved
+                ? 'ready_prompt'
+                : await waitForRequiredStartupEvidenceAfterDirectFallback({
+                    requireWorkerStartupEvidence,
+                    workerCli,
+                    teamName,
+                    workerName,
+                    cwd,
+                    timeoutMs: startupEvidenceTimeoutMs,
+                });
+            noteTiming('startup_evidence', {
+                ok: fallbackStartupEvidence !== 'none',
+                reason: fallbackStartupEvidence,
+                transport: fallback.transport,
+                request_id: queued.request_id,
+            });
+            if (requiresObservedStartupEvidence && fallbackStartupEvidence === 'none') {
+                await transitionDispatchRequest(teamName, queued.request_id, 'failed', 'failed', { last_reason: `${workerCli}_startup_no_evidence_after_fallback:${fallback.reason}` }, cwd).catch(() => { });
+                return {
+                    ok: false,
+                    transport: fallback.transport,
+                    reason: `${workerCli}_startup_no_evidence_after_fallback:${fallback.reason}`,
+                    request_id: queued.request_id,
+                };
+            }
+            const current = await readDispatchRequest(teamName, queued.request_id, cwd);
+            if (current) {
+                await transitionDispatchRequest(teamName, queued.request_id, current.status, 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            }
+            return {
+                ok: true,
+                transport: fallback.transport,
+                reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}`,
+                request_id: queued.request_id,
+            };
+        }
+        await transitionDispatchRequest(teamName, queued.request_id, receipt.status, 'failed', { last_reason: `fallback_attempted_but_unconfirmed:${fallback.reason}` }, cwd).catch(() => { });
+        return {
+            ok: false,
+            transport: fallback.transport,
+            reason: `fallback_attempted_but_unconfirmed:${fallback.reason}`,
+            request_id: queued.request_id,
+        };
+    }
+    const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
+    noteTiming('direct_fallback', {
+        ok: fallback.ok,
+        reason: fallback.reason,
+        transport: fallback.transport,
+        request_id: queued.request_id,
+    });
+    const startupFallbackLabel = receipt?.status === 'notified' && requiresObservedStartupEvidence
+        ? `${workerCli}_startup_no_evidence`
+        : null;
+    const fallbackFailureReason = startupFallbackLabel
+        ? `${startupFallbackLabel}_fallback_failed:${fallback.reason}`
+        : `fallback_attempted_but_unconfirmed:${fallback.reason}`;
+    if (fallback.ok) {
+        const fallbackStartupEvidence = startupReadyPromptObserved
+            ? 'ready_prompt'
+            : await waitForRequiredStartupEvidenceAfterDirectFallback({
+                requireWorkerStartupEvidence,
+                workerCli,
+                teamName,
+                workerName,
+                cwd,
+                timeoutMs: startupEvidenceTimeoutMs,
+            });
+        noteTiming('startup_evidence', {
+            ok: fallbackStartupEvidence !== 'none',
+            reason: fallbackStartupEvidence,
+            transport: fallback.transport,
+            request_id: queued.request_id,
+        });
+        if (requiresObservedStartupEvidence && fallbackStartupEvidence === 'none') {
+            const current = await readDispatchRequest(teamName, queued.request_id, cwd);
+            if (current && current.status !== 'failed') {
+                await transitionDispatchRequest(teamName, queued.request_id, current.status, 'failed', { last_reason: `${workerCli}_startup_no_evidence_after_fallback:${fallback.reason}` }, cwd).catch(() => { });
+            }
+            return {
+                ok: false,
+                transport: fallback.transport,
+                reason: `${workerCli}_startup_no_evidence_after_fallback:${fallback.reason}`,
+                request_id: queued.request_id,
+            };
+        }
+        const marked = await markDispatchRequestNotified(teamName, queued.request_id, { last_reason: `fallback_confirmed:${fallback.reason}` }, cwd);
+        if (!marked) {
+            const current = await readDispatchRequest(teamName, queued.request_id, cwd);
+            if (current) {
+                await transitionDispatchRequest(teamName, queued.request_id, current.status, 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            }
+        }
+        return {
+            ok: true,
+            transport: fallback.transport,
+            reason: startupFallbackLabel
+                ? `${startupFallbackLabel}_fallback_confirmed:${fallback.reason}`
+                : `hook_timeout_fallback_confirmed:${fallback.reason}`,
+            request_id: queued.request_id,
+        };
+    }
+    const current = await readDispatchRequest(teamName, queued.request_id, cwd);
+    if (current && current.status !== 'failed') {
+        await transitionDispatchRequest(teamName, queued.request_id, current.status, 'failed', { last_reason: fallbackFailureReason }, cwd).catch(() => { });
+    }
+    return {
+        ok: false,
+        transport: fallback.transport,
+        reason: fallbackFailureReason,
+        request_id: queued.request_id,
+    };
+}
+async function waitForRequiredStartupEvidenceAfterDirectFallback(params) {
+    const { requireWorkerStartupEvidence, workerCli, teamName, workerName, cwd, timeoutMs, } = params;
+    const requiresObservedStartupEvidence = requireWorkerStartupEvidence === true
+        && (workerCli === 'claude' || workerCli === 'codex');
+    if (!requiresObservedStartupEvidence || !workerCli) {
+        return 'none';
+    }
+    return await waitForWorkerStartupEvidence({
+        teamName,
+        workerName,
+        workerCli,
+        cwd,
+        timeoutMs,
+    });
+}
+async function finalizeHookPreferredMailboxDispatch(params) {
+    const { teamName, requestId, workerName, workerIndex, paneId, messageId, triggerMessage, intent, config, dispatchPolicy, cwd, fallbackNotify, } = params;
+    const receipt = await waitForDispatchReceipt(teamName, requestId, cwd, {
+        timeoutMs: dispatchPolicy.dispatch_ack_timeout_ms,
+        pollMs: 50,
+    });
+    if (receipt && (receipt.status === 'notified' || receipt.status === 'delivered')) {
+        await markMessageNotified(teamName, workerName, messageId, cwd).catch(() => false);
+        const outcome = { ok: true, transport: 'hook', reason: `hook_receipt_${receipt.status}`, request_id: requestId, message_id: messageId };
+        await logRuntimeDispatchOutcome({ cwd, teamName, workerName, requestId, messageId, intent, outcome });
+        return outcome;
+    }
+    const fallback = fallbackNotify
+        ? await fallbackNotify()
+        : (typeof workerIndex === 'number'
+            ? await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId)
+            : { ok: false, transport: 'none', reason: 'missing_worker_index' });
+    if (receipt?.status === 'failed') {
+        if (fallback.ok) {
+            await markMessageNotified(teamName, workerName, messageId, cwd).catch(() => false);
+            const current = await readDispatchRequest(teamName, requestId, cwd);
+            if (current) {
+                await transitionDispatchRequest(teamName, requestId, current.status, 'failed', { message_id: messageId, last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => null);
+            }
+            const outcome = {
+                ok: true,
+                transport: fallback.transport,
+                reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}`,
+                request_id: requestId,
+                message_id: messageId,
+            };
+            await logRuntimeDispatchOutcome({ cwd, teamName, workerName, requestId, messageId, intent, outcome });
+            return outcome;
+        }
+        await transitionDispatchRequest(teamName, requestId, 'failed', 'failed', { message_id: messageId, last_reason: `fallback_attempted_but_unconfirmed:${fallback.reason}` }, cwd).catch(() => { });
+        const outcome = {
+            ok: false,
+            transport: fallback.transport,
+            reason: `fallback_attempted_but_unconfirmed:${fallback.reason}`,
+            request_id: requestId,
+            message_id: messageId,
+        };
+        await logRuntimeDispatchOutcome({ cwd, teamName, workerName, requestId, messageId, intent, outcome });
+        return outcome;
+    }
+    if (fallback.ok) {
+        if (isLeaderPaneMissingMailboxPersistedOutcome({ workerName, paneId, outcome: fallback })) {
+            await markDispatchRequestLeaderPaneMissingDeferred({
+                teamName,
+                requestId,
+                messageId,
+                cwd,
+            });
+            const outcome = {
+                ok: true,
+                transport: fallback.transport,
+                reason: 'leader_pane_missing_mailbox_persisted',
+                request_id: requestId,
+                message_id: messageId,
+            };
+            await logRuntimeDispatchOutcome({ cwd, teamName, workerName, requestId, messageId, intent, outcome });
+            return outcome;
+        }
+        await markMessageNotified(teamName, workerName, messageId, cwd).catch(() => false);
+        const marked = await markDispatchRequestNotified(teamName, requestId, { message_id: messageId, last_reason: `fallback_confirmed:${fallback.reason}` }, cwd);
+        if (!marked) {
+            const current = await readDispatchRequest(teamName, requestId, cwd);
+            if (current) {
+                await transitionDispatchRequest(teamName, requestId, current.status, 'failed', { message_id: messageId, last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            }
+        }
+        const outcome = {
+            ok: true,
+            transport: fallback.transport,
+            reason: `hook_timeout_fallback_confirmed:${fallback.reason}`,
+            request_id: requestId,
+            message_id: messageId,
+        };
+        await logRuntimeDispatchOutcome({ cwd, teamName, workerName, requestId, messageId, intent, outcome });
+        return outcome;
+    }
+    const current = await readDispatchRequest(teamName, requestId, cwd);
+    if (current) {
+        await transitionDispatchRequest(teamName, requestId, current.status, 'failed', { message_id: messageId, last_reason: `fallback_attempted_but_unconfirmed:${fallback.reason}` }, cwd).catch(() => { });
+    }
+    const outcome = {
+        ok: false,
+        transport: fallback.transport,
+        reason: `fallback_attempted_but_unconfirmed:${fallback.reason}`,
+        request_id: requestId,
+        message_id: messageId,
+    };
+    await logRuntimeDispatchOutcome({ cwd, teamName, workerName, requestId, messageId, intent, outcome });
+    return outcome;
+}
+async function notifyLeaderAsync(config, message, cwd) {
+    // Canonical leader delivery is durable mailbox persistence plus HUD-owned
+    // authority processing. Team runtime must not directly inject into the
+    // leader pane from this fallback path.
+    const { notifyLeaderMailboxAsync } = await import('./tmux-session.js');
+    const persisted = await notifyLeaderMailboxAsync(config.name, 'system', message, cwd);
+    if (!persisted) {
+        return { ok: false, transport: 'mailbox', reason: 'leader_mailbox_notify_failed' };
+    }
+    if (!config.leader_pane_id) {
+        return { ok: true, transport: 'mailbox', reason: 'leader_pane_missing_mailbox_persisted' };
+    }
+    return { ok: true, transport: 'mailbox', reason: 'leader_mailbox_notified' };
+}
+async function deliverPendingMailboxMessages(teamName, config, workers, previousNotifications, dispatchPolicy, cwd) {
+    const nextNotifications = {};
+    const pendingIdsAcrossTeam = new Set();
+    for (const worker of workers) {
+        const workerInfo = config.workers.find((w) => w.name === worker.name);
+        if (!workerInfo)
+            continue;
+        const mailbox = await listMailboxMessages(teamName, worker.name, cwd);
+        const pending = mailbox.filter((m) => !m.delivered_at);
+        if (pending.length === 0)
+            continue;
+        const pendingIds = pending.map((m) => m.message_id);
+        for (const id of pendingIds)
+            pendingIdsAcrossTeam.add(id);
+        // Preserve already-tracked notification timestamps in the next snapshot.
+        for (const msg of pending) {
+            nextNotifications[msg.message_id] = msg.notified_at || previousNotifications[msg.message_id] || '';
+        }
+        // Only notify for messages that have never been successfully notified.
+        // Using a message-ID set prevents re-notification on every monitor poll
+        // (issue #116). A message is considered notified when either:
+        //   - notified_at is set in the mailbox file (persisted by markMessageNotified), or
+        //   - the message_id exists in previousNotifications from the last snapshot.
+        // Both checks use Boolean() so an empty-string value is treated as unnotified.
+        const unnotified = pending.filter((m) => !m.notified_at && !previousNotifications[m.message_id]);
+        if (unnotified.length === 0)
+            continue;
+        if (!worker.alive)
+            continue;
+        for (const msg of unnotified) {
+            const outcome = await dispatchPendingMailboxMessage({
+                teamName,
+                workerName: worker.name,
+                workerInfo,
+                messageId: msg.message_id,
+                config,
+                dispatchPolicy,
+                cwd,
+            });
+            if (outcome.ok) {
+                nextNotifications[msg.message_id] = new Date().toISOString();
+            }
+        }
+    }
+    const pruned = {};
+    for (const [messageId, ts] of Object.entries(nextNotifications)) {
+        if (pendingIdsAcrossTeam.has(messageId) && ts)
+            pruned[messageId] = ts;
+    }
+    return pruned;
+}
+function resolveWorkerMailboxTransportPreference(config, dispatchPolicy) {
+    return config.worker_launch_mode === 'prompt'
+        ? 'prompt_stdin'
+        : (dispatchPolicy.dispatch_mode === 'transport_direct' ? 'transport_direct' : 'hook_preferred_with_fallback');
+}
+function resolveLeaderMailboxTransportPreference(dispatchPolicy) {
+    return dispatchPolicy.dispatch_mode === 'transport_direct' ? 'transport_direct' : 'hook_preferred_with_fallback';
+}
+function isExistingMailboxNotificationOutcome(outcome) {
+    return outcome.ok && outcome.reason === 'existing_message_already_notified';
+}
+async function dispatchPendingMailboxMessage(params) {
+    const { teamName, workerName, workerInfo, messageId, config, dispatchPolicy, cwd } = params;
+    const triggerDirective = buildMailboxTriggerDirective(workerName, teamName, 1, resolveInstructionStateRoot(workerInfo.worktree_path));
+    const transportPreference = resolveWorkerMailboxTransportPreference(config, dispatchPolicy);
+    const queued = await enqueueDispatchRequest(teamName, {
+        kind: 'mailbox',
+        to_worker: workerName,
+        worker_index: workerInfo.index,
+        pane_id: workerInfo.pane_id,
+        trigger_message: triggerDirective.text,
+        intent: triggerDirective.intent,
+        message_id: messageId,
+        transport_preference: transportPreference,
+        fallback_allowed: transportPreference === 'hook_preferred_with_fallback',
+    }, cwd);
+    if (transportPreference === 'hook_preferred_with_fallback') {
+        return await finalizeQueuedMailboxDispatch({
+            queuedOutcome: {
+                ok: true,
+                transport: 'hook',
+                reason: 'queued_for_hook_dispatch',
+                request_id: queued.request.request_id,
+                message_id: messageId,
+            },
+            transportPreference,
+            teamName,
+            workerName,
+            workerIndex: workerInfo.index,
+            paneId: workerInfo.pane_id,
+            messageId,
+            triggerMessage: triggerDirective.text,
+            intent: triggerDirective.intent,
+            config,
+            dispatchPolicy,
+            cwd,
+        });
+    }
+    const direct = await notifyWorkerOutcome(config, workerInfo.index, triggerDirective.text, workerInfo.pane_id);
+    const outcome = { ...direct, request_id: queued.request.request_id, message_id: messageId };
+    if (outcome.ok) {
+        await markMessageNotified(teamName, workerName, messageId, cwd).catch(() => false);
+        await markDispatchRequestNotified(teamName, queued.request.request_id, { message_id: messageId, last_reason: outcome.reason }, cwd).catch(() => null);
+    }
+    await logRuntimeDispatchOutcome({
+        cwd,
+        teamName,
+        workerName,
+        requestId: queued.request.request_id,
+        messageId,
+        outcome,
+    });
+    return outcome;
+}
+async function finalizeQueuedMailboxDispatch(params) {
+    const { queuedOutcome, transportPreference, teamName, workerName, workerIndex, paneId, messageId, triggerMessage, intent, config, dispatchPolicy, cwd, fallbackNotify, } = params;
+    if (transportPreference !== 'hook_preferred_with_fallback') {
+        return queuedOutcome;
+    }
+    if (isExistingMailboxNotificationOutcome(queuedOutcome)) {
+        return queuedOutcome;
+    }
+    if (!queuedOutcome.request_id || !messageId) {
+        return { ...queuedOutcome, ok: false, reason: 'dispatch_request_missing_id' };
+    }
+    return await finalizeHookPreferredMailboxDispatch({
+        teamName,
+        requestId: queuedOutcome.request_id,
+        workerName,
+        workerIndex,
+        paneId,
+        messageId,
+        triggerMessage,
+        intent,
+        config,
+        dispatchPolicy,
+        cwd,
+        fallbackNotify,
+    });
+}
+async function sendLeaderMailboxMessage(params) {
+    const { teamName, fromWorker, body, config, dispatchPolicy, cwd } = params;
+    const triggerDirective = buildLeaderMailboxTriggerDirective(teamName, fromWorker, config.team_state_root || undefined);
+    const transportPreference = resolveLeaderMailboxTransportPreference(dispatchPolicy);
+    const queuedOutcome = await queueDirectMailboxMessage({
+        teamName,
+        fromWorker,
+        toWorker: 'leader-fixed',
+        toPaneId: config.leader_pane_id ?? undefined,
+        body,
+        triggerMessage: triggerDirective.text,
+        intent: triggerDirective.intent,
+        cwd,
+        transportPreference,
+        fallbackAllowed: transportPreference === 'hook_preferred_with_fallback',
+        notify: async (_target, message) => {
+            if (transportPreference === 'hook_preferred_with_fallback') {
+                return { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' };
+            }
+            if (!config.leader_pane_id) {
+                return { ok: false, transport: 'mailbox', reason: 'leader_pane_missing_transport_direct_failed' };
+            }
+            return await notifyLeaderAsync(config, message, cwd);
+        },
+    });
+    if (!isExistingMailboxNotificationOutcome(queuedOutcome)
+        && transportPreference === 'hook_preferred_with_fallback'
+        && !config.leader_pane_id) {
+        if (queuedOutcome.request_id) {
+            await markDispatchRequestLeaderPaneMissingDeferred({
+                teamName,
+                requestId: queuedOutcome.request_id,
+                messageId: queuedOutcome.message_id,
+                cwd,
+            });
+        }
+        const deferredOutcome = {
+            ...queuedOutcome,
+            ok: true,
+            transport: 'mailbox',
+            reason: 'leader_pane_missing_mailbox_persisted',
+        };
+        await logRuntimeDispatchOutcome({
+            cwd,
+            teamName,
+            workerName: 'leader-fixed',
+            requestId: deferredOutcome.request_id,
+            messageId: deferredOutcome.message_id,
+            intent: triggerDirective.intent,
+            outcome: deferredOutcome,
+        });
+        return deferredOutcome;
+    }
+    if (!isExistingMailboxNotificationOutcome(queuedOutcome)
+        && transportPreference === 'transport_direct'
+        && !config.leader_pane_id) {
+        const failedOutcome = {
+            ...queuedOutcome,
+            ok: false,
+            transport: 'mailbox',
+            reason: 'leader_pane_missing_transport_direct_failed',
+        };
+        await logRuntimeDispatchOutcome({
+            cwd,
+            teamName,
+            workerName: 'leader-fixed',
+            requestId: failedOutcome.request_id,
+            messageId: failedOutcome.message_id,
+            intent: triggerDirective.intent,
+            outcome: failedOutcome,
+        });
+        return failedOutcome;
+    }
+    const canLeaderFallbackDirectly = Boolean(config.leader_pane_id) && isTmuxAvailable();
+    return await finalizeQueuedMailboxDispatch({
+        queuedOutcome,
+        transportPreference: canLeaderFallbackDirectly ? transportPreference : 'transport_direct',
+        teamName,
+        workerName: 'leader-fixed',
+        paneId: config.leader_pane_id ?? undefined,
+        messageId: queuedOutcome.message_id,
+        triggerMessage: triggerDirective.text,
+        intent: triggerDirective.intent,
+        config,
+        dispatchPolicy,
+        cwd,
+        fallbackNotify: async () => await notifyLeaderAsync(config, triggerDirective.text, cwd),
+    });
+}
+async function sendRecipientMailboxMessage(params) {
+    const { teamName, fromWorker, toWorker, body, config, dispatchPolicy, cwd } = params;
+    const recipient = config.workers.find((worker) => worker.name === toWorker);
+    if (!recipient)
+        throw new Error(`Worker ${toWorker} not found in team`);
+    const triggerDirective = buildMailboxTriggerDirective(toWorker, teamName, 1, resolveInstructionStateRoot(recipient.worktree_path));
+    const transportPreference = resolveWorkerMailboxTransportPreference(config, dispatchPolicy);
+    const queuedOutcome = await queueDirectMailboxMessage({
+        teamName,
+        fromWorker,
+        toWorker,
+        toWorkerIndex: recipient.index,
+        toPaneId: recipient.pane_id,
+        body,
+        triggerMessage: triggerDirective.text,
+        intent: triggerDirective.intent,
+        cwd,
+        transportPreference,
+        fallbackAllowed: transportPreference === 'hook_preferred_with_fallback',
+        notify: async (_target, message) => (transportPreference === 'hook_preferred_with_fallback'
+            ? { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }
+            : await notifyWorkerOutcome(config, recipient.index, message, recipient.pane_id)),
+    });
+    return await finalizeQueuedMailboxDispatch({
+        queuedOutcome,
+        transportPreference,
+        teamName,
+        workerName: recipient.name,
+        workerIndex: recipient.index,
+        paneId: recipient.pane_id,
+        messageId: queuedOutcome.message_id,
+        triggerMessage: triggerDirective.text,
+        intent: triggerDirective.intent,
+        config,
+        dispatchPolicy,
+        cwd,
+    });
+}
+async function finalizeBroadcastMailboxOutcomes(params) {
+    const { teamName, outcomes, transportPreference, config, dispatchPolicy, cwd } = params;
+    if (transportPreference !== 'hook_preferred_with_fallback') {
+        return outcomes;
+    }
+    const finalizedOutcomes = [];
+    for (const outcome of outcomes) {
+        const target = outcome.to_worker
+            ? (config.workers.find((worker) => worker.name === outcome.to_worker) ?? null)
+            : null;
+        if (!target) {
+            finalizedOutcomes.push({ ...outcome, ok: false, reason: 'missing_worker_index' });
+            continue;
+        }
+        const triggerDirective = buildMailboxTriggerDirective(target.name, teamName, 1, resolveInstructionStateRoot(target.worktree_path));
+        finalizedOutcomes.push(await finalizeQueuedMailboxDispatch({
+            queuedOutcome: outcome,
+            transportPreference,
+            teamName,
+            workerName: target.name,
+            workerIndex: target.index,
+            paneId: target.pane_id,
+            messageId: outcome.message_id,
+            triggerMessage: triggerDirective.text,
+            intent: triggerDirective.intent,
+            config,
+            dispatchPolicy,
+            cwd,
+        }));
+    }
+    return finalizedOutcomes;
+}
+export async function sendWorkerMessage(teamName, fromWorker, toWorker, body, cwd) {
+    const sanitized = sanitizeTeamName(teamName);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        throw new Error(`Team ${sanitized} not found`);
+    const manifest = await readTeamManifestV2(sanitized, cwd);
+    const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, config.worker_launch_mode);
+    if (toWorker === 'leader-fixed') {
+        const finalOutcome = await sendLeaderMailboxMessage({
+            teamName: sanitized,
+            fromWorker,
+            body,
+            config,
+            dispatchPolicy,
+            cwd,
+        });
+        if (!finalOutcome.ok)
+            throw new Error(`mailbox_notify_failed:${finalOutcome.reason}`);
+        return finalOutcome;
+    }
+    const finalOutcome = await sendRecipientMailboxMessage({
+        teamName: sanitized,
+        fromWorker,
+        toWorker,
+        body,
+        config,
+        dispatchPolicy,
+        cwd,
+    });
+    if (!finalOutcome.ok)
+        throw new Error(`mailbox_notify_failed:${finalOutcome.reason}`);
+    return finalOutcome;
+}
+export async function broadcastWorkerMessage(teamName, fromWorker, body, cwd) {
+    const sanitized = sanitizeTeamName(teamName);
+    const config = await readTeamConfig(sanitized, cwd);
+    if (!config)
+        throw new Error(`Team ${sanitized} not found`);
+    const manifest = await readTeamManifestV2(sanitized, cwd);
+    const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, config.worker_launch_mode);
+    const transportPreference = resolveWorkerMailboxTransportPreference(config, dispatchPolicy);
+    const outcomes = await queueBroadcastMailboxMessage({
+        teamName: sanitized,
+        fromWorker,
+        recipients: config.workers.map((w) => ({ workerName: w.name, workerIndex: w.index, paneId: w.pane_id })),
+        body,
+        cwd,
+        triggerFor: (workerName) => buildMailboxTriggerDirective(workerName, sanitized, 1, resolveInstructionStateRoot(config.workers.find((worker) => worker.name === workerName)?.worktree_path)).text,
+        intentFor: () => 'pending-mailbox-review',
+        transportPreference,
+        fallbackAllowed: transportPreference === 'hook_preferred_with_fallback',
+        notify: async (target, message) => transportPreference === 'hook_preferred_with_fallback'
+            ? { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }
+            : (typeof target.workerIndex === 'number'
+                ? await notifyWorkerOutcome(config, target.workerIndex, message, target.paneId)
+                : { ok: false, transport: 'none', reason: 'missing_worker_index' }),
+    });
+    const results = await finalizeBroadcastMailboxOutcomes({
+        teamName: sanitized,
+        outcomes,
+        transportPreference,
+        config,
+        dispatchPolicy,
+        cwd,
+    });
+    if (results.some((result) => !result.ok)) {
+        const firstFailure = results.find((result) => !result.ok);
+        throw new Error(`mailbox_notify_failed:${firstFailure?.reason ?? 'unknown'}`);
+    }
+}
+//# sourceMappingURL=runtime.js.map