oh-my-codex 0.15.0 → 0.15.2

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, cleanupTeamWorkerLaunchOrphanedMcpProcesses, } 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,31 @@ 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?.();
+    }
+}
+async function markPendingInboxDispatchesNotified(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 transitionDispatchRequest(teamName, request.request_id, 'pending', 'notified', { last_reason: opts.lastReason ?? 'test_notified_receipt' }, cwd).catch(() => { });
+    }
+}
 function withEmptyPath(fn) {
     const prev = process.env.PATH;
     process.env.PATH = '';
@@ -564,6 +589,161 @@ describe('runtime', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('uses a production startup evidence window that can tolerate slow Codex startup', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-startup-window-'));
+        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;
+        const prevStartupEvidenceTimeout = process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+        const prevStartupDispatchRetries = process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES;
+        const prevStartupDispatchRetryDelay = process.env.OMX_TEAM_STARTUP_DISPATCH_RETRY_DELAY_MS;
+        let receiptNotifier = null;
+        let progressWriter = null;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-startup-window-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
+      *"-F #{pane_id}"*"#{pane_current_command}"*)
+        printf "%%1\\tzsh\\tzsh\\n"
+        exit 0
+        ;;
+      *"#{pane_pid}"*)
+        echo "4321"
+        exit 0
+        ;;
+      *"#{pane_dead} #{pane_pid}"*)
+        echo "0 4321"
+        exit 0
+        ;;
+      *)
+        exit 0
+        ;;
+    esac
+    ;;
+  split-window)
+    case "$*" in
+      *" -h "*)
+        echo "%2"
+        ;;
+      *)
+        echo "%3"
+        ;;
+    esac
+    exit 0
+    ;;
+  capture-pane)
+    printf 'OpenAI Codex\\n> '
+    exit 0
+    ;;
+  send-keys|resize-pane|select-layout|set-window-option|select-pane|set-hook|run-shell|kill-pane|kill-session)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`,
+                binaries: [
+                    {
+                        name: 'codex',
+                        content: '#!/bin/sh\nsleep 30\n',
+                    },
+                ],
+            }, async () => {
+                process.env.TMUX = 'leader-session';
+                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';
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES = '1';
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRY_DELAY_MS = '50';
+                receiptNotifier = setInterval(() => {
+                    void markPendingInboxDispatchesNotified('team-startup-window', cwd, {
+                        toWorker: 'worker-1',
+                        lastReason: 'test_notified_receipt',
+                    }).catch(() => { });
+                }, 20);
+                progressWriter = setTimeout(() => {
+                    void writeWorkerStatus('team-startup-window', 'worker-1', {
+                        state: 'working',
+                        current_task_id: '1',
+                        updated_at: new Date().toISOString(),
+                    }, cwd).catch(() => { });
+                }, 6_000);
+                const runtime = await withoutTeamWorkerEnv(() => startTeam('team-startup-window', 'interactive startup should wait for slow Codex evidence', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd));
+                assert.equal(runtime.teamName, 'team-startup-window');
+                assert.ok(await readTeamConfig('team-startup-window', cwd));
+            });
+        }
+        finally {
+            if (receiptNotifier)
+                clearInterval(receiptNotifier);
+            if (progressWriter)
+                clearTimeout(progressWriter);
+            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;
+            if (typeof prevStartupEvidenceTimeout === 'string') {
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = prevStartupEvidenceTimeout;
+            }
+            else {
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+            }
+            if (typeof prevStartupDispatchRetries === 'string') {
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES = prevStartupDispatchRetries;
+            }
+            else {
+                delete process.env.OMX_TEAM_STARTUP_DISPATCH_RETRIES;
+            }
+            if (typeof prevStartupDispatchRetryDelay === 'string') {
+                process.env.OMX_TEAM_STARTUP_DISPATCH_RETRY_DELAY_MS = prevStartupDispatchRetryDelay;
+            }
+            else {
+                delete process.env.OMX_TEAM_STARTUP_DISPATCH_RETRY_DELAY_MS;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('startTeam rejects interactive startup when tmux fallback never produces worker startup evidence', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-startup-no-evidence-'));
         const prevTmux = process.env.TMUX;
@@ -809,10 +989,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 });
         }
     });
@@ -828,6 +1004,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 });
         }
     });
@@ -956,7 +1133,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');
@@ -967,7 +1144,6 @@ esac
                 if (teamNameForCleanup) {
                     await shutdownTeam(teamNameForCleanup, cwd, { force: true });
                 }
-                runtime = null;
             });
         }
         finally {
@@ -1274,11 +1450,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;
@@ -1288,6 +1464,148 @@ 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" ;;
+      *"#{pane_dead}"*) echo "0" ;;
+      *"-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;
@@ -1457,6 +1775,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;
@@ -4263,8 +4739,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) {
@@ -4365,6 +4852,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.
@@ -4715,7 +5315,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);
@@ -4729,14 +5329,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 });