oh-my-codex 0.12.4 → 0.12.6

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

@@ -6,10 +6,11 @@ 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, writeWorkerStatus, } from '../state.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 { resolveTeamLowComplexityDefaultModel } from '../model-contract.js';
 import { readTeamEvents } from '../state/events.js';
+import { sanitizeTeamName } from '../tmux-session.js';
 async function initRepo() {
     const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-worktree-repo-'));
     execFileSync('git', ['init'], { cwd, stdio: 'ignore' });
@@ -107,6 +108,29 @@ function withoutTeamWorkerEnv(fn) {
         }
     }
 }
+function withMockPromptModeCodexAllowed(fn) {
+    const previous = process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT;
+    process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT = '1';
+    let restoreImmediately = true;
+    const restore = () => {
+        if (typeof previous === 'string')
+            process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT = previous;
+        else
+            delete process.env.OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT;
+    };
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            restoreImmediately = false;
+            return result.finally(restore);
+        }
+        return result;
+    }
+    finally {
+        if (restoreImmediately)
+            restore();
+    }
+}
 async function waitForFileText(filePath, matcher, timeoutMs = 3_000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -150,6 +174,7 @@ async function withPromptModeCodexEnv(binDir, extraEnv, run) {
         TMUX: undefined,
         OMX_TEAM_WORKER_LAUNCH_MODE: 'prompt',
         OMX_TEAM_WORKER_CLI: 'codex',
+        OMX_TEST_ALLOW_NONTTY_CODEX_PROMPT: '1',
         ...extraEnv,
     };
     for (const [key, value] of Object.entries(nextEnv)) {
@@ -488,6 +513,159 @@ describe('runtime', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    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 {
+            await initTeamState('codex-blocked-startup', 'blocked startup evidence test', 'executor', 1, cwd);
+            await writeAtomic(join(cwd, '.omx', 'state', 'team', 'codex-blocked-startup', 'workers', 'worker-1', 'status.json'), JSON.stringify({
+                state: 'blocked',
+                reason: 'waiting on shared file',
+                updated_at: new Date().toISOString(),
+            }, null, 2));
+            const progress = await waitForWorkerStartupEvidence({
+                teamName: 'codex-blocked-startup',
+                workerName: 'worker-1',
+                workerCli: 'codex',
+                cwd,
+                timeoutMs: 25,
+                pollMs: 5,
+            });
+            assert.equal(progress, 'worker_progress');
+        }
+        finally {
+            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;
+        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 receiptFailer = null;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-startup-no-evidence-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 ({ tmuxLogPath }) => {
+                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';
+                receiptFailer = setInterval(() => {
+                    void (async () => {
+                        const requests = await listDispatchRequests('team-startup-no-evidence', cwd, { kind: 'inbox' }).catch(() => []);
+                        for (const request of requests) {
+                            if (request.status !== 'pending')
+                                continue;
+                            await transitionDispatchRequest('team-startup-no-evidence', request.request_id, 'pending', 'failed', { last_reason: 'test_failed_receipt' }, cwd).catch(() => { });
+                        }
+                    })();
+                }, 20);
+                await assert.rejects(() => withoutTeamWorkerEnv(() => startTeam('team-startup-no-evidence', 'interactive startup must observe worker evidence', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd)), /worker_notify_failed/);
+                if (receiptFailer) {
+                    clearInterval(receiptFailer);
+                    receiptFailer = null;
+                }
+                assert.equal(await readTeamConfig('team-startup-no-evidence', cwd), null);
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.match(tmuxLog, /send-keys -t %2 -l --/);
+            });
+        }
+        finally {
+            if (receiptFailer)
+                clearInterval(receiptFailer);
+            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('resolveWorkerLaunchArgsFromEnv logs source=none/default-none when thinking is not explicit', () => {
         const logs = [];
         const originalLog = console.log;
@@ -860,6 +1038,14 @@ case "\${1:-}" in
   split-window)
     case "$*" in
       *" -h "*)
+        mkdir -p "${cwd}/.omx/state/team/team-pane-pid/workers/worker-1"
+        cat > "${cwd}/.omx/state/team/team-pane-pid/workers/worker-1/status.json" <<'EOF'
+{
+  "state": "working",
+  "current_task_id": "1",
+  "updated_at": "2026-04-10T00:00:00.000Z"
+}
+EOF
         echo "%2"
         ;;
       *)
@@ -922,15 +1108,409 @@ esac
     });
     it('startTeam saves interactive pane ids before readiness waits in source order', async () => {
         const source = await readFile(join(process.cwd(), 'src', 'team', 'runtime.ts'), 'utf-8');
-        const applyIndex = source.indexOf('applyCreatedInteractiveSessionToConfig(config, createdSession, workerPaneIds);');
-        const saveIndex = source.indexOf('await saveTeamConfig(config, leaderCwd);', applyIndex);
-        const readyIndex = source.indexOf('const ready = waitForWorkerReady(sessionName, i, workerReadyTimeoutMs, paneId);', saveIndex);
-        assert.notEqual(applyIndex, -1);
-        assert.notEqual(saveIndex, -1);
-        assert.notEqual(readyIndex, -1);
+        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 applyIndex = applyMatch?.index ?? -1;
+        const saveIndex = saveMatch?.index ?? -1;
+        const readyIndex = readyMatch?.index ?? -1;
+        assert.notEqual(applyMatch, null);
+        assert.notEqual(saveMatch, null);
+        assert.notEqual(readyMatch, null);
         assert.equal(applyIndex < saveIndex, true);
         assert.equal(saveIndex < readyIndex, 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;
+        const previousTmuxPane = process.env.TMUX_PANE;
+        const previousLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        const previousSkipReadyWait = process.env.OMX_TEAM_SKIP_READY_WAIT;
+        const previousStartupEvidenceTimeout = process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+        let runtime = null;
+        const teamName = 'team-no-startup-evidence';
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-no-startup-evidence-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_dead}"*)
+        echo "0"
+        ;;
+      *"#{pane_dead} #{pane_pid}"*)
+        echo "0 4242"
+        ;;
+      *"pane_current_command"*)
+        printf "%%1\\tnode\\t'codex'\\n"
+        ;;
+      *"#{pane_pid}"*)
+        echo "4242"
+        ;;
+      *)
+        exit 0
+        ;;
+    esac
+    exit 0
+    ;;
+  capture-pane)
+    exit 0
+    ;;
+  split-window)
+    case "$*" in
+      *" -h "*)
+        echo "%2"
+        ;;
+      *)
+        echo "%3"
+        ;;
+    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
+process.stdin.resume();
+setTimeout(() => process.exit(0), 30000);
+process.on('SIGTERM', () => process.exit(0));
+`,
+                    },
+                ],
+            }, 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_SKIP_READY_WAIT = '1';
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = '500';
+                runtime = await withoutTeamWorkerEnv(() => startTeam(teamName, 'interactive startup should keep evaluating per-worker startup issues while panes stay alive', 'executor', 2, [
+                    { subject: 'worker-1 task', description: 'd', owner: 'worker-1' },
+                    { subject: 'worker-2 task', description: 'd', owner: 'worker-2' },
+                ], cwd));
+                const worker1Status = await readWorkerStatus(teamName, 'worker-1', cwd);
+                const worker2Status = await readWorkerStatus(teamName, 'worker-2', cwd);
+                assert.equal(worker1Status.state, 'unknown');
+                assert.equal(worker2Status.state, 'unknown');
+                assert.match(worker1Status.reason ?? '', /startup_no_evidence|fallback_attempted_but_unconfirmed/);
+                assert.match(worker2Status.reason ?? '', /startup_no_evidence|fallback_attempted_but_unconfirmed/);
+                const task1 = await readTask(teamName, '1', cwd);
+                const task2 = await readTask(teamName, '2', cwd);
+                assert.equal(task1?.status, 'pending');
+                assert.equal(task2?.status, 'pending');
+            });
+        }
+        finally {
+            if (runtime) {
+                await shutdownTeam(teamName, 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 previousSkipReadyWait === 'string')
+                process.env.OMX_TEAM_SKIP_READY_WAIT = previousSkipReadyWait;
+            else
+                delete process.env.OMX_TEAM_SKIP_READY_WAIT;
+            if (typeof previousStartupEvidenceTimeout === 'string') {
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = previousStartupEvidenceTimeout;
+            }
+            else {
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    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;
+        const previousTmuxPane = process.env.TMUX_PANE;
+        const previousLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        const previousStartupEvidenceTimeout = process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-dead-startup-pane-bin-',
+                tmuxScript: () => `#!/bin/sh
+set -eu
+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 4242"
+        ;;
+      *"#{pane_pid}"*)
+        echo "4242"
+        ;;
+      *)
+        exit 0
+        ;;
+    esac
+    exit 0
+    ;;
+  capture-pane)
+    exit 0
+    ;;
+  split-window)
+    case "$*" in
+      *" -h "*) echo "%2" ;;
+      *) echo "%3" ;;
+    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_STARTUP_EVIDENCE_TIMEOUT_MS = '500';
+                await assert.rejects(() => withoutTeamWorkerEnv(() => startTeam('team-dead-startup-pane', 'dead pane should still fail startup', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd)), /Worker worker-1 did not become ready/);
+            });
+        }
+        finally {
+            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 previousStartupEvidenceTimeout === 'string') {
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = previousStartupEvidenceTimeout;
+            }
+            else {
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('startTeam materializes all worker identity/inbox files before worker-1 startup evidence can block later workers', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-materialize-before-evidence-'));
+        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 previousSkipReadyWait = process.env.OMX_TEAM_SKIP_READY_WAIT;
+        const previousStartupEvidenceTimeout = process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+        try {
+            await withMockTmuxFixture({
+                dirPrefix: 'omx-runtime-materialize-before-evidence-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_dead} #{pane_pid}"*)
+        echo "0 4242"
+        ;;
+      *"pane_current_command"*)
+        printf "%%1\\tnode\\t'codex'\\n"
+        ;;
+      *"-t %2"*"#{pane_pid}"*)
+        echo "4242"
+        ;;
+      *"-t %3"*"#{pane_pid}"*)
+        echo "4343"
+        ;;
+      *"-t %4"*"#{pane_pid}"*)
+        echo "4444"
+        ;;
+      *"#{pane_pid}"*)
+        echo "4141"
+        ;;
+      *)
+        exit 0
+        ;;
+    esac
+    exit 0
+    ;;
+  capture-pane)
+    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" ;;
+      3) echo "%4" ;;
+      *) echo "%5" ;;
+    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
+process.stdin.resume();
+setTimeout(() => process.exit(0), 30000);
+process.on('SIGTERM', () => process.exit(0));
+`,
+                    },
+                ],
+            }, async () => {
+                const sanitizedTeamName = sanitizeTeamName('team-materialize-before-evidence');
+                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';
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = '500';
+                const teamPromise = withoutTeamWorkerEnv(() => startTeam('team-materialize-before-evidence', 'later workers should materialize before startup evidence failure', 'executor', 2, [
+                    { subject: 'w1', description: 'worker one', owner: 'worker-1' },
+                    { subject: 'w2', description: 'worker two', owner: 'worker-2' },
+                ], cwd));
+                const observedTeamPromise = teamPromise.then((runtime) => ({ ok: true, runtime }), (error) => ({ ok: false, error }));
+                const workerOneIdentity = join(cwd, '.omx', 'state', 'team', sanitizedTeamName, 'workers', 'worker-1', 'identity.json');
+                const workerTwoIdentity = join(cwd, '.omx', 'state', 'team', sanitizedTeamName, 'workers', 'worker-2', 'identity.json');
+                const workerTwoInbox = join(cwd, '.omx', 'state', 'team', sanitizedTeamName, 'workers', 'worker-2', 'inbox.md');
+                let materializedAllWorkers = false;
+                for (let attempt = 0; attempt < 450; attempt += 1) {
+                    if (existsSync(workerOneIdentity)
+                        && existsSync(workerTwoIdentity)
+                        && existsSync(workerTwoInbox)) {
+                        materializedAllWorkers = true;
+                        break;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                }
+                assert.equal(materializedAllWorkers, true, 'worker-2 durable state should exist before worker-1 startup evidence failure rejects launch');
+                const outcome = await observedTeamPromise;
+                assert.equal(outcome.ok, false);
+                assert.match(String(outcome.error), /worker_notify_failed:worker-1/);
+                assert.equal(existsSync(join(cwd, '.omx', 'state', 'team', sanitizedTeamName)), false);
+            });
+        }
+        finally {
+            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 previousSkipReadyWait === 'string')
+                process.env.OMX_TEAM_SKIP_READY_WAIT = previousSkipReadyWait;
+            else
+                delete process.env.OMX_TEAM_SKIP_READY_WAIT;
+            if (typeof previousStartupEvidenceTimeout === 'string') {
+                process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS = previousStartupEvidenceTimeout;
+            }
+            else {
+                delete process.env.OMX_TEAM_STARTUP_EVIDENCE_TIMEOUT_MS;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('startTeam rejects dirty leader workspace before provisioning worker worktrees', async () => {
         const repo = await initRepo();
         const prevLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
@@ -982,8 +1562,6 @@ sleep 5
             assert.equal(runtime.config.worker_launch_mode, 'prompt');
             assert.equal((runtime.config.workers[0]?.pid ?? 0) > 0, true);
             const expectedArgv = [
-                '--approval-mode',
-                'yolo',
                 '-i',
                 'Read .omx/state/team/team-gemini-prompt/workers/worker-1/inbox.md, start work now, report concrete progress, then continue assigned work or next feasible task.',
             ];
@@ -1034,59 +1612,29 @@ sleep 5
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('startTeam preserves explicit codex launch args while forcing bypass in prompt mode', async () => {
+    it('startTeam rejects codex prompt mode even when explicit launch args are provided', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-codex-explicit-launch-'));
         const binDir = join(cwd, 'bin');
         const fakeCodexPath = join(binDir, 'codex');
-        const capturePath = join(cwd, 'codex-argv.json');
         await mkdir(binDir, { recursive: true });
         await writeFile(fakeCodexPath, `#!/usr/bin/env node
