oh-my-codex 0.14.4 → 0.15.1

package/dist/team/__tests__/runtime.test.js

@@ -6,8 +6,8 @@ import { join } from 'path';
 import { tmpdir } from 'os';
 import { existsSync } from 'fs';
 import { HUD_TMUX_TEAM_HEIGHT_LINES } from '../../hud/constants.js';
-import { initTeamState, createTask, readTeamConfig, saveTeamConfig, listMailboxMessages, listDispatchRequests, transitionDispatchRequest, updateWorkerHeartbeat, writeAtomic, readTask, readMonitorSnapshot, claimTask, transitionTaskStatus, readWorkerStatus, writeWorkerStatus, } from '../state.js';
-import { monitorTeam, shutdownTeam, resumeTeam, startTeam, assignTask, sendWorkerMessage, applyCreatedInteractiveSessionToConfig, resolveWorkerLaunchArgsFromEnv, shouldPrekillInteractiveShutdownProcessTrees, waitForWorkerStartupEvidence, waitForClaudeStartupEvidence, } from '../runtime.js';
+import { initTeamState, createTask, writeWorkerInbox, readTeamConfig, saveTeamConfig, listMailboxMessages, listDispatchRequests, transitionDispatchRequest, updateWorkerHeartbeat, writeAtomic, readTask, readMonitorSnapshot, claimTask, transitionTaskStatus, readWorkerStatus, writeWorkerStatus, } from '../state.js';
+import { monitorTeam, shutdownTeam, resumeTeam, startTeam, assignTask, sendWorkerMessage, applyCreatedInteractiveSessionToConfig, resolveWorkerLaunchArgsFromEnv, shouldPrekillInteractiveShutdownProcessTrees, waitForWorkerStartupEvidence, waitForClaudeStartupEvidence, cleanupTeamWorkerLaunchOrphanedMcpProcesses, settleStartupAttemptResults, } from '../runtime.js';
 import { resolveAgentReasoningEffort, resolveTeamLowComplexityDefaultModel } from '../model-contract.js';
 import { readTeamEvents } from '../state/events.js';
 import { sanitizeTeamName } from '../tmux-session.js';
@@ -56,6 +56,21 @@ async function readTeamDeliveryLog(cwd) {
         .filter(Boolean)
         .map((line) => JSON.parse(line));
 }
