oh-my-codex 0.12.4 → 0.12.6

package/dist/team/runtime.js

@@ -3,8 +3,8 @@ 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, dismissTrustPromptIfPresent, sleepFractionalSeconds, sendToWorker, sendToWorkerStdin, isWorkerAlive, getWorkerPanePid, killWorkerByPaneIdAsync, restoreStandaloneHudPane, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listPaneIds, listTeamSessions, } 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, 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, } from './team-ops.js';
+import { sanitizeTeamName, isTmuxAvailable, hasCurrentTmuxClientContext, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, dismissTrustPromptIfPresent, sleepFractionalSeconds, 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, 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, } from './team-ops.js';
 import { queueInboxInstruction, queueDirectMailboxMessage, queueBroadcastMailboxMessage, waitForDispatchReceipt, } from './mcp-comm.js';
 import { appendTeamDeliveryLogForCwd } from './delivery-log.js';
 import { generateWorkerOverlay, writeTeamWorkerInstructionsFile, removeTeamWorkerInstructionsFile, writeWorkerWorktreeRootAgentsFile, removeWorkerWorktreeRootAgentsFile, generateInitialInbox, generateTaskAssignmentInbox, generateShutdownInbox, buildTriggerDirective, buildMailboxTriggerDirective, buildLeaderMailboxTriggerDirective, writeWorkerRoleInstructionsFile, } from './worker-bootstrap.js';
@@ -18,6 +18,7 @@ import { inferPhaseTargetFromTaskCounts, reconcilePhaseStateForMonitor } from '.
 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, writeTeamCommitHygieneContext, } from './commit-hygiene.js';
 import { assertCleanLeaderWorkspaceForWorkerWorktrees, ensureWorktree, isGitRepository, isWorktreeDirty, planWorktreeTarget, removeWorktreeForce, rollbackProvisionedWorktrees, } from './worktree.js';