-const fs = require('fs');
-fs.writeFileSync(process.env.OMX_CODEX_ARGV_CAPTURE_PATH, JSON.stringify(process.argv.slice(2), null, 2));
-process.stdin.resume();
-setTimeout(() => process.exit(0), 5000);
-process.on('SIGTERM', () => process.exit(0));
+process.exit(0);
 `, { mode: 0o755 });
         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_CODEX_ARGV_CAPTURE_PATH;
         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 = '--model gpt-5.3-codex-spark -c model_reasoning_effort="low"';
-        process.env.OMX_CODEX_ARGV_CAPTURE_PATH = capturePath;
-        let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-codex-explicit-launch', 'codex prompt-mode team bootstrap', 'explore', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd));
-            assert.equal(runtime.config.worker_launch_mode, 'prompt');
-            assert.equal((runtime.config.workers[0]?.pid ?? 0) > 0, true);
-            let argv = null;
-            for (let attempt = 0; attempt < 50; attempt += 1) {
-                if (existsSync(capturePath)) {
-                    argv = JSON.parse(await readFile(capturePath, 'utf-8'));
-                    break;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            }
-            assert.ok(argv, 'codex argv capture file should be written');
-            assert.equal(argv.includes('--dangerously-bypass-approvals-and-sandbox'), true);
-            assert.equal(argv.filter((arg) => arg === '--dangerously-bypass-approvals-and-sandbox').length, 1);
-            assert.equal(argv.includes('--model'), true);
-            assert.equal(argv[argv.indexOf('--model') + 1], 'gpt-5.3-codex-spark');
-            assert.equal(argv.includes('-c'), true);
-            assert.equal(argv.includes('model_reasoning_effort="low"'), true);
-            assert.equal(argv.some((arg) => arg.includes('model_instructions_file=')), true);
-            await shutdownTeam(runtime.teamName, cwd, { force: true });
-            runtime = null;
+            await assert.rejects(() => withoutTeamWorkerEnv(() => startTeam('team-codex-explicit-launch', 'codex prompt-mode team bootstrap', 'explore', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd)), /prompt_mode_codex_requires_tty/);
+            assert.equal(existsSync(join(cwd, '.omx', 'state', 'team', 'team-codex-explicit-launch')), false);
         }
         finally {
-            if (runtime) {
-                await shutdownTeam(runtime.teamName, cwd, { force: true }).catch(() => { });
-            }
             if (typeof prevPath === 'string')
                 process.env.PATH = prevPath;
             else
@@ -1107,10 +1655,6 @@ process.on('SIGTERM', () => process.exit(0));
                 process.env.OMX_TEAM_WORKER_LAUNCH_ARGS = prevLaunchArgs;
             else
                 delete process.env.OMX_TEAM_WORKER_LAUNCH_ARGS;
-            if (typeof prevCapture === 'string')
-                process.env.OMX_CODEX_ARGV_CAPTURE_PATH = prevCapture;
-            else
-                delete process.env.OMX_CODEX_ARGV_CAPTURE_PATH;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -1147,10 +1691,10 @@ process.on('SIGTERM', () => process.exit(0));
         process.env.OMX_ARGV_CAPTURE_DIR = captureDir;
         let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-role-routing', 'heuristic routing handoff', 'executor', 2, [
+            runtime = await withMockPromptModeCodexAllowed(() => withoutTeamWorkerEnv(() => startTeam('team-role-routing', 'heuristic routing handoff', 'executor', 2, [
                 { subject: 'test routing report only', description: 'test routing report only', owner: 'worker-1', role: 'test-engineer' },
                 { subject: 'document routing report only', description: 'document routing report only', owner: 'worker-2', role: 'writer' },
-            ], cwd));
+            ], cwd)));
             assert.equal(runtime.config.worker_launch_mode, 'prompt');
             assert.equal(runtime.config.workers[0]?.role, 'test-engineer');
             assert.equal(runtime.config.workers[1]?.role, 'writer');
@@ -1256,9 +1800,9 @@ process.on('SIGTERM', () => process.exit(0));
         process.env.OMX_TEAM_WORKER_LAUNCH_ARGS = '--model gpt-5.4-mini-tuned';
         let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-mini-tuned-routing', 'mini tuned routing handoff', 'executor', 1, [
+            runtime = await withMockPromptModeCodexAllowed(() => withoutTeamWorkerEnv(() => startTeam('team-mini-tuned-routing', 'mini tuned routing handoff', 'executor', 1, [
                 { subject: 'document routing report only', description: 'document routing report only', owner: 'worker-1', role: 'writer' },
-            ], cwd));
+            ], cwd)));
             const workerInstructions = await readFile(join(cwd, '.omx', 'state', 'team', runtime.teamName, 'workers', 'worker-1', 'AGENTS.md'), 'utf-8');
             assert.match(workerInstructions, /You are operating as the \*\*writer\*\* role/);
             assert.match(workerInstructions, /You are Writer\./);
@@ -1311,7 +1855,7 @@ process.on('SIGTERM', () => process.exit(0));
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('startTeam supports prompt launch mode without tmux and pipes trigger text via stdin', async () => {
+    it('startTeam rejects codex prompt mode without tmux with an explicit non-tty error', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-prompt-'));
         const binDir = join(cwd, 'bin');
         const fakeCodexPath = join(binDir, 'codex');
@@ -1329,19 +1873,11 @@ process.on('SIGTERM', () => process.exit(0));
         delete process.env.TMUX;
         process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'prompt';
         process.env.OMX_TEAM_WORKER_CLI = 'codex';
-        let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-prompt', 'prompt-mode team bootstrap', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd));
-            assert.equal(runtime.config.worker_launch_mode, 'prompt');
-            assert.equal(runtime.config.leader_pane_id, null);
-            assert.equal((runtime.config.workers[0]?.pid ?? 0) > 0, true);
-            await shutdownTeam(runtime.teamName, cwd, { force: true });
-            runtime = null;
+            await assert.rejects(() => withoutTeamWorkerEnv(() => startTeam('team-prompt', 'prompt-mode team bootstrap', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd)), /prompt_mode_codex_requires_tty/);
+            assert.equal(existsSync(join(cwd, '.omx', 'state', 'team', 'team-prompt')), false);
         }
         finally {
-            if (runtime) {
-                await shutdownTeam(runtime.teamName, cwd, { force: true }).catch(() => { });
-            }
             if (typeof prevPath === 'string')
                 process.env.PATH = prevPath;
             else
@@ -1520,7 +2056,7 @@ process.on('SIGTERM', () => process.exit(0));
         process.env.OMX_TEST_LOG_DIR = logDir;
         let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-detached-worktree-paths', 'detached worktree path resolution', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], repo, { worktreeMode: { enabled: true, detached: true, name: null } }));
+            runtime = await withMockPromptModeCodexAllowed(() => withoutTeamWorkerEnv(() => startTeam('team-detached-worktree-paths', 'detached worktree path resolution', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], repo, { worktreeMode: { enabled: true, detached: true, name: null } })));
             const workerPath = runtime.config.workers[0]?.worktree_path;
             assert.ok(workerPath, 'detached worker should have a worktree path');
             assert.notEqual(workerPath, repo);
@@ -1592,7 +2128,7 @@ process.on('SIGTERM', () => process.exit(0));
         process.env.OMX_TEAM_WORKER_CLI = 'codex';
         let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-detached-worktree-shutdown', 'detached worktree shutdown cleanup', 'executor', 1, [], repo, { worktreeMode: { enabled: true, detached: true, name: null } }));
+            runtime = await withMockPromptModeCodexAllowed(() => withoutTeamWorkerEnv(() => startTeam('team-detached-worktree-shutdown', 'detached worktree shutdown cleanup', 'executor', 1, [], repo, { worktreeMode: { enabled: true, detached: true, name: null } })));
             const worktreePath = runtime.config.workers[0]?.worktree_path;
             assert.ok(worktreePath, 'worker worktree path should be persisted');
             assert.equal(runtime.config.workers[0]?.worktree_created, true);
@@ -1659,7 +2195,7 @@ process.on('SIGTERM', () => process.exit(0));
         process.env.OMX_TEST_LOG_DIR = logDir;
         let runtime = null;
         try {
-            runtime = await withoutTeamWorkerEnv(() => startTeam('team-detached-worktree-resume-metadata', 'detached worktree resume metadata', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], repo, { worktreeMode: { enabled: true, detached: true, name: null } }));
+            runtime = await withMockPromptModeCodexAllowed(() => withoutTeamWorkerEnv(() => startTeam('team-detached-worktree-resume-metadata', 'detached worktree resume metadata', 'executor', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], repo, { worktreeMode: { enabled: true, detached: true, name: null } })));
             const originalWorker = runtime.config.workers[0];
             const originalWorktreePath = originalWorker?.worktree_path;
             assert.ok(originalWorktreePath, 'worker worktree path should be persisted before resume');
@@ -3101,6 +3637,78 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('shutdownTeam reconciles stale leader and hud pane ids before native Windows split-pane teardown', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-shutdown-win32-stale-topology-'));
+        const teamName = 'team-win32-stale-topo';
+        try {
+            await withNativeWindowsPlatform(async () => {
+                await withMockTmuxFixture({
+                    dirPrefix: 'omx-runtime-shutdown-win32-stale-topology-bin-',
+                    tmuxScript: (tmuxLogPath) => `#!/bin/sh
+set -eu
+printf '%s\\n' "$*" >> "${tmuxLogPath}"
+case "$1" in
+  -V)
+    echo "tmux 3.4"
+    exit 0
+    ;;
+  list-panes)
+    case "$*" in
+      *"-F #{pane_dead} #{pane_pid}"*)
+        exit 1
+        ;;
+      *"-t leader:0 -F #{pane_id}"*"#{pane_current_command}"*)
+        printf "%%21\\tpwsh\\tpwsh\\n%%22\\tnode\\tnode /tmp/bin/omx.js hud --watch\\n%%23\\tcodex\\tcodex\\n%%24\\tcodex\\tcodex\\n"
+        exit 0
+        ;;
+      *)
+        exit 1
+        ;;
+    esac
+    ;;
+  split-window)
+    printf '%%44\\n'
+    exit 0
+    ;;
+  kill-pane|resize-pane|select-pane)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`,
+                }, async ({ tmuxLogPath }) => {
+                    await initTeamState(teamName, 'shutdown win32 stale topology test', 'executor', 2, cwd);
+                    const config = await readTeamConfig(teamName, cwd);
+                    assert.ok(config);
+                    if (!config)
+                        return;
+                    config.tmux_session = 'leader:0';
+                    config.leader_pane_id = '%11';
+                    config.hud_pane_id = '%12';
+                    config.workers[0].pane_id = '%23';
+                    config.workers[1].pane_id = '%24';
+                    await saveTeamConfig(config, cwd);
+                    await shutdownTeam(teamName, cwd, { force: true });
+                    const teamRoot = join(cwd, '.omx', 'state', 'team', teamName);
+                    assert.equal(existsSync(teamRoot), false);
+                    assert.equal(await readMonitorSnapshot(teamName, cwd), null);
+                    const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                    assert.doesNotMatch(tmuxLog, /list-panes -t %21 -F #\{pane_pid\}/);
+                    assert.doesNotMatch(tmuxLog, /kill-pane -t %21/);
+                    assert.match(tmuxLog, /kill-pane -t %22/);
+                    assert.match(tmuxLog, /kill-pane -t %23/);
+                    assert.match(tmuxLog, /kill-pane -t %24/);
+                    assert.match(tmuxLog, new RegExp(`split-window -v -l ${HUD_TMUX_TEAM_HEIGHT_LINES} -t %21 -d -P -F #\\{pane_id\\}`));
+                    assert.match(tmuxLog, /select-pane -t %21/);
+                });
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('shutdownTeam skips prekill and keeps the leader pane alive on shared-session shutdown', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-shutdown-shared-session-'));
         try {