+async function markPendingInboxDispatchesDelivered(teamName, cwd, opts = {}) {
+    const requests = await listDispatchRequests(teamName, cwd, { kind: 'inbox' }).catch(() => []);
+    for (const request of requests) {
+        if (request.status !== 'pending')
+            continue;
+        if (opts.toWorker && request.to_worker !== opts.toWorker)
+            continue;
+        await opts.beforeDeliver?.();
+        const notified = await transitionDispatchRequest(teamName, request.request_id, 'pending', 'notified', { last_reason: opts.lastReason ?? 'test_delivered_receipt' }, cwd).catch(() => null);
+        if (!notified)
+            continue;
+        await transitionDispatchRequest(teamName, request.request_id, 'notified', 'delivered', { last_reason: opts.lastReason ?? 'test_delivered_receipt' }, cwd).catch(() => { });
+        await opts.afterDeliver?.();
+    }
+}
 function withEmptyPath(fn) {
     const prev = process.env.PATH;
     process.env.PATH = '';
@@ -517,6 +532,30 @@ describe('runtime', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('cleanupTeamWorkerLaunchOrphanedMcpProcesses keeps ps and cleanup failures non-fatal', async () => {
+        const warnings = [];
+        let calls = 0;
+        await cleanupTeamWorkerLaunchOrphanedMcpProcesses({
+            cleanup: async () => {
+                calls += 1;
+                throw new Error('ps unavailable');
+            },
+            writeWarning: (message) => warnings.push(message),
+        });
+        await cleanupTeamWorkerLaunchOrphanedMcpProcesses({
+            cleanup: async () => ({
+                dryRun: false,
+                candidates: [],
+                terminatedCount: 0,
+                forceKilledCount: 0,
+                failedPids: [1234],
+            }),
+            writeWarning: (message) => warnings.push(message),
+        });
+        assert.equal(calls, 1);
+        assert.match(warnings.join('\n'), /ps unavailable.*continuing worker launch/);
+        assert.match(warnings.join('\n'), /Failed to reap 1 orphaned OMX MCP process/);
+    });
     it('waitForWorkerStartupEvidence treats blocked worker status as settled progress even without a claimed task id', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-codex-blocked-startup-'));
         try {
@@ -785,10 +824,6 @@ sleep 5
                 process.env.OMX_TEAM_WORKER_LAUNCH_MODE = prevLaunchMode;
             else
                 delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
-            if (typeof prevWorkerCli === 'string')
-                process.env.OMX_TEAM_WORKER_CLI = prevWorkerCli;
-            else
-                delete process.env.OMX_TEAM_WORKER_CLI;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -804,6 +839,7 @@ sleep 5
                 process.env.OMX_TEAM_WORKER_LAUNCH_MODE = prevLaunchMode;
             else
                 delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+            delete process.env.OMX_TEAM_WORKER_CLI;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -932,7 +968,7 @@ esac
                 delete process.env.WSL_DISTRO_NAME;
                 delete process.env.WSL_INTEROP;
                 Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
-                runtime = await withoutTeamWorkerEnv(() => startTeam('team-win32-no-env', 'native windows current-client detection', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd));
+                const runtime = await withoutTeamWorkerEnv(() => startTeam('team-win32-no-env', 'native windows current-client detection', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd));
                 teamNameForCleanup = runtime.teamName;
                 assert.equal(runtime.config.tmux_session, 'leader:0');
                 assert.equal(runtime.config.leader_pane_id, '%1');
@@ -943,7 +979,6 @@ esac
                 if (teamNameForCleanup) {
                     await shutdownTeam(teamNameForCleanup, cwd, { force: true });
                 }
-                runtime = null;
             });
         }
         finally {
@@ -1017,6 +1052,115 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('startTeam runs worker MCP orphan cleanup before interactive tmux worker spawn', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-interactive-mcp-cleanup-'));
+        const prevTmux = process.env.TMUX;
+        const prevTmuxPane = process.env.TMUX_PANE;
+        const prevLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const prevWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        const prevSkipReadyWait = process.env.OMX_TEAM_SKIP_READY_WAIT;
+        let runtime = null;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-interactive-mcp-cleanup-bin-',
+                tmuxScript: (tmuxLogPath) => `#!/bin/sh
+set -eu
+printf '%s\n' "$*" >> "${tmuxLogPath}"
+case "\${1:-}" in
+  -V)
+    echo "tmux 3.4"
+    exit 0
+    ;;
+  display-message)
+    case "$*" in
+      *"#{window_width}"*) echo "120" ;;
+      *) echo "leader:0 %1" ;;
+    esac
+    exit 0
+    ;;
+  list-panes)
+    case "$*" in
+      *"pane_current_command"*) printf "%%1\tnode\t'codex'\n" ;;
+      *"#{pane_dead} #{pane_pid}"*) echo "1 999999" ;;
+      *"-t %2"*"#{pane_pid}"*) echo "2222" ;;
+      *"#{pane_pid}"*) echo "1111" ;;
+      *) exit 0 ;;
+    esac
+    exit 0
+    ;;
+  split-window)
+    case "$*" in
+      *" -h "*)
+        mkdir -p "${cwd}/.omx/state/team/team-interactive-cleanup/workers/worker-1"
+        cat > "${cwd}/.omx/state/team/team-interactive-cleanup/workers/worker-1/status.json" <<'EOF'
+{
+  "state": "working",
+  "current_task_id": "1",
+  "updated_at": "2026-04-23T00:00:00.000Z"
+}
+EOF
+        echo "%2"
+        ;;
+      *) echo "%3" ;;
+    esac
+    exit 0
+    ;;
+  set-hook|run-shell|select-layout|set-window-option|select-pane|send-keys|kill-pane|kill-session)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`,
+                binaries: [{ name: 'codex', content: '#!/bin/sh\nexit 0\n' }],
+            }, async ({ tmuxLogPath }) => {
+                delete process.env.TMUX;
+                process.env.TMUX_PANE = '%1';
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'interactive';
+                process.env.OMX_TEAM_WORKER_CLI = 'codex';
+                process.env.OMX_TEAM_SKIP_READY_WAIT = '1';
+                const events = [];
+                runtime = await withoutTeamWorkerEnv(() => startTeam('team-interactive-cleanup', 'interactive cleanup before worker spawn', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd, {
+                    cleanupLaunchOrphanedMcpProcesses: async () => {
+                        events.push('cleanup');
+                        return { dryRun: false, candidates: [], terminatedCount: 0, forceKilledCount: 0, failedPids: [] };
+                    },
+                }));
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.match(tmuxLog, /split-window/);
+                assert.deepEqual(events, ['cleanup']);
+                assert.equal(runtime.config.workers[0]?.pane_id, '%2');
+            });
+        }
+        finally {
+            const runtimeToShutdown = runtime;
+            if (runtimeToShutdown) {
+                await shutdownTeam(runtimeToShutdown.teamName, cwd, { force: true }).catch(() => { });
+            }
+            if (typeof prevTmux === 'string')
+                process.env.TMUX = prevTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof prevTmuxPane === 'string')
+                process.env.TMUX_PANE = prevTmuxPane;
+            else
+                delete process.env.TMUX_PANE;
+            if (typeof prevLaunchMode === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = prevLaunchMode;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof prevWorkerCli === 'string')
+                process.env.OMX_TEAM_WORKER_CLI = prevWorkerCli;
+            else
+                delete process.env.OMX_TEAM_WORKER_CLI;
+            if (typeof prevSkipReadyWait === 'string')
+                process.env.OMX_TEAM_SKIP_READY_WAIT = prevSkipReadyWait;
+            else
+                delete process.env.OMX_TEAM_SKIP_READY_WAIT;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('startTeam captures interactive worker pid from the resolved pane id', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-pane-pid-'));
         const prevTmux = process.env.TMUX;
@@ -1141,11 +1285,11 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('startTeam saves interactive pane ids before readiness waits in source order', async () => {
+    it('startTeam saves interactive pane ids before concurrent readiness attempts', async () => {
         const source = await readFile(join(process.cwd(), 'src', 'team', 'runtime.ts'), 'utf-8');
         const applyMatch = source.match(/applyCreatedInteractiveSessionToConfig\(\s*config,\s*createdSession,\s*workerPaneIds\s*\);/m);
         const saveMatch = source.match(/await saveTeamConfig\(config, leaderCwd\);/m);
-        const readyMatch = source.match(/const ready = waitForWorkerReady\(/m);
+        const readyMatch = source.match(/waitForWorkerReadyAsync\(/m);
         const applyIndex = applyMatch?.index ?? -1;
         const saveIndex = saveMatch?.index ?? -1;
         const readyIndex = readyMatch?.index ?? -1;
@@ -1155,6 +1299,147 @@ esac
         assert.equal(applyIndex < saveIndex, true);
         assert.equal(saveIndex < readyIndex, true);
     });
+    it('startTeam starts worker-2 readiness before delayed worker-1 readiness settles', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-parallel-ready-'));
+        const previousTmux = process.env.TMUX;
+        const previousTmuxPane = process.env.TMUX_PANE;
+        const previousLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        const previousReadyTimeout = process.env.OMX_TEAM_READY_TIMEOUT_MS;
+        const previousStartupEvidenceTimeout = process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+        const previousStartupDispatchRetries = process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES;
+        let receiptDeliverer = null;
+        let runtimeTeamName = null;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-parallel-ready-bin-',
+                tmuxScript: () => `#!/bin/sh
+set -eu
+order_file="${cwd}/ready-order.log"
+case "$1" in
+  -V)
+    echo "tmux 3.4"
+    exit 0
+    ;;
+  display-message)
+    case "$*" in
+      *"#{window_width}"*) echo "120" ;;
+      *) echo "leader:0 %1" ;;
+    esac
+    exit 0
+    ;;
+  list-panes)
+    case "$*" in
+      *"pane_current_command"*) printf "%%1\tnode\t'codex'\n" ;;
+      *"#{pane_dead} #{pane_pid}"*) echo "0 4242" ;;
+      *"-t %2"*"#{pane_pid}"*) echo "4242" ;;
+      *"-t %3"*"#{pane_pid}"*) echo "4343" ;;
+      *"#{pane_pid}"*) echo "4141" ;;
+      *) exit 0 ;;
+    esac
+    exit 0
+    ;;
+  capture-pane)
+    case "$*" in
+      *"-t %2"*)
+        printf '%s\n' w1-ready-start >> "$order_file"
+        sleep 0.4
+        printf '%s\n' w1-ready-done >> "$order_file"
+        printf 'OpenAI Codex\nmodel: test\n› \n'
+        ;;
+      *"-t %3"*)
+        printf '%s\n' w2-ready-start >> "$order_file"
+        printf 'OpenAI Codex\nmodel: test\n› \n'
+        ;;
+      *)
+        printf 'OpenAI Codex\nmodel: test\n› \n'
+        ;;
+    esac
+    exit 0
+    ;;
+  split-window)
+    count_file="${cwd}/split-window-count"
+    count=0
+    if [ -f "$count_file" ]; then count=$(cat "$count_file"); fi
+    count=$((count + 1))
+    printf '%s' "$count" > "$count_file"
+    case "$count" in
+      1) echo "%2" ;;
+      2) echo "%3" ;;
+      *) echo "%4" ;;
+    esac
+    exit 0
+    ;;
+  set-hook|run-shell|select-layout|set-window-option|select-pane|send-keys|kill-pane|kill-session|resize-pane)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`,
+                binaries: [{ name: 'codex', content: '#!/usr/bin/env node\nprocess.stdin.resume();\n' }],
+            }, async () => {
+                delete process.env.TMUX;
+                process.env.TMUX_PANE = '%1';
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'interactive';
+                process.env.OMX_TEAM_WORKER_CLI = 'codex';
+                process.env.OMX_TEAM_READY_TIMEOUT_MS = '2000';
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = '50';
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES = '1';
+                receiptDeliverer = setInterval(() => {
+                    void (async () => {
+                        await markPendingInboxDispatchesDelivered('team-parallel-ready', cwd);
+                    })();
+                }, 20);
+                const runtime = await withoutTeamWorkerEnv(() => startTeam('team-parallel-ready', 'worker-2 readiness should not wait for worker-1 readiness settle', 'executor', 2, [
+                    { subject: 'w1', description: 'worker one', owner: 'worker-1' },
+                    { subject: 'w2', description: 'worker two', owner: 'worker-2' },
+                ], cwd));
+                runtimeTeamName = runtime.teamName;
+                const order = (await readFile(join(cwd, 'ready-order.log'), 'utf-8')).trim().split('\n');
+                assert.ok(order.includes('w1-ready-start'));
+                assert.ok(order.includes('w2-ready-start'));
+                assert.ok(order.includes('w1-ready-done'));
+                assert.equal(order.indexOf('w2-ready-start') < order.indexOf('w1-ready-done'), true, `expected worker-2 readiness attempt before worker-1 readiness settled, got ${order.join(',')}`);
+            });
+        }
+        finally {
+            if (receiptDeliverer)
+                clearInterval(receiptDeliverer);
+            if (runtimeTeamName)
+                await shutdownTeam(runtimeTeamName, cwd, { force: true }).catch(() => { });
+            if (typeof previousTmux === 'string')
+                process.env.TMUX = previousTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof previousTmuxPane === 'string')
+                process.env.TMUX_PANE = previousTmuxPane;
+            else
+                delete process.env.TMUX_PANE;
+            if (typeof previousLaunchMode === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = previousLaunchMode;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof previousWorkerCli === 'string')
+                process.env.OMX_TEAM_WORKER_CLI = previousWorkerCli;
+            else
+                delete process.env.OMX_TEAM_WORKER_CLI;
+            if (typeof previousReadyTimeout === 'string')
+                process.env.OMX_TEAM_READY_TIMEOUT_MS = previousReadyTimeout;
+            else
+                delete process.env.OMX_TEAM_READY_TIMEOUT_MS;
+            if (typeof previousStartupEvidenceTimeout === 'string')
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = previousStartupEvidenceTimeout;
+            else
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+            if (typeof previousStartupDispatchRetries === 'string')
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES = previousStartupDispatchRetries;
+            else
+                delete process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('startTeam records recoverable startup issues per worker instead of failing launch early when panes stay alive', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-no-startup-evidence-'));
         const previousTmux = process.env.TMUX;
@@ -1324,6 +1609,164 @@ process.on('SIGTERM', () => process.exit(0));
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('startTeam attempts worker-2 before rejecting lowest-index unrecoverable startup failure', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-parallel-dead-pane-'));
+        const previousTmux = process.env.TMUX;
+        const previousTmuxPane = process.env.TMUX_PANE;
+        const previousLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        const previousReadyTimeout = process.env.OMX_TEAM_READY_TIMEOUT_MS;
+        const previousStartupEvidenceTimeout = process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+        const previousStartupDispatchRetries = process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES;
+        let receiptFailer = null;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-parallel-dead-pane-bin-',
+                tmuxScript: () => `#!/bin/sh
+set -eu
+order_file="${cwd}/dead-pane-order.log"
+case "$1" in
+  -V)
+    echo "tmux 3.4"
+    exit 0
+    ;;
+  display-message)
+    case "$*" in
+      *"#{window_width}"*) echo "120" ;;
+      *) echo "leader:0 %1" ;;
+    esac
+    exit 0
+    ;;
+  list-panes)
+    case "$*" in
+      *"pane_current_command"*) printf "%%1\tnode\t'codex'\n" ;;
+      *"-t %2"*"#{pane_dead} #{pane_pid}"*) echo "1 4242" ;;
+      *"-t %3"*"#{pane_dead} #{pane_pid}"*) echo "0 4343" ;;
+      *"#{pane_dead} #{pane_pid}"*) echo "0 4141" ;;
+      *"-t %2"*"#{pane_pid}"*) echo "4242" ;;
+      *"-t %3"*"#{pane_pid}"*) echo "4343" ;;
+      *"#{pane_pid}"*) echo "4141" ;;
+      *) exit 0 ;;
+    esac
+    exit 0
+    ;;
+  capture-pane)
+    case "$*" in
+      *"-t %2"*) printf '%s\n' w1-ready-start >> "$order_file" ;;
+      *"-t %3"*) printf '%s\n' w2-ready-start >> "$order_file"; printf 'OpenAI Codex\nmodel: test\n› \n' ;;
+      *) printf 'OpenAI Codex\nmodel: test\n› \n' ;;
+    esac
+    exit 0
+    ;;
+  split-window)
+    count_file="${cwd}/split-window-count"
+    count=0
+    if [ -f "$count_file" ]; then count=$(cat "$count_file"); fi
+    count=$((count + 1))
+    printf '%s' "$count" > "$count_file"
+    case "$count" in
+      1) echo "%2" ;;
+      2) echo "%3" ;;
+      *) echo "%4" ;;
+    esac
+    exit 0
+    ;;
+  set-hook|run-shell|select-layout|set-window-option|select-pane|send-keys|kill-pane|kill-session|resize-pane)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`,
+                binaries: [{ name: 'codex', content: '#!/usr/bin/env node\nprocess.stdin.resume();\n' }],
+            }, async () => {
+                delete process.env.TMUX;
+                process.env.TMUX_PANE = '%1';
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'interactive';
+                process.env.OMX_TEAM_WORKER_CLI = 'codex';
+                process.env.OMX_TEAM_READY_TIMEOUT_MS = '300';
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = '50';
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES = '1';
+                receiptFailer = setInterval(() => {
+                    void (async () => {
+                        const requests = await listDispatchRequests('team-parallel-dead-pane', cwd, { kind: 'inbox' }).catch(() => []);
+                        for (const request of requests) {
+                            if (request.status !== 'pending')
+                                continue;
+                            await transitionDispatchRequest('team-parallel-dead-pane', request.request_id, 'pending', 'failed', { last_reason: 'test_failed_receipt' }, cwd).catch(() => { });
+                        }
+                    })();
+                }, 20);
+                await assert.rejects(() => withoutTeamWorkerEnv(() => startTeam('team-parallel-dead-pane', 'worker-2 should be attempted despite worker-1 fatal readiness failure', 'executor', 2, [
+                    { subject: 'w1', description: 'worker one', owner: 'worker-1' },
+                    { subject: 'w2', description: 'worker two', owner: 'worker-2' },
+                ], cwd)), /Worker worker-1 did not become ready/);
+                const order = (await readFile(join(cwd, 'dead-pane-order.log'), 'utf-8')).trim().split('\n');
+                assert.ok(order.includes('w1-ready-start'));
+                assert.ok(order.includes('w2-ready-start'));
+            });
+        }
+        finally {
+            if (receiptFailer)
+                clearInterval(receiptFailer);
+            if (typeof previousTmux === 'string')
+                process.env.TMUX = previousTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof previousTmuxPane === 'string')
+                process.env.TMUX_PANE = previousTmuxPane;
+            else
+                delete process.env.TMUX_PANE;
+            if (typeof previousLaunchMode === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = previousLaunchMode;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof previousWorkerCli === 'string')
+                process.env.OMX_TEAM_WORKER_CLI = previousWorkerCli;
+            else
+                delete process.env.OMX_TEAM_WORKER_CLI;
+            if (typeof previousReadyTimeout === 'string')
+                process.env.OMX_TEAM_READY_TIMEOUT_MS = previousReadyTimeout;
+            else
+                delete process.env.OMX_TEAM_READY_TIMEOUT_MS;
+            if (typeof previousStartupEvidenceTimeout === 'string')
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = previousStartupEvidenceTimeout;
+            else
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+            if (typeof previousStartupDispatchRetries === 'string')
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES = previousStartupDispatchRetries;
+            else
+                delete process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('settleStartupAttemptResults waits for sibling startup attempt to settle after worker startup throw', async () => {
+        let worker2Settled = false;
+        const startupAttemptResults = await settleStartupAttemptResults([
+            {
+                workerIndex: 1,
+                workerName: 'worker-1',
+                attempt: Promise.reject(new Error('test_startup_attempt_throw:worker-1')),
+            },
+            {
+                workerIndex: 2,
+                workerName: 'worker-2',
+                attempt: new Promise((resolve) => {
+                    setTimeout(() => {
+                        worker2Settled = true;
+                        resolve({ ok: true, workerIndex: 2, workerName: 'worker-2' });
+                    }, 100);
+                }),
+            },
+        ]);
+        assert.equal(worker2Settled, true, 'worker-2 startup attempt should settle before results return');
+        const firstStartupError = startupAttemptResults
+            .filter((result) => !result.ok)
+            .sort((a, b) => a.workerIndex - b.workerIndex)[0];
+        assert.equal(firstStartupError?.workerName, 'worker-1');
+        assert.match(String(firstStartupError?.error), /test_startup_attempt_throw:worker-1/);
+    });
     it('startTeam still fails startup when the worker pane is dead/unrecoverable', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-dead-startup-pane-'));
         const previousTmux = process.env.TMUX;
@@ -1651,6 +2094,78 @@ process.on('SIGTERM', () => process.exit(0));
             await rm(repo, { recursive: true, force: true });
         }
     });