@@ -51,6 +52,40 @@ async function syncRootTeamModeStateOnTerminalPhase(teamName, phase, cwd) {
         // 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) {
@@ -86,10 +121,10 @@ export function applyCreatedInteractiveSessionToConfig(config, createdSession, w
     }
 }
 function collectShutdownPaneIds(params) {
-    const { config, livePaneIds = [], restoredStandaloneHudPaneId = null } = params;
+    const { config, livePaneIds = [], restoredStandaloneHudPaneId = null, leaderPaneId = config.leader_pane_id, hudPaneId = config.hud_pane_id, } = params;
     const excludedPaneIds = new Set([
-        config.leader_pane_id,
-        config.hud_pane_id,
+        leaderPaneId,
+        hudPaneId,
         restoredStandaloneHudPaneId,
     ].filter((paneId) => typeof paneId === 'string' && paneId.trim().startsWith('%')));
     const paneIds = new Set();
@@ -862,14 +897,24 @@ const TEAM_LEADER_CWD_ENV = 'OMX_TEAM_LEADER_CWD';
 const WORKTREE_TRIGGER_STATE_ROOT = '$OMX_TEAM_STATE_ROOT';
 const STARTUP_EVIDENCE_TIMEOUT_MS = 2_000;
 const STARTUP_EVIDENCE_POLL_MS = 100;
+const STARTUP_EVIDENCE_LAUNCH_TIMEOUT_MS = 5_000;
 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 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 = 'OMX_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 OMX_TEAM_WORKER_CLI=claude/gemini for prompt-mode teammates.`);
+    }
+}
 function resolveWorkerReadyTimeoutMs(env) {
     const raw = env.OMX_TEAM_READY_TIMEOUT_MS;
     const parsed = Number.parseInt(String(raw ?? ''), 10);
@@ -877,6 +922,12 @@ function resolveWorkerReadyTimeoutMs(env) {
         return parsed;
     return 45_000;
 }
+function resolveWorkerStartupEvidenceTimeoutMs(env, workerReadyTimeoutMs) {
+    const raw = Number.parseInt(String(env.OMX_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 parseTeamWorkerContext(raw) {
     if (typeof raw !== 'string' || raw.trim() === '')
         return null;
@@ -954,6 +1005,30 @@ export async function waitForClaudeStartupEvidence(params) {
 function shouldSkipWorkerReadyWait(env) {
     return env.OMX_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(() => { });
+}
 function setTeamModelInstructionsFile(teamName, filePath) {
     if (!previousModelInstructionsFileByTeam.has(teamName)) {
         previousModelInstructionsFileByTeam.set(teamName, process.env[MODEL_INSTRUCTIONS_FILE_ENV]);
@@ -1258,8 +1333,8 @@ function isPromptWorkerAlive(config, worker) {
 }
 export { TEAM_LOW_COMPLEXITY_DEFAULT_MODEL };
 export { resolveCanonicalTeamStateRoot };
-function spawnPromptWorker(teamName, workerName, workerIndex, workerCwd, launchArgs, workerEnv, workerCli, initialPrompt) {
-    const processSpec = buildWorkerProcessLaunchSpec(teamName, workerIndex, launchArgs, workerCwd, workerEnv, workerCli, initialPrompt);
+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',
@@ -1402,7 +1477,11 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
         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 skipWorkerReadyWait = shouldSkipWorkerReadyWait(process.env);
     try {
         // 3. Init state directory + config
@@ -1518,9 +1597,53 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 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)
         if (workerLaunchMode === 'interactive') {
             const createdSession = createTeamSession(sanitized, workerCount, leaderCwd, sharedWorkerLaunchArgs, workerStartups);
@@ -1539,12 +1662,21 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             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);
+                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]);
+        }
         await saveTeamConfig(config, leaderCwd);
         // 7. Wait for all workers to be ready (interactive mode), then bootstrap them
         const manifest = await readTeamManifestV2(sanitized, leaderCwd);
@@ -1554,64 +1686,33 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             if (!bootstrapPlan) {
                 throw new Error(`missing bootstrap plan for worker-${i}`);
             }
-            const { workerName, paneId, workerTasks, workerRole, inbox, trigger, triggerIntent, initialPrompt } = {
+            const { workerName, paneId, workerTasks, inbox, trigger, triggerIntent, initialPrompt } = {
                 workerName: bootstrapPlan.workerName,
                 paneId: workerPaneIds[i - 1],
                 workerTasks: bootstrapPlan.workerTasks,
-                workerRole: bootstrapPlan.workerRole,
                 inbox: bootstrapPlan.inbox,
                 trigger: bootstrapPlan.trigger,
                 triggerIntent: bootstrapPlan.triggerIntent,
                 initialPrompt: bootstrapPlan.initialPrompt,
             };
-            const workerWorkspace = bootstrapPlan.workerWorkspace;
             if (workerTasks.map(t => t.role).filter(Boolean).length > 0 && new Set(workerTasks.map(t => t.role).filter(Boolean)).size > 1) {
                 console.log(`[omx:team] ${workerName}: mixed task roles [${[...new Set(workerTasks.map(t => t.role).filter(Boolean))].join(', ')}], falling back to ${agentType}`);
             }
-            // Write worker identity
-            const identity = {
-                name: workerName,
-                index: i,
-                role: workerRole,
-                worker_cli: workerCliPlan[i - 1],
-                assigned_tasks: workerTasks.map(t => t.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,
-            };
-            // Get pane PID and store it (interactive mode) or process PID (prompt mode)
-            if (workerLaunchMode === 'interactive') {
-                const panePid = getWorkerPanePid(sessionName, i, paneId);
-                if (panePid)
-                    identity.pid = panePid;
-            }
-            else if (config.workers[i - 1]?.pid) {
-                identity.pid = config.workers[i - 1].pid;
-            }
-            if (paneId)
-                identity.pane_id = paneId;
-            if (config.workers[i - 1]) {
-                config.workers[i - 1].pid = identity.pid;
-                config.workers[i - 1].pane_id = paneId;
-                config.workers[i - 1].role = workerRole;
-                config.workers[i - 1].worker_cli = workerCliPlan[i - 1];
-                config.workers[i - 1].working_dir = workerWorkspace.cwd;
-                config.workers[i - 1].worktree_repo_root = workerWorkspace.worktreeRepoRoot;
-                config.workers[i - 1].worktree_path = workerWorkspace.worktreePath;
-                config.workers[i - 1].worktree_branch = workerWorkspace.worktreeBranch;
-                config.workers[i - 1].worktree_detached = workerWorkspace.worktreeDetached;
-                config.workers[i - 1].worktree_created = workerWorkspace.worktreeCreated;
-                config.workers[i - 1].team_state_root = teamStateRoot;
-            }
-            await writeWorkerIdentity(sanitized, workerName, identity, leaderCwd);
             // Wait for worker readiness
             if (workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt) {
                 const ready = waitForWorkerReady(sessionName, i, workerReadyTimeoutMs, paneId);
                 if (!ready) {
+                    const workerAlive = isWorkerPaneOpen(sessionName, i, paneId);
+                    if (workerAlive) {
+                        await recordRecoverableStartupIssue({
+                            teamName: sanitized,
+                            workerName,
+                            taskIds: workerTasks.map((task) => task.id),
+                            reason: 'ready_prompt_timeout',
+                            cwd: leaderCwd,
+                        });
+                        continue;
+                    }
                     throw new Error(`Worker ${workerName} did not become ready in tmux session ${sessionName}`);
                 }
             }
@@ -1639,6 +1740,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                         dispatchPolicy,
                         inboxCorrelationKey: `startup:${workerName}`,
                         requireWorkerStartupEvidence: true,
+                        startupEvidenceTimeoutMs: workerStartupEvidenceTimeoutMs,
                     });
                     if (dispatchOutcome.ok)
                         break;
@@ -1659,7 +1761,22 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 }
             }
             if (!dispatchOutcome.ok) {
-                throw new Error(`worker_notify_failed:${workerName}`);
+                const workerAlive = workerLaunchMode === 'prompt'
+                    ? isPromptWorkerAlive(config, config.workers[i - 1])
+                    : isWorkerPaneOpen(sessionName, i, paneId);
+                if (workerLaunchMode === 'interactive'
+                    && workerAlive
+                    && isRecoverableInteractiveStartupReason(dispatchOutcome.reason)) {
+                    await recordRecoverableStartupIssue({
+                        teamName: sanitized,
+                        workerName,
+                        taskIds: workerTasks.map((task) => task.id),
+                        reason: dispatchOutcome.reason,
+                        cwd: leaderCwd,
+                    });
+                    continue;
+                }
+                throw new Error(`worker_notify_failed:${workerName}:${dispatchOutcome.reason}`);
             }
         }
         await saveTeamConfig(config, leaderCwd);
@@ -2118,10 +2235,14 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
             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({
@@ -2232,8 +2353,20 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
     const leaderPaneId = config.leader_pane_id;
     const hudPaneId = config.hud_pane_id;
     if (config.worker_launch_mode === 'interactive') {
-        const livePaneIds = listPaneIds(sessionName);
-        let shutdownPaneIds = collectShutdownPaneIds({ config, livePaneIds });
+        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))
@@ -2261,10 +2394,10 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
             console.warn(`[team shutdown] ${sanitized}: ${resizeHookWarning}; continuing teardown`);
         }
         let restoredHudPaneId = null;
-        if (hudPaneId) {
-            await killWorkerByPaneIdAsync(hudPaneId, leaderPaneId ?? undefined);
+        if (effectiveHudPaneId) {
+            await killWorkerByPaneIdAsync(effectiveHudPaneId, effectiveLeaderPaneId ?? undefined);
             if (sessionName.includes(':')) {
-                restoredHudPaneId = restoreStandaloneHudPane(leaderPaneId, cwd);
+                restoredHudPaneId = restoreStandaloneHudPane(effectiveLeaderPaneId, cwd);
                 if (!restoredHudPaneId) {
                     console.warn(`[team shutdown] ${sanitized}: failed to restore standalone HUD pane`);
                 }
@@ -2274,10 +2407,12 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
             config,
             livePaneIds: listPaneIds(sessionName),
             restoredStandaloneHudPaneId: restoredHudPaneId,
+            leaderPaneId: effectiveLeaderPaneId,
+            hudPaneId: effectiveHudPaneId,
         });
         await teardownWorkerPanes(shutdownPaneIds, {
-            leaderPaneId,
-            hudPaneId: restoredHudPaneId ?? hudPaneId,
+            leaderPaneId: effectiveLeaderPaneId,
+            hudPaneId: restoredHudPaneId ?? effectiveHudPaneId,
         });
         // 4. Destroy tmux session
         if (!sessionName.includes(':')) {
@@ -2376,12 +2511,17 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
         }
     }
     // 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(' | '));
     }
@@ -2652,7 +2792,7 @@ async function markDispatchRequestLeaderPaneMissingDeferred(params) {
     }, cwd).catch(() => { });
 }
 async function dispatchCriticalInboxInstruction(params) {
-    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, cwd, dispatchPolicy, inboxCorrelationKey, requireWorkerStartupEvidence, } = params;
+    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, cwd, dispatchPolicy, inboxCorrelationKey, requireWorkerStartupEvidence, startupEvidenceTimeoutMs, } = params;
     if (config.worker_launch_mode === 'prompt') {
         return await queueInboxInstruction({
             teamName,
@@ -2720,6 +2860,7 @@ async function dispatchCriticalInboxInstruction(params) {
             workerName,
             workerCli,
             cwd,
+            timeoutMs: startupEvidenceTimeoutMs,
         });
         if (startupEvidence !== 'none') {
             return {
@@ -2733,7 +2874,27 @@ async function dispatchCriticalInboxInstruction(params) {
     if (receipt?.status === 'failed') {
         const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
         if (fallback.ok) {
-            await transitionDispatchRequest(teamName, queued.request_id, 'pending', 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            const fallbackStartupEvidence = await waitForRequiredStartupEvidenceAfterDirectFallback({
+                requireWorkerStartupEvidence,
+                workerCli,
+                teamName,
+                workerName,
+                cwd,
+                timeoutMs: startupEvidenceTimeoutMs,
+            });
+            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,
@@ -2757,9 +2918,32 @@ async function dispatchCriticalInboxInstruction(params) {
         ? `${startupFallbackLabel}_fallback_failed:${fallback.reason}`
         : `fallback_attempted_but_unconfirmed:${fallback.reason}`;
     if (fallback.ok) {
+        const fallbackStartupEvidence = await waitForRequiredStartupEvidenceAfterDirectFallback({
+            requireWorkerStartupEvidence,
+            workerCli,
+            teamName,
+            workerName,
+            cwd,
+            timeoutMs: startupEvidenceTimeoutMs,
+        });
+        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) {
-            await transitionDispatchRequest(teamName, queued.request_id, 'pending', 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            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,
@@ -2781,6 +2965,21 @@ async function dispatchCriticalInboxInstruction(params) {
         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, {
@@ -2801,7 +3000,10 @@ async function finalizeHookPreferredMailboxDispatch(params) {
     if (receipt?.status === 'failed') {
         if (fallback.ok) {
             await markMessageNotified(teamName, workerName, messageId, cwd).catch(() => false);
-            await transitionDispatchRequest(teamName, requestId, 'failed', 'failed', { message_id: messageId, last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => null);
+            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,
@@ -2844,7 +3046,10 @@ async function finalizeHookPreferredMailboxDispatch(params) {
         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) {
-            await transitionDispatchRequest(teamName, requestId, 'failed', 'failed', { message_id: messageId, last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            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,