+    it('startTeam runs worker MCP orphan cleanup before prompt worker spawn', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-prompt-mcp-cleanup-'));
+        const binDir = join(cwd, 'bin');
+        const fakeCodexPath = join(binDir, 'codex');
+        const capturePath = join(cwd, 'prompt-cleanup-order.jsonl');
+        await mkdir(binDir, { recursive: true });
+        await writeFakePromptWorkerBinary(fakeCodexPath, `const capturePath = process.env.OMX_PROMPT_CLEANUP_CAPTURE_PATH;
+if (capturePath) require('fs').appendFileSync(capturePath, 'spawn' + String.fromCharCode(10));
+setTimeout(() => {}, 5000);`);
+        const prevPath = process.env.PATH;
+        const prevTmux = process.env.TMUX;
+        const prevLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const prevWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        const prevLaunchArgs = process.env.OMX_TEAM_WORKER_LAUNCH_ARGS;
+        const prevCapture = process.env.OMX_PROMPT_CLEANUP_CAPTURE_PATH;
+        const prevAllowNonTty = process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT;
+        let runtime = null;
+        try {
+            process.env.PATH = `${binDir}:${prevPath ?? ''}`;
+            delete process.env.TMUX;
+            process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'prompt';
+            process.env.OMX_TEAM_WORKER_CLI = 'codex';
+            process.env.OMX_TEAM_WORKER_LAUNCH_ARGS = `--config ${JSON.stringify(`model_instructions_file=\"${join(cwd, 'AGENTS.md')}\"`)}`;
+            process.env.OMX_PROMPT_CLEANUP_CAPTURE_PATH = capturePath;
+            process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT = '1';
+            const started = await withoutTeamWorkerEnv(() => startTeam('team-prompt-cleanup', 'prompt cleanup before worker spawn', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd, {
+                cleanupLaunchOrphanedMcpProcesses: async () => {
+                    await writeFile(capturePath, 'cleanup\n', 'utf-8');
+                    return { dryRun: false, candidates: [], terminatedCount: 0, forceKilledCount: 0, failedPids: [] };
+                },
+            }));
+            runtime = started;
+            const order = await waitForFileText(capturePath, (content) => /spawn/.test(content));
+            assert.equal(order, 'cleanup\nspawn\n');
+            await shutdownTeam(runtime.teamName, cwd, { force: true });
+            runtime = null;
+        }
+        finally {
+            if (runtime) {
+                await shutdownTeam(runtime.teamName, cwd, { force: true }).catch(() => { });
+            }
+            if (typeof prevPath === 'string')
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            if (typeof prevTmux === 'string')
+                process.env.TMUX = prevTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof prevLaunchMode === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = prevLaunchMode;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof prevWorkerCli === 'string')
+                process.env.OMX_TEAM_WORKER_CLI = prevWorkerCli;
+            else
+                delete process.env.OMX_TEAM_WORKER_CLI;
+            if (typeof prevLaunchArgs === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_ARGS = prevLaunchArgs;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_ARGS;
+            if (typeof prevCapture === 'string')
+                process.env.OMX_PROMPT_CLEANUP_CAPTURE_PATH = prevCapture;
+            else
+                delete process.env.OMX_PROMPT_CLEANUP_CAPTURE_PATH;
+            if (typeof prevAllowNonTty === 'string')
+                process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT = prevAllowNonTty;
+            else
+                delete process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('startTeam launches gemini workers with startup prompt and no default model passthrough', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-gemini-'));
         const binDir = join(cwd, 'bin');
@@ -1801,11 +2316,13 @@ process.on('SIGTERM', () => process.exit(0));
         const prevLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
         const prevWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
         const prevCaptureDir = process.env.OMX_ARGV_CAPTURE_DIR;
+        const prevStandardModel = process.env.OMX_DEFAULT_STANDARD_MODEL;
         process.env.PATH = `${binDir}:${prevPath ?? ''}`;
         delete process.env.TMUX;
         process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'prompt';
         process.env.OMX_TEAM_WORKER_CLI = 'codex';
         process.env.OMX_ARGV_CAPTURE_DIR = captureDir;
+        delete process.env.OMX_DEFAULT_STANDARD_MODEL;
         let runtime = null;
         try {
             runtime = await withMockPromptModeCodexAllowed(() => withoutTeamWorkerEnv(() => startTeam('team-role-routing', 'heuristic routing handoff', 'executor', 2, [
@@ -1829,8 +2346,8 @@ process.on('SIGTERM', () => process.exit(0));
             assert.doesNotMatch(worker1Instructions, /exact gpt-5\.4-mini model/);
             assert.match(worker2Instructions, /You are operating as the \*\*writer\*\* role/);
             assert.match(worker2Instructions, /You are Writer\./);
-            assert.match(worker2Instructions, /exact gpt-5\.4-mini model/);
-            assert.match(worker2Instructions, /strict execution order: inspect -> plan -> act -> verify/);
+            assert.doesNotMatch(worker2Instructions, /exact gpt-5\.4-mini model/);
+            assert.match(worker2Instructions, /resolved_model: gpt-5\.5/);
             let worker1Args = null;
             let worker2Args = null;
             for (let attempt = 0; attempt < 50; attempt += 1) {
@@ -1852,7 +2369,7 @@ process.on('SIGTERM', () => process.exit(0));
             assert.match(worker1Joined, /--model gpt-5\.5/);
             assert.match(worker2Joined, /model_reasoning_effort="high"/);
             assert.match(worker2Joined, /model_instructions_file=.*worker-2\/AGENTS\.md/);
-            assert.match(worker2Joined, /--model gpt-5\.4-mini/);
+            assert.match(worker2Joined, /--model gpt-5\.5/);
             await shutdownTeam(runtime.teamName, cwd, { force: true });
             runtime = null;
         }
@@ -1880,6 +2397,10 @@ process.on('SIGTERM', () => process.exit(0));
                 process.env.OMX_ARGV_CAPTURE_DIR = prevCaptureDir;
             else
                 delete process.env.OMX_ARGV_CAPTURE_DIR;
+            if (typeof prevStandardModel === 'string')
+                process.env.OMX_DEFAULT_STANDARD_MODEL = prevStandardModel;
+            else
+                delete process.env.OMX_DEFAULT_STANDARD_MODEL;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -1909,11 +2430,13 @@ process.on('SIGTERM', () => process.exit(0));
         const prevWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
         const prevCaptureDir = process.env.OMX_ARGV_CAPTURE_DIR;
         const prevLaunchArgs = process.env.OMX_TEAM_WORKER_LAUNCH_ARGS;
+        const prevStandardModel = process.env.OMX_DEFAULT_STANDARD_MODEL;
         process.env.PATH = `${binDir}:${prevPath ?? ''}`;
         delete process.env.TMUX;
         process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'prompt';
         process.env.OMX_TEAM_WORKER_CLI = 'codex';
         process.env.OMX_ARGV_CAPTURE_DIR = captureDir;
+        delete process.env.OMX_DEFAULT_STANDARD_MODEL;
         process.env.OMX_TEAM_WORKER_LAUNCH_ARGS = '--model gpt-5.4-mini-tuned';
         let runtime = null;
         try {
@@ -1965,6 +2488,10 @@ process.on('SIGTERM', () => process.exit(0));
                 process.env.OMX_ARGV_CAPTURE_DIR = prevCaptureDir;
             else
                 delete process.env.OMX_ARGV_CAPTURE_DIR;
+            if (typeof prevStandardModel === 'string')
+                process.env.OMX_DEFAULT_STANDARD_MODEL = prevStandardModel;
+            else
+                delete process.env.OMX_DEFAULT_STANDARD_MODEL;
             if (typeof prevLaunchArgs === 'string')
                 process.env.OMX_TEAM_WORKER_LAUNCH_ARGS = prevLaunchArgs;
             else
@@ -4046,8 +4573,19 @@ esac
             config.workers[0].pid = sleeperPid;
             config.workers[0].pane_id = null;
             await writeFile(configPath, JSON.stringify(config, null, 2));
+            const manifestPath = join(cwd, '.omx', 'state', 'team', 'team-prompt-resume', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            manifest.policy.worker_launch_mode = 'prompt';
+            manifest.tmux_session = 'prompt-team-prompt-resume';
+            manifest.leader_pane_id = null;
+            manifest.hud_pane_id = null;
+            manifest.workers[0].pid = sleeperPid;
+            manifest.workers[0].pane_id = null;
+            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
             const runtime = await resumeTeam('team-prompt-resume', cwd);
             assert.equal(runtime, null);
+            const events = await readTeamEvents('team-prompt-resume', cwd);
+            assert.ok(events.some((event) => event.reason === `prompt_resume_unavailable:missing_handle:worker-1:${sleeperPid}`), 'resumeTeam should persist an explicit missing-handle diagnostic event');
         }
         finally {
             if (sleeperPid > 0) {
@@ -4148,6 +4686,119 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('startTeam persists synthesized delegation plans for broad tasks', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-'));
+        const binDir = join(cwd, 'bin');
+        const fakeCodexPath = join(binDir, 'codex');
+        await mkdir(binDir, { recursive: true });
+        await writeFakePromptWorkerBinary(fakeCodexPath, `setTimeout(() => {}, 5000);`);
+        let runtime = null;
+        try {
+            runtime = await withPromptModeCodexEnv(binDir, {}, () => withoutTeamWorkerEnv(() => startTeam('team-delegation-persist', 'delegation persistence test', 'executor', 1, [{ subject: 'Investigate runtime assignment', description: 'Search runtime and debug assignTask behavior' }], cwd)));
+            const task = await readTask('team-delegation-persist', '1', cwd);
+            assert.equal(task?.delegation?.mode, 'auto');
+            assert.equal(task?.delegation?.child_model, 'gpt-5.4-mini');
+            assert.equal(task?.delegation?.required_parallel_probe, true);
+        }
+        finally {
+            if (runtime) {
+                await shutdownTeam(runtime.teamName, cwd, { force: true }).catch(() => { });
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('startTeam remaps repo-aware DAG dependencies after concrete task IDs are created', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-'));
+        const binDir = join(cwd, 'bin');
+        const fakeCodexPath = join(binDir, 'codex');
+        await mkdir(binDir, { recursive: true });
+        await writeFakePromptWorkerBinary(fakeCodexPath, `setTimeout(() => {}, 5000);`);
+        let runtime = null;
+        try {
+            runtime = await withPromptModeCodexEnv(binDir, {}, () => withoutTeamWorkerEnv(() => startTeam('team-dag-remap', 'repo-aware DAG remap test', 'executor', 2, [
+                {
+                    subject: 'Implement runtime',
+                    description: 'Change runtime',
+                    owner: 'worker-1',
+                    role: 'executor',
+                    symbolic_id: 'impl',
+                    symbolic_depends_on: [],
+                    lane: 'implementation',
+                    filePaths: ['src/team/runtime.ts'],
+                    allocation_reason: 'balances current load',
+                },
+                {
+                    subject: 'Verify runtime',
+                    description: 'Test runtime',
+                    owner: 'worker-2',
+                    role: 'test-engineer',
+                    symbolic_id: 'verify',
+                    symbolic_depends_on: ['impl'],
+                    lane: 'verification',
+                    allocation_reason: 'keeps blocked work on a lighter lane',
+                },
+            ], cwd, {
+                decompositionMetadata: {
+                    decomposition_source: 'dag_sidecar',
+                    worker_count_requested: 2,
+                    worker_count_effective: 2,
+                    worker_count_source: 'plan-suggested',
+                    ready_lane_count: 1,
+                    useful_lane_count: 2,
+                    allocation_reasons: {
+                        impl: 'balances current load',
+                        verify: 'keeps blocked work on a lighter lane',
+                    },
+                    node_dependencies: {
+                        impl: [],
+                        verify: ['impl'],
+                    },
+                },
+            })));
+            const first = await readTask('team-dag-remap', '1', cwd);
+            const second = await readTask('team-dag-remap', '2', cwd);
+            assert.deepEqual(first?.depends_on, []);
+            assert.deepEqual(first?.blocked_by, undefined);
+            assert.deepEqual(second?.depends_on, ['1']);
+            assert.deepEqual(second?.blocked_by, ['1']);
+            const report = JSON.parse(await readFile(join(cwd, '.omx', 'state', 'team', 'team-dag-remap', 'decomposition-report.json'), 'utf-8'));
+            assert.deepEqual(report.node_id_to_task_id, { impl: '1', verify: '2' });
+            assert.deepEqual(report.task_hints?.['2']?.depends_on, ['1']);
+            assert.deepEqual(report.task_hints?.['2']?.symbolic_depends_on, ['impl']);
+            const inbox = await readFile(join(cwd, '.omx', 'state', 'team', 'team-dag-remap', 'workers', 'worker-2', 'inbox.md'), 'utf-8');
+            assert.match(inbox, /Blocked by: 1/);
+            assert.doesNotMatch(inbox, /Blocked by: impl/);
+            assert.doesNotMatch(inbox, /Depends on: impl/);
+        }
+        finally {
+            if (runtime) {
+                await shutdownTeam(runtime.teamName, cwd, { force: true }).catch(() => { });
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('assignTask synthesizes delegation before follow-up dispatch rollback', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-'));
+        try {
+            await initTeamState('team-assign-delegation', 'assignment delegation test', 'executor', 1, cwd);
+            const config = await readTeamConfig('team-assign-delegation', cwd);
+            assert.ok(config);
+            config.worker_launch_mode = 'prompt';
+            await saveTeamConfig(config, cwd);
+            const task = await createTask('team-assign-delegation', { subject: 'Investigate follow-up assignment', description: 'Search repo and debug follow-up assignment behavior', status: 'pending' }, cwd);
+            await writeWorkerInbox('team-assign-delegation', 'worker-1', 'existing inbox', cwd);
+            await assert.rejects(() => assignTask('team-assign-delegation', 'worker-1', task.id, cwd), /worker_notify_failed/);
+            const reread = await readTask('team-assign-delegation', task.id, cwd);
+            assert.equal(reread?.delegation?.mode, 'auto');
+            assert.equal(reread?.delegation?.child_model, 'gpt-5.4-mini');
+            const inbox = await readFile(join(cwd, '.omx', 'state', 'team', 'team-assign-delegation', 'workers', 'worker-1', 'inbox.md'), 'utf-8');
+            assert.match(inbox, /Assignment Cancelled/);
+            assert.match(inbox, /worker_notify_failed/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('monitorTeam does not re-notify already-notified mailbox messages (issue #116)', async () => {
         // Regression: deliverPendingMailboxMessages used to re-notify every 15 s via shouldRetry.
         // After the fix it must NOT re-notify messages that already have notified_at set.
@@ -4498,7 +5149,7 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('sendWorkerMessage transport_direct keeps leader-fixed request pending when leader_pane_id missing', async () => {
+    it('sendWorkerMessage transport_direct fails fast for leader-fixed when leader_pane_id missing', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-leader-direct-'));
         try {
             await initTeamState('team-leader-direct', 'leader direct transport test', 'executor', 1, cwd);
@@ -4512,14 +5163,23 @@ esac
             const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
             manifest.policy = { ...(manifest.policy || {}), dispatch_mode: 'transport_direct' };
             await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-            await sendWorkerMessage('team-leader-direct', 'worker-1', 'leader-fixed', 'hello leader direct', cwd);
+            await assert.rejects(sendWorkerMessage('team-leader-direct', 'worker-1', 'leader-fixed', 'hello leader direct', cwd), /mailbox_notify_failed:leader_pane_missing_transport_direct_failed/);
             const mailbox = await listMailboxMessages('team-leader-direct', 'leader-fixed', cwd);
             assert.ok(mailbox.length >= 1, `expected at least 1 mailbox message, got ${mailbox.length}`);
             const requests = await listDispatchRequests('team-leader-direct', cwd, { kind: 'mailbox', to_worker: 'leader-fixed' });
             assert.ok(requests.length >= 1, `expected at least 1 leader-fixed dispatch request, got ${requests.length}`);
             const latest = requests[requests.length - 1];
-            assert.equal(latest?.status, 'pending');
-            assert.equal(latest?.last_reason, 'leader_pane_missing_deferred');
+            assert.equal(latest?.status, 'failed');
+            assert.equal(latest?.last_reason, 'leader_pane_missing_transport_direct_failed');
+            assert.ok(latest?.failed_at, 'missing leader pane should fail fast with failed_at evidence');
+            const deliveryLog = await readTeamDeliveryLog(cwd);
+            const runtimeEntries = deliveryLog.filter((entry) => entry.event === 'dispatch_result'
+                && entry.source === 'team.runtime'
+                && entry.to_worker === 'leader-fixed'
+                && entry.transport === 'mailbox'
+                && entry.result === 'failed'
+                && entry.reason === 'leader_pane_missing_transport_direct_failed');
+            assert.equal(runtimeEntries.length, 1, 'leader direct missing-pane failure should emit exactly one runtime dispatch_result entry');
         }
         finally {
             await rm(cwd, { recursive: true, force: true });