oh-my-codex 0.20.2 → 0.20.5

package/dist/cli/__tests__/launch-fallback.test.js

@@ -1,14 +1,17 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync } from 'node:fs';
-import { chmod, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
-import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmod, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { execFileSync, spawn, spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { HUD_TMUX_HEIGHT_LINES } from '../../hud/constants.js';
-import { DETACHED_TMUX_HISTORY_LIMIT } from '../index.js';
+import { HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_HEIGHT_LINES } from '../../hud/constants.js';
+import { DETACHED_LAUNCH_CONTROL_PLANE_KEYS, DETACHED_TMUX_HISTORY_LIMIT, buildMadmaxDetachedLaunchContextKey } from '../index.js';
+import { closeLaunchSessionBindingOnce, establishLaunchSessionBinding, finalizeBoundOnce, writeSessionStart, } from '../../hooks/session.js';
+import { buildPtyScriptCommand, isRealScriptAvailable, isRealTmuxAvailable, withTempTmuxSession } from '../../team/__tests__/tmux-test-fixture.js';
 const CLI_SPAWN_TIMEOUT_MS = 60_000;
+const DARWIN_PTY_FINALIZATION_POLL_LIMIT = 600;
 function buildRunOmxEnv(envOverrides) {
     const env = { ...process.env };
     for (const key of Object.keys(env)) {
@@ -50,8 +53,10 @@ function normalizeDarwinTmpPath(value) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function shouldSkipForSpawnPermissions(err) {
-    return typeof err === 'string' && /(EPERM|EACCES)/i.test(err);
+function shouldSkipForSpawnPermissions(_err) {
+    // These integration fixtures are contractual: EPERM/EACCES is a failure,
+    // not a pass. Node's test runner has no portable dynamic skip here.
+    return false;
 }
 async function createGitRepo(wd) {
     const repo = join(wd, 'repo');
@@ -68,17 +73,167 @@ async function writeExecutable(path, content) {
     await writeFile(path, content);
     await chmod(path, 0o755);
 }
+async function wrapFakeTmuxWithDetachedLeader(fakeTmuxPath) {
+    const implementationPath = `${fakeTmuxPath}.impl`;
+    await rename(fakeTmuxPath, implementationPath);
+    await writeExecutable(fakeTmuxPath, `#!/bin/sh
+if [ "$1" = "display-message" ] && [ "$2" = "-p" ] && [ "$3" = "-t" ] && case "$5" in *'#{session_created}'*'#{window_id}'*'#{pane_pid}'*) true;; *) false;; esac; then
+  session=$(cat /tmp/omx-test-detached-session-name 2>/dev/null || printf omx-test)
+  leader_pid=$(cat "$0.detached-leader-pid" 2>/dev/null || printf 123)
+  printf '%s\t$1\t1\t0\t@1\t%s\t%s\n' "$session" "$4" "$leader_pid"
+  exit 0
+fi
+if [ "$1" = "set-option" ] && [ "$2" = "-t" ] && [ "$4" = "@omx_instance_id" ]; then
+  printf '%s' "$5" > /tmp/omx-test-detached-owner-id
+fi
+if [ "$1" = "list-panes" ] && case "$*" in *'#{session_created}'*'#{@omx_instance_id}'*) true;; *) false;; esac; then
+  ${JSON.stringify(implementationPath)} "$@" >/dev/null 2>&1 || true
+  session=$(cat /tmp/omx-test-detached-session-name 2>/dev/null || printf omx-test)
+  owner=$(cat /tmp/omx-test-detached-owner-id 2>/dev/null || printf '')
+  leader_pid=$(cat "$0.detached-leader-pid" 2>/dev/null || printf 123)
+  pane=$(cat "$0.detached-leader-pane" 2>/dev/null || printf '%%12')
+  printf '%s\t0\t%s\t%s\t$1\t1\t%s\n' "$pane" "$leader_pid" "$session" "$owner"
+  exit 0
+fi
+if [ "$1" = "if-shell" ] && [ "$2" = "-F" ] && [ "$3" = "-t" ]; then
+  if [ -f "$0.detached-recycled" ] && [ "$4" = "%99" ]; then ${JSON.stringify(implementationPath)} __nested_hud_guard_denied__ %99 999 '$2' @2; exit 0; fi
+  ${JSON.stringify(implementationPath)} "$@" >/dev/null 2>&1 || true
+  success="$6"
+  receipt=$(printf '%s' "$success" | sed -n 's/.*\\(omx_detached_[A-Za-z0-9-]*\\).*/\\1/p')
+  case "\${OMX_TEST_DETACHED_RECYCLE:-}" in
+    split) case "$success" in *split-window*) exit 0;; esac ;;
+    finalization) case "$*" in
+      *split-window*) : > "$0.detached-split-seen" ;;
+      *"if-shell -F -t '%99'"*) if [ -f "$0.detached-split-seen" ]; then
+        ${JSON.stringify(implementationPath)} __recycled__ %99 999 '$2' @2
+        : > "$0.detached-recycled"
+        eval "set -- $success"
+        "$0" "$@" >/dev/null
+      fi ;;
+    esac ;;
+  esac
+  [ -n "$receipt" ] || exit 1
+  case "$success" in
+    *split-window*) printf '%%99\t456\t$1\t@1\t%s\n' "$receipt" ;;
+    *) printf '%s\n' "$receipt" ;;
+  esac
+  exit 0
+fi
+if [ "$1" = "list-panes" ] && case "$*" in *'#{pane_id}'*'#{pane_dead}'*'#{pane_pid}'*) true;; *) false;; esac; then
+  leader_pid=$(cat "$0.detached-leader-pid" 2>/dev/null || printf '')
+  [ -n "$leader_pid" ] || exit 1
+  pane=$(cat "$0.detached-leader-pane" 2>/dev/null || printf '%%12')
+  printf '%s\t0\t%s\n' "$pane" "$leader_pid"
+  exit 0
+fi
+output=$(${JSON.stringify(implementationPath)} "$@")
+status=$?
+printf '%s' "$output"
+if [ "$status" -eq 0 ] && [ "$1" = "new-session" ]; then
+  previous=''
+  for arg in "$@"; do
+    if [ "$previous" = '-s' ]; then printf '%s' "$arg" > /tmp/omx-test-detached-session-name; break; fi
+    previous="$arg"
+  done
+  for last_arg do :; done
+  pane=$(printf '%s' "$output" | sed -n '1p')
+  TMUX=/tmp/omx-test-tmux,1,0 TMUX_PANE="$pane" nohup /bin/sh -c 'eval "exec $1"' sh "$last_arg" </dev/null >/tmp/omx-test-detached-leader.log 2>&1 &
+  leader_pid=$!
+  printf '%s' "$leader_pid" > "$0.detached-leader-pid"
+  printf '%s' "$pane" > "$0.detached-leader-pane"
+  (while kill -0 "$leader_pid" 2>/dev/null; do sleep 0.02; done; printf done > ${JSON.stringify(`${fakeTmuxPath}.leader-done`)}) </dev/null >/dev/null 2>&1 &
+fi
+exit "$status"
+`);
+}
 async function createLaunchFixture(wd, tmuxScript) {
     const home = join(wd, 'home');
     const fakeBin = join(wd, 'bin');
     const tmuxLogPath = join(wd, 'tmux.log');
+    const leaderDonePath = join(wd, 'leader-done');
     await mkdir(home, { recursive: true });
     await mkdir(fakeBin, { recursive: true });
-    await writeExecutable(join(fakeBin, 'codex'), '#!/bin/sh\nprintf \'fake-codex:%s\\n\' "$*"\n');
+    await writeExecutable(join(fakeBin, 'codex'), '#!/bin/sh\nprintf \'fake-codex:%s\\n\' "$*"\nsleep 1\n');
     await writeExecutable(join(fakeBin, 'ps'), '#!/bin/sh\nexit 0\n');
-    await writeExecutable(join(fakeBin, 'tmux'), tmuxScript(tmuxLogPath));
+    const tmuxImpl = join(fakeBin, 'tmux-impl');
+    await writeExecutable(tmuxImpl, tmuxScript(tmuxLogPath));
+    await writeExecutable(join(fakeBin, 'tmux'), `#!/bin/sh
+if [ "$1" = "display-message" ] && [ "$2" = "-p" ] && [ "$3" = "-t" ] && case "$5" in *'#{session_created}'*'#{window_id}'*'#{pane_pid}'*) true;; *) false;; esac; then
+  session=$(cat /tmp/omx-test-detached-session-name 2>/dev/null || printf omx-test)
+  leader_pid=$(cat "$0.detached-leader-pid" 2>/dev/null || printf 123)
+  printf '%s\t$1\t1\t0\t@1\t%s\t%s\n' "$session" "$4" "$leader_pid"
+  exit 0
+fi
+if [ "$1" = "set-option" ] && [ "$2" = "-t" ] && [ "$4" = "@omx_instance_id" ]; then
+  printf '%s' "$5" > /tmp/omx-test-detached-owner-id
+fi
+if [ "$1" = "list-panes" ] && case "$*" in *'#{session_created}'*'#{@omx_instance_id}'*) true;; *) false;; esac; then
+  ${JSON.stringify(tmuxImpl)} "$@" >/dev/null 2>&1 || true
+  session=$(cat /tmp/omx-test-detached-session-name 2>/dev/null || printf omx-test)
+  owner=$(cat /tmp/omx-test-detached-owner-id 2>/dev/null || printf '')
+  leader_pid=$(cat "$0.detached-leader-pid" 2>/dev/null || printf 123)
+  pane=$(cat "$0.detached-leader-pane" 2>/dev/null || printf '%%12')
+  printf '%s\t0\t%s\t%s\t$1\t1\t%s\n' "$pane" "$leader_pid" "$session" "$owner"
+  exit 0
+fi
+if [ "$1" = "list-panes" ] && case "$*" in *'#{pane_id}'*'#{pane_dead}'*'#{pane_pid}'*) true;; *) false;; esac; then
+  leader_pid=$(cat "$0.detached-leader-pid" 2>/dev/null || printf '')
+  [ -n "$leader_pid" ] || exit 1
+  pane=$(cat "$0.detached-leader-pane" 2>/dev/null || printf '%%12')
+  printf '%s\t0\t%s\n' "$pane" "$leader_pid"
+  exit 0
+fi
+if [ "$1" = "if-shell" ] && [ "$2" = "-F" ] && [ "$3" = "-t" ]; then
+  if [ -f "$0.detached-recycled" ] && [ "$4" = "%99" ]; then ${JSON.stringify(tmuxImpl)} __nested_hud_guard_denied__ %99 999 '$2' @2; exit 0; fi
+  ${JSON.stringify(tmuxImpl)} "$@" >/dev/null 2>&1 || true
+  success="$6"
+  receipt=$(printf '%s' "$success" | sed -n 's/.*\\(omx_detached_[A-Za-z0-9-]*\\).*/\\1/p')
+  case "\${OMX_TEST_DETACHED_RECYCLE:-}" in
+    split) case "$success" in *split-window*) exit 0;; esac ;;
+    finalization) case "$*" in
+      *split-window*) : > "$0.detached-split-seen" ;;
+      *"if-shell -F -t '%99'"*) if [ -f "$0.detached-split-seen" ]; then
+        ${JSON.stringify(tmuxImpl)} __recycled__ %99 999 '$2' @2
+        : > "$0.detached-recycled"
+        eval "set -- $success"
+        "$0" "$@" >/dev/null
+      fi ;;
+    esac ;;
+  esac
+  [ -n "$receipt" ] || exit 1
+  case "$success" in
+    *split-window*) printf '%%99\t456\t$1\t@1\t%s\n' "$receipt" ;;
+    *) printf '%s\n' "$receipt" ;;
+  esac
+  exit 0
+fi
+output=$(${JSON.stringify(tmuxImpl)} "$@")
+status=$?
+printf '%s' "$output"
+if [ "$status" -eq 0 ] && [ "$1" = "new-session" ]; then
+  previous=''
+  for arg in "$@"; do
+    if [ "$previous" = '-s' ]; then printf '%s' "$arg" > /tmp/omx-test-detached-session-name; break; fi
+    previous="$arg"
+  done
+  for last_arg do :; done
+  previous=''
+  for arg in "$@"; do
+    if [ "$previous" = '-e' ]; then export "$arg"; fi
+    previous="$arg"
+  done
+  pane=$(printf '%s' "$output" | sed -n '1p')
+  TMUX=/tmp/omx-test-tmux,1,0 TMUX_PANE="$pane" nohup /bin/sh -c 'eval "exec $1"' sh "$last_arg" </dev/null >/tmp/omx-test-detached-leader.log 2>&1 &
+  leader_pid=$!
+  printf '%s' "$leader_pid" > "$0.detached-leader-pid"
+  printf '%s' "$pane" > "$0.detached-leader-pane"
+  (while kill -0 "$leader_pid" 2>/dev/null; do sleep 0.02; done; printf done > ${JSON.stringify(join(wd, 'leader-done'))}) </dev/null >/dev/null 2>&1 &
+fi
+exit "$status"
+`);
     return {
         tmuxLogPath,
+        leaderDonePath,
         env: {
             HOME: home,
             PATH: `${fakeBin}:/usr/bin:/bin`,
@@ -93,6 +248,104 @@ async function createLaunchFixture(wd, tmuxScript) {
         },
     };
 }
+function startHeldOmx(cwd, envOverrides) {
+    const testDir = dirname(fileURLToPath(import.meta.url));
+    const repoRoot = join(testDir, '..', '..', '..');
+    return spawn(process.execPath, [join(repoRoot, 'dist', 'cli', 'omx.js'), '--direct', '--version'], {
+        cwd,
+        env: buildRunOmxEnv(envOverrides),
+        stdio: 'inherit',
+    });
+}
+async function waitForPath(path, expectedLines = 1, timeoutMs = 6_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (existsSync(path)) {
+            const contents = await readFile(path, 'utf-8').catch(() => '');
+            if (contents.trim().split('\n').filter(Boolean).length >= expectedLines)
+                return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    throw new Error(`timed out waiting for ${path}`);
+}
+function parseShimTmuxArgv(contents) {
+    return contents
+        .split('tmux argv:\n')
+        .slice(1)
+        .map((record) => record.split('\nend tmux argv')[0].split('\n').filter(Boolean));
+}
+async function assertShimLogQuiescent(path, quietPeriodMs, message) {
+    const before = await readFile(path, 'utf-8').catch(() => '');
+    await new Promise((resolve) => setTimeout(resolve, quietPeriodMs));
+    assert.equal(await readFile(path, 'utf-8').catch(() => ''), before, message);
+}
+async function waitForServerLogSubstring(readServerLog, offset, needle, timeoutMs = 3_000, intervalMs = 25) {
+    const deadline = Date.now() + timeoutMs;
+    let lastWindow = '';
+    while (Date.now() <= deadline) {
+        const log = await readServerLog();
+        lastWindow = log.slice(offset);
+        if (lastWindow.includes(needle))
+            return lastWindow;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`timed out after ${timeoutMs}ms waiting for ${JSON.stringify(needle)} in private tmux server log; tail=${JSON.stringify(lastWindow.slice(-2_000))}`);
+}
+async function stopHeldOmx(child, releasePath) {
+    await rm(releasePath, { force: true });
+    await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', () => resolve());
+    });
+}
+async function createHeldCodexFixture(wd) {
+    const home = join(wd, 'home');
+    const fakeBin = join(wd, 'bin');
+    const releasePath = join(wd, 'hold');
+    const rootsPath = join(wd, 'roots.log');
+    await mkdir(home, { recursive: true });
+    await mkdir(fakeBin, { recursive: true });
+    await writeFile(releasePath, 'hold\n');
+    await writeExecutable(join(fakeBin, 'codex'), `#!/bin/sh
+printf '%s\\n' "$OMX_ROOT" >> "${rootsPath}"
+while [ -f "${releasePath}" ]; do sleep 1; done
+`);
+    await writeExecutable(join(fakeBin, 'ps'), '#!/bin/sh\nexit 0\n');
+    return {
+        releasePath,
+        rootsPath,
+        env: {
+            HOME: home,
+            PATH: `${fakeBin}:/usr/bin:/bin`,
+            OMX_AUTO_UPDATE: '0',
+            OMX_NOTIFY_FALLBACK: '0',
+            OMX_HOOK_DERIVED_SIGNALS: '0',
+            OMX_ROOT: '',
+            OMX_STATE_ROOT: '',
+            TMUX: '',
+            TMUX_PANE: '',
+        },
+    };
+}
+function skipUnlessPrivateRealTmux(t) {
+    if (isRealTmuxAvailable())
+        return true;
+    assert.equal(process.env.CI, undefined, 'CI must provide tmux for the private-server detached launch regression');
+    t.skip('tmux is not installed');
+    return false;
+}
+function skipUnlessScriptAvailable(t) {
+    if (process.platform === 'win32') {
+        t.skip('PTY launch harness requires posix script(1)');
+        return false;
+    }
+    if (isRealScriptAvailable())
+        return true;
+    assert.equal(process.env.CI, undefined, 'CI must provide script(1) for the PTY launch regression');
+    t.skip('script(1) is not installed');
+    return false;
+}
 describe('omx launch fallback when tmux is unavailable', () => {
     it('surfaces direct Codex startup stderr and preserves the child exit code', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-child-error-'));
@@ -122,7 +375,7 @@ exit 42
             assert.match(result.stderr, /\[omx\] codex exited with code 42/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('reports a missing Codex executable instead of exiting silently', async () => {
@@ -149,7 +402,7 @@ exit 42
             assert.notEqual(result.stderr.trim(), '');
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('launches codex directly without tmux ENOENT noise', async () => {
@@ -180,7 +433,256 @@ exit 42
             assert.doesNotMatch(result.stderr, /spawnSync tmux ENOENT/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('passes literal max and ultra after -- with raw config args to Codex launch unchanged', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-reasoning-passthrough-'));
+        try {
+            const home = join(wd, 'home');
+            const fakeBin = join(wd, 'bin');
+            const fakeCodexPath = join(fakeBin, 'codex');
+            const fakePsPath = join(fakeBin, 'ps');
+            const fakeCapturePath = join(wd, 'fake-codex-argv.json');
+            await mkdir(home, { recursive: true });
+            await mkdir(fakeBin, { recursive: true });
+            await writeFile(fakeCodexPath, [
+                '#!/bin/sh',
+                `exec "$NODE_BINARY" -e 'require("node:fs").writeFileSync(process.env.OMX_FAKE_CODEX_CAPTURE_PATH, JSON.stringify(process.argv.slice(1)))' -- "$@"`,
+                '',
+            ].join('\n'));
+            await chmod(fakeCodexPath, 0o755);
+            await writeFile(fakePsPath, '#!/bin/sh\nexit 0\n');
+            await chmod(fakePsPath, 0o755);
+            const result = runOmx(wd, [
+                '--direct',
+                '-c',
+                'model_reasoning_effort=MAX',
+                '--',
+                '--max',
+                '--ultra',
+                '-c',
+                'model_reasoning_effort="ultra"',
+                '-c',
+                'model_reasoning_effort=future',
+                'suffix argument with spaces',
+                '',
+                '--',
+                'after second marker',
+            ], {
+                HOME: home,
+                PATH: `${fakeBin}:/usr/bin:/bin`,
+                NODE_OPTIONS: '',
+                OMX_AUTO_UPDATE: '0',
+                OMX_NOTIFY_FALLBACK: '0',
+                OMX_HOOK_DERIVED_SIGNALS: '0',
+                NODE_BINARY: process.execPath,
+                OMX_FAKE_CODEX_CAPTURE_PATH: fakeCapturePath,
+                TMUX: '',
+                TMUX_PANE: '',
+            });
+            if (shouldSkipForSpawnPermissions(result.error))
+                return;
+            assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+            const capturedArgv = JSON.parse(await readFile(fakeCapturePath, 'utf-8'));
+            const firstMarkerIndex = capturedArgv.indexOf('--');
+            assert.equal(firstMarkerIndex, 4);
+            const modelInstructionsArg = capturedArgv[firstMarkerIndex - 1];
+            assert.match(modelInstructionsArg, /^model_instructions_file="[^"\n]+"$/);
+            assert.match(modelInstructionsArg, /\.omx\/state\/sessions\/omx-[^"]+\/AGENTS\.md"$/);
+            assert.equal(capturedArgv.filter((arg) => arg.startsWith('model_instructions_file=')).length, 1);
+            assert.deepEqual(capturedArgv, [
+                '-c',
+                'model_reasoning_effort=MAX',
+                '-c',
+                modelInstructionsArg,
+                '--',
+                '--max',
+                '--ultra',
+                '-c',
+                'model_reasoning_effort="ultra"',
+                '-c',
+                'model_reasoning_effort=future',
+                'suffix argument with spaces',
+                '',
+                '--',
+                'after second marker',
+            ]);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('treats image values as variadic when detecting resume launches', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-image-resume-'));
+        try {
+            const home = join(wd, 'home');
+            const fakeBin = join(wd, 'bin');
+            const fakeCapturePath = join(wd, 'fake-codex.json');
+            await mkdir(join(wd, '.omx'), { recursive: true });
+            await mkdir(join(wd, '.codex'), { recursive: true });
+            await mkdir(home, { recursive: true });
+            await mkdir(fakeBin, { recursive: true });
+            await writeFile(join(wd, '.omx', 'setup-scope.json'), JSON.stringify({ scope: 'project' }));
+            await writeFile(join(wd, '.codex', 'state_5.sqlite'), 'resume-only-sentinel');
+            await writeExecutable(join(fakeBin, 'codex'), `#!/bin/sh
+exec "$NODE_BINARY" -e 'const fs = require("node:fs"); const path = require("node:path"); fs.writeFileSync(process.env.OMX_FAKE_CODEX_CAPTURE_PATH, JSON.stringify({ argv: process.argv.slice(1), hasResumeSqlite: fs.existsSync(path.join(process.env.CODEX_HOME, "state_5.sqlite")) }))' -- "$@"
+`);
+            const cases = [
+                { args: ['-i', 'resume'], resumes: false },
+                { args: ['--image', 'resume'], resumes: false },
+                { args: ['--image=resume'], resumes: false },
+                { args: ['-iresume'], resumes: false },
+                { args: ['-i=resume'], resumes: false },
+                { args: ['-i', 'screenshot.png', 'resume'], resumes: false },
+                { args: ['--image', 'screenshot.png', 'resume'], resumes: false },
+                { args: ['--image=screenshot.png', 'resume'], resumes: true },
+                { args: ['-iscreenshot.png', 'resume'], resumes: true },
+                { args: ['-i=screenshot.png', 'resume'], resumes: true },
+                { args: ['-i', 'one.png', '-i', 'two.png', 'resume'], resumes: false },
+                { args: ['--image', 'one.png', '--image', 'two.png', 'resume'], resumes: false },
+                { args: ['-i', 'one.png,two.png', 'resume'], resumes: false },
+                { args: ['--image', 'one.png,two.png', 'resume'], resumes: false },
+                { args: ['--image', 'one.png', '--model', 'gpt-review', 'resume'], resumes: true },
+                { args: ['--image=one.png', '--model=gpt-review', 'resume'], resumes: true },
+            ];
+            for (const testCase of cases) {
+                const result = runOmx(wd, ['--direct', ...testCase.args], {
+                    HOME: home,
+                    PATH: `${fakeBin}:/usr/bin:/bin`,
+                    NODE_BINARY: process.execPath,
+                    OMX_AUTO_UPDATE: '0',
+                    OMX_BYPASS_DEFAULT_SYSTEM_PROMPT: '0',
+                    OMX_HOOK_DERIVED_SIGNALS: '0',
+                    OMX_NOTIFY_FALLBACK: '0',
+                    OMX_FAKE_CODEX_CAPTURE_PATH: fakeCapturePath,
+                });
+                if (shouldSkipForSpawnPermissions(result.error))
+                    return;
+                assert.equal(result.status, 0, `${JSON.stringify(testCase.args)}: ${result.error || result.stderr || result.stdout}`);
+                const captured = JSON.parse(await readFile(fakeCapturePath, 'utf-8'));
+                assert.deepEqual(captured.argv, testCase.args);
+                assert.equal(captured.hasResumeSqlite, testCase.resumes, JSON.stringify(testCase.args));
+            }
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+});
+describe('ordinary launch root collision guidance', () => {
+    it('keeps the cwd default for the first launch and fails the second and third launches closed with explicit-root guidance', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-root-conflict-'));
+        let binding;
+        try {
+            execFileSync('git', ['init'], { cwd: wd, stdio: 'ignore' });
+            const fixture = await createHeldCodexFixture(wd);
+            const established = await establishLaunchSessionBinding(wd, 'first-standard-launch', { pid: process.pid });
+            assert.equal(established.kind, 'committed-released');
+            if (established.kind !== 'committed-released')
+                return;
+            binding = established.binding;
+            const second = runOmx(wd, ['--direct', '--version'], fixture.env);
+            const third = runOmx(wd, ['--direct', '--version'], fixture.env);
+            if (shouldSkipForSpawnPermissions(second.error) || shouldSkipForSpawnPermissions(third.error))
+                return;
+            for (const result of [second, third]) {
+                assert.notEqual(result.status, 0, result.stderr || result.stdout);
+                assert.match(result.stderr, /session_pointer_owner_conflict/);
+                assert.match(result.stderr, /concurrent conversations in this checkout require distinct user-specified OMX_ROOT values/);
+                assert.match(result.stderr, /POSIX: OMX_ROOT="\$HOME\/\.omx\/instances\/second-conversation" omx/);
+                assert.match(result.stderr, /PowerShell: \$env:OMX_ROOT = "\$HOME\/\.omx\/instances\/second-conversation"; omx/);
+                assert.match(result.stderr, /cmd\.exe: set "OMX_ROOT=%USERPROFILE%\\\.omx\\instances\\second-conversation" && omx/);
+                assert.match(result.stderr, /OMX does not reroute or allocate one automatically/);
+            }
+            const resume = runOmx(wd, ['--direct', 'resume'], fixture.env);
+            if (!shouldSkipForSpawnPermissions(resume.error)) {
+                assert.notEqual(resume.status, 0, resume.stderr || resume.stdout);
+                assert.match(resume.stderr, /session_pointer_owner_conflict/);
+                assert.doesNotMatch(resume.stderr, /concurrent conversations in this checkout require distinct user-specified OMX_ROOT values/);
+            }
+            await finalizeBoundOnce(binding, 'test');
+        }
+        finally {
+            if (binding)
+                await closeLaunchSessionBindingOnce(binding).catch(() => { });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('keeps explicit roots literal: distinct roots launch independently while a shared root remains fatal without reroute guidance', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-explicit-roots-'));
+        execFileSync('git', ['init'], { cwd: wd, stdio: 'ignore' });
+        let first;
+        let second;
+        try {
+            const fixture = await createHeldCodexFixture(wd);
+            const firstRoot = join(wd, 'first-root');
+            const secondRoot = join(wd, 'second-root');
+            first = startHeldOmx(wd, { ...fixture.env, OMX_ROOT: firstRoot });
+            second = startHeldOmx(wd, { ...fixture.env, OMX_ROOT: secondRoot });
+            await waitForPath(fixture.rootsPath, 2);
+            assert.deepEqual(new Set((await readFile(fixture.rootsPath, 'utf-8')).trim().split('\n')), new Set([firstRoot, secondRoot]));
+            const collision = runOmx(wd, ['--direct', '--version'], { ...fixture.env, OMX_ROOT: firstRoot });
+            if (shouldSkipForSpawnPermissions(collision.error))
+                return;
+            assert.notEqual(collision.status, 0, collision.stderr || collision.stdout);
+            assert.match(collision.stderr, /session_pointer_owner_conflict/);
+            assert.doesNotMatch(collision.stderr, /concurrent conversations in this checkout require distinct user-specified OMX_ROOT values/);
+            assert.doesNotMatch(collision.stderr, /reroute or allocate one automatically/);
+            await stopHeldOmx(first, fixture.releasePath);
+            first = undefined;
+            if (second.exitCode === null) {
+                await new Promise((resolve) => second.once('exit', () => resolve()));
+            }
+            second = undefined;
+        }
+        finally {
+            if (first)
+                first.kill('SIGKILL');
+            if (second)
+                second.kill('SIGKILL');
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('keeps different checkout defaults independent and fails closed on stale default-pointer evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-root-stale-'));
+        let firstBinding;
+        let secondBinding;
+        try {
+            const firstCheckout = join(wd, 'first-checkout');
+            const secondCheckout = join(wd, 'second-checkout');
+            await mkdir(firstCheckout, { recursive: true });
+            await mkdir(secondCheckout, { recursive: true });
+            execFileSync('git', ['init'], { cwd: firstCheckout, stdio: 'ignore' });
+            execFileSync('git', ['init'], { cwd: secondCheckout, stdio: 'ignore' });
+            const firstEstablished = await establishLaunchSessionBinding(firstCheckout, 'first-checkout-owner', { pid: process.pid });
+            const secondEstablished = await establishLaunchSessionBinding(secondCheckout, 'second-checkout-owner', { pid: process.pid });
+            assert.equal(firstEstablished.kind, 'committed-released');
+            assert.equal(secondEstablished.kind, 'committed-released');
+            if (firstEstablished.kind !== 'committed-released' || secondEstablished.kind !== 'committed-released')
+                return;
+            firstBinding = firstEstablished.binding;
+            secondBinding = secondEstablished.binding;
+            assert.match(await readFile(join(firstCheckout, '.omx', 'state', 'session.json'), 'utf-8'), /first-checkout-owner/);
+            assert.match(await readFile(join(secondCheckout, '.omx', 'state', 'session.json'), 'utf-8'), /second-checkout-owner/);
+            await finalizeBoundOnce(firstBinding, 'test');
+            await finalizeBoundOnce(secondBinding, 'test');
+            await writeSessionStart(firstCheckout, 'stale-owner', { pid: 2_147_483_647 });
+            const fixture = await createHeldCodexFixture(wd);
+            await rm(fixture.releasePath, { force: true });
+            const relaunch = runOmx(firstCheckout, ['--direct', '--version'], fixture.env);
+            if (shouldSkipForSpawnPermissions(relaunch.error))
+                return;
+            assert.notEqual(relaunch.status, 0, relaunch.error || relaunch.stderr || relaunch.stdout);
+            assert.match(relaunch.stderr, /session_pointer_unusable|stale-dead/);
+            assert.match(await readFile(join(firstCheckout, '.omx', 'state', 'session.json'), 'utf-8'), /stale-owner/);
+        }
+        finally {
+            if (firstBinding)
+                await closeLaunchSessionBindingOnce(firstBinding).catch(() => { });
+            if (secondBinding)
+                await closeLaunchSessionBindingOnce(secondBinding).catch(() => { });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
 });
@@ -218,7 +720,7 @@ printf 'fake-codex:%s\n' "$*"
             assert.equal(existsSync(join(worktreePath, '.omx')), false);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('preserves explicit OMX_ROOT for launch worktree state', async () => {
@@ -254,7 +756,7 @@ printf 'fake-codex:%s\n' "$*"
             assert.equal(existsSync(join(repo, '.omx')), false);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('keeps direct madmax worktree launches bound to the boxed run root', async () => {
@@ -304,7 +806,7 @@ printf 'fake-codex:%s\n' "$*"
             assert.match(normalizedStdout, /fake-codex-context:[0-9a-f]{32}/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
 });
@@ -363,20 +865,406 @@ exit 0
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
             assert.match(tmuxLog, /tmux:new-session /);
-            assert.match(tmuxLog, /tmux:split-window /);
+            assert.match(tmuxLog, /tmux:if-shell -F -t %12 .*split-window/);
             assert.doesNotMatch(tmuxLog, /tmux:attach-session/);
             assert.doesNotMatch(result.stderr, /failed to attach detached tmux session/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
 });
 describe('omx launcher when tmux is available', () => {
-    it('reuses the same boxed madmax detached launch context instead of spawning duplicate tmux sessions', async () => {
+    it('restores an enlarged detached HUD on the first larger client attach', async (t) => {
+        if (!skipUnlessPrivateRealTmux(t))
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-private-real-tmux-'));
+        try {
+            await withTempTmuxSession(async (fixture) => {
+                const home = join(wd, 'home');
+                const bin = join(wd, 'bin');
+                const shimLogPath = join(wd, 'private-tmux-shim.log');
+                await mkdir(home, { recursive: true });
+                await mkdir(bin, { recursive: true });
+                await writeExecutable(join(bin, 'codex'), '#!/bin/sh\nsleep 300\n');
+                await fixture.createPathShim(bin, shimLogPath);
+                const result = runOmx(wd, ['--madmax', '--tmux'], {
+                    HOME: home,
+                    PATH: `${bin}:${process.env.PATH ?? ''}`,
+                    OMX_AUTO_UPDATE: '0',
+                    OMX_NOTIFY_FALLBACK: '0',
+                    OMX_HOOK_DERIVED_SIGNALS: '0',
+                    OMX_HERMES_MCP_BRIDGE: '1',
+                    OMX_LAUNCH_POLICY: 'direct',
+                    TMUX: '',
+                    TMUX_PANE: '',
+                });
+                assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+                const launchedSession = fixture.run(['list-sessions', '-F', '#{session_name}'])
+                    .split('\n')
+                    .find((name) => name.startsWith('omx-') && name !== fixture.sessionName);
+                assert.ok(launchedSession, 'compiled launcher must create its detached session on the private server');
+                // tmux 3.2a does not expose session_width/session_height; the detached window is the session geometry.
+                assert.equal(fixture.run(['display-message', '-p', '-t', launchedSession, '#{window_width}x#{window_height}']), '80x24', 'the detached session must remain at its initial geometry before any client attaches');
+                const panes = fixture.run(['list-panes', '-t', launchedSession, '-F', '#{pane_id}\t#{pane_height}\t#{pane_start_command}'])
+                    .split('\n')
+                    .map((line) => line.split('\t'));
+                const hud = panes.find(([, , command]) => command.includes('OMX_DETACHED_HUD_OPERATION='));
+                assert.ok(hud, 'HUD split must carry its operation marker');
+                assert.equal(Number(hud[1]), HUD_TMUX_HEIGHT_LINES, 'authorized direct reconciliation must resize the HUD');
+                assert.equal(fixture.run(['show-options', '-v', '-t', launchedSession, 'history-limit']), String(DETACHED_TMUX_HISTORY_LIMIT), 'direct leader mutation must receive its receipt and set session history');
+                const hooks = fixture.run(['show-hooks', '-t', launchedSession]);
+                assert.match(hooks, /client-resized\[[0-9]+\].*run-shell -b/);
+                assert.match(hooks, /tmux if-shell -F -t/);
+                assert.match(hooks, /OMX_DETACHED_HUD_OPERATION=/);
+                const storedPaneFormat = hooks.match(/##\{pane_id\}\\t##\{pane_dead\}\\t##\{pane_pid\}/)?.[0] ?? '';
+                assert.equal(storedPaneFormat, '##{pane_id}\\t##{pane_dead}\\t##{pane_pid}', 'stored hook display must retain one outer format escape and encode TAB bytes');
+                const executablePaneFormat = storedPaneFormat.replaceAll('##{', '#{').replaceAll('\\t', '\t');
+                assert.equal(executablePaneFormat, '#{pane_id}\t#{pane_dead}\t#{pane_pid}', 'one outer tmux format pass must decode the stored format into the executable nested argv');
+                const clientAttachedHookSlots = [...hooks.matchAll(/client-attached\[[0-9]+\]/g)].map(([slot]) => slot);
+                for (const hookSlot of clientAttachedHookSlots) {
+                    fixture.run(['set-hook', '-u', '-t', launchedSession, hookSlot]);
+                }
+                const installedHooks = fixture.run(['show-hooks', '-t', launchedSession]);
+                const storedResizeHookSlots = [...installedHooks.matchAll(/client-resized\[[0-9]+\]/g)].map(([slot]) => slot);
+                assert.equal(storedResizeHookSlots.length, 1, 'exactly one installed client-resized hook must remain for the natural resize trigger');
+                assert.match(installedHooks, /client-resized\[[0-9]+\].*run-shell -b/);
+                assert.doesNotMatch(installedHooks, /client-attached\[[0-9]+\]/, 'the resize trigger must not be conflated with client-attached hook execution');
+                await new Promise((resolve) => setTimeout(resolve, (HUD_RESIZE_RECONCILE_DELAY_SECONDS * 1_000) + 250));
+                const launchPaneSnapshots = parseShimTmuxArgv(await readFile(shimLogPath, 'utf-8'))
+                    .filter((argv) => argv[0] === 'list-panes' && argv[1] === '-a');
+                assert.ok(launchPaneSnapshots.length >= 2, 'the direct and delayed launch reconciliations must both complete before the stored-hook baseline is cleared');
+                await assertShimLogQuiescent(shimLogPath, 250, 'launch and delayed reconciliation must settle before clearing the stored-hook baseline');
+                await writeFile(shimLogPath, '');
+                assert.equal(await readFile(shimLogPath, 'utf-8'), '', 'the shim baseline must start after launch and reconciliation activity settles');
+                fixture.run(['resize-pane', '-t', hud[0], '-y', '7']);
+                assert.equal(Number(fixture.run(['display-message', '-p', '-t', hud[0], '#{pane_height}'])), 7, 'the detached HUD must be enlarged before the restore trigger');
+                assert.equal(fixture.run(['display-message', '-p', '-t', launchedSession, '#{window_width}x#{window_height}']), '80x24', 'enlarging the detached HUD must not attach a client');
+                fixture.triggerClientResize(launchedSession, { cols: 121, rows: 41 });
+                await new Promise((resolve) => setTimeout(resolve, (HUD_RESIZE_RECONCILE_DELAY_SECONDS * 1_000) + 250));
+                await assertShimLogQuiescent(shimLogPath, 250, 'the stored client-resized hook must finish both its immediate and delayed passes before assertions');
+                assert.equal(Number(fixture.run(['display-message', '-p', '-t', hud[0], '#{pane_height}'])), HUD_TMUX_HEIGHT_LINES, 'the first larger client attach must restore the enlarged detached HUD');
+                const paneSnapshots = parseShimTmuxArgv(await readFile(shimLogPath, 'utf-8'))
+                    .filter((argv) => argv[0] === 'list-panes' && argv[1] === '-a');
+                assert.equal(paneSnapshots.length, 2, 'only the explicitly triggered stored client-resized hook may produce the post-baseline immediate and delayed pane snapshots');
+                for (const argv of paneSnapshots) {
+                    assert.deepEqual(argv, ['list-panes', '-a', '-F', executablePaneFormat], 'post-baseline stored client-resized hook execution must preserve the exact executable TAB-delimited nested argv');
+                }
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('records the guarded resize command without an unknown-command parser error', async (t) => {
+        if (!skipUnlessPrivateRealTmux(t))
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-private-real-tmux-'));
+        try {
+            await withTempTmuxSession({ serverLog: true }, async (fixture) => {
+                const home = join(wd, 'home');
+                const bin = join(wd, 'bin');
+                const shimLogPath = join(wd, 'private-tmux-shim.log');
+                await mkdir(home, { recursive: true });
+                await mkdir(bin, { recursive: true });
+                await writeExecutable(join(bin, 'codex'), '#!/bin/sh\nsleep 300\n');
+                await fixture.createPathShim(bin, shimLogPath);
+                const result = runOmx(wd, ['--madmax', '--tmux'], {
+                    HOME: home,
+                    PATH: `${bin}:${process.env.PATH ?? ''}`,
+                    OMX_AUTO_UPDATE: '0',
+                    OMX_NOTIFY_FALLBACK: '0',
+                    OMX_HOOK_DERIVED_SIGNALS: '0',
+                    OMX_HERMES_MCP_BRIDGE: '1',
+                    OMX_LAUNCH_POLICY: 'direct',
+                    TMUX: '',
+                    TMUX_PANE: '',
+                });
+                assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+                const launchedSession = fixture.run(['list-sessions', '-F', '#{session_name}'])
+                    .split('\n')
+                    .find((name) => name.startsWith('omx-') && name !== fixture.sessionName);
+                assert.ok(launchedSession, 'compiled launcher must create its detached session on the private server');
+                const panes = fixture.run(['list-panes', '-t', launchedSession, '-F', '#{pane_id}\t#{pane_height}\t#{pane_start_command}'])
+                    .split('\n')
+                    .map((line) => line.split('\t'));
+                const hud = panes.find(([, , command]) => command.includes('OMX_DETACHED_HUD_OPERATION='));
+                assert.ok(hud, 'HUD split must carry its operation marker');
+                const hooks = fixture.run(['show-hooks', '-t', launchedSession]);
+                const storedPaneFormat = hooks.match(/##\{pane_id\}\\t##\{pane_dead\}\\t##\{pane_pid\}/)?.[0] ?? '';
+                const executablePaneFormat = storedPaneFormat.replaceAll('##{', '#{').replaceAll('\\t', '\t');
+                assert.equal(executablePaneFormat, '#{pane_id}\t#{pane_dead}\t#{pane_pid}', 'one outer tmux format pass must decode the stored format into the executable nested argv');
+                const clientAttachedHookSlots = [...hooks.matchAll(/client-attached\[[0-9]+\]/g)].map(([slot]) => slot);
+                for (const hookSlot of clientAttachedHookSlots) {
+                    fixture.run(['set-hook', '-u', '-t', launchedSession, hookSlot]);
+                }
+                const installedHooks = fixture.run(['show-hooks', '-t', launchedSession]);
+                const storedResizeHookSlots = [...installedHooks.matchAll(/client-resized\[[0-9]+\]/g)].map(([slot]) => slot);
+                assert.equal(storedResizeHookSlots.length, 1, 'exactly one installed client-resized hook must remain for the natural resize trigger');
+                await new Promise((resolve) => setTimeout(resolve, (HUD_RESIZE_RECONCILE_DELAY_SECONDS * 1_000) + 250));
+                const launchPaneSnapshots = parseShimTmuxArgv(await readFile(shimLogPath, 'utf-8'))
+                    .filter((argv) => argv[0] === 'list-panes' && argv[1] === '-a');
+                assert.ok(launchPaneSnapshots.length >= 2, 'the direct and delayed launch reconciliations must both complete before the stored-hook baseline is cleared');
+                await assertShimLogQuiescent(shimLogPath, 250, 'launch and delayed reconciliation must settle before clearing the stored-hook baseline');
+                await writeFile(shimLogPath, '');
+                const probeOffset = (await fixture.readServerLog()).length;
+                const probe = fixture.runResult([
+                    'if-shell', '-F', '-t', fixture.leaderPaneId, '1',
+                    'tmux display-message -p omx-oracle-probe', '',
+                ]);
+                assert.equal(probe.error, '', 'the positive-control tmux client must start successfully');
+                assert.notEqual(probe.status, 0, 'tmux must reject the deliberately malformed selected command list');
+                assert.ok(probe.stderr === '' || /unknown command: tmux/.test(probe.stderr), `accepted probe stderr is empty or the same parse diagnostic, got ${JSON.stringify(probe.stderr)}`);
+                assert.equal(fixture.sessionExists(), true, 'the private tmux server must remain alive after the malformed client command');
+                assert.equal(fixture.run(['display-message', '-p', '-t', fixture.leaderPaneId, '#{pane_id}']), fixture.leaderPaneId, 'a successful post-probe command must prove the server remains responsive');
+                await waitForServerLogSubstring(fixture.readServerLog, probeOffset, 'unknown command: tmux', 3_000, 25);
+                const triggerOffset = (await fixture.readServerLog()).length;
+                fixture.run(['resize-pane', '-t', hud[0], '-y', '7']);
+                assert.equal(Number(fixture.run(['display-message', '-p', '-t', hud[0], '#{pane_height}'])), 7, 'the detached HUD must be enlarged before the parser oracle trigger');
+                fixture.triggerClientResize(launchedSession, { cols: 121, rows: 41 });
+                await new Promise((resolve) => setTimeout(resolve, (HUD_RESIZE_RECONCILE_DELAY_SECONDS * 1_000) + 250));
+                await assertShimLogQuiescent(shimLogPath, 250, 'the stored client-resized hook must finish both its immediate and delayed passes before assertions');
+                const paneSnapshots = parseShimTmuxArgv(await readFile(shimLogPath, 'utf-8'))
+                    .filter((argv) => argv[0] === 'list-panes' && argv[1] === '-a');
+                assert.equal(paneSnapshots.length, 2, 'only the explicitly triggered stored client-resized hook may produce the post-baseline immediate and delayed pane snapshots');
+                for (const argv of paneSnapshots) {
+                    assert.deepEqual(argv, ['list-panes', '-a', '-F', executablePaneFormat], 'post-baseline stored client-resized hook execution must preserve the exact executable TAB-delimited nested argv');
+                }
+                const triggerWindow = (await fixture.readServerLog()).slice(triggerOffset);
+                assert.ok(triggerWindow.includes(`resize-pane -t ${hud[0]} -y ${HUD_TMUX_HEIGHT_LINES}`), 'the server-log window must cover the stored hook resize command');
+                assert.doesNotMatch(triggerWindow, /unknown command: tmux/, 'the triggered guarded sink must parse as a bare tmux command-list entry (#3292)');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('denies detached HUD mutation after the pane owner changes', async (t) => {
+        if (!skipUnlessPrivateRealTmux(t))
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-private-real-tmux-'));
+        try {
+            await withTempTmuxSession(async (fixture) => {
+                const home = join(wd, 'home');
+                const bin = join(wd, 'bin');
+                const shimLogPath = join(wd, 'private-tmux-shim.log');
+                const foreignSession = 'foreign-control';
+                let launchedSession;
+                let originalOwner;
+                await mkdir(home, { recursive: true });
+                await mkdir(bin, { recursive: true });
+                await writeExecutable(join(bin, 'codex'), '#!/bin/sh\nsleep 300\n');
+                await fixture.createPathShim(bin, shimLogPath);
+                fixture.run(['new-session', '-d', '-s', foreignSession, 'sleep 300']);
+                const foreignBefore = fixture.run(['list-panes', '-t', foreignSession, '-F', '#{pane_id}\t#{pane_pid}\t#{pane_height}']);
+                try {
+                    const result = runOmx(wd, ['--madmax', '--tmux'], {
+                        HOME: home,
+                        PATH: `${bin}:${process.env.PATH ?? ''}`,
+                        OMX_AUTO_UPDATE: '0',
+                        OMX_NOTIFY_FALLBACK: '0',
+                        OMX_HOOK_DERIVED_SIGNALS: '0',
+                        OMX_HERMES_MCP_BRIDGE: '1',
+                        OMX_LAUNCH_POLICY: 'direct',
+                        TMUX: '',
+                        TMUX_PANE: '',
+                    });
+                    assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+                    launchedSession = fixture.run(['list-sessions', '-F', '#{session_name}'])
+                        .split('\n')
+                        .find((name) => name.startsWith('omx-') && name !== fixture.sessionName);
+                    assert.ok(launchedSession, 'compiled launcher must create its detached session on the private server');
+                    const panes = fixture.run(['list-panes', '-t', launchedSession, '-F', '#{pane_id}\t#{pane_height}\t#{pane_start_command}'])
+                        .split('\n')
+                        .map((line) => line.split('\t'));
+                    const hud = panes.find(([, , command]) => command.includes('OMX_DETACHED_HUD_OPERATION='));
+                    assert.ok(hud, 'HUD split must carry its operation marker');
+                    const hooks = fixture.run(['show-hooks', '-t', launchedSession]);
+                    const storedPaneFormat = hooks.match(/##\{pane_id\}\\t##\{pane_dead\}\\t##\{pane_pid\}/)?.[0] ?? '';
+                    const executablePaneFormat = storedPaneFormat.replaceAll('##{', '#{').replaceAll('\\t', '\t');
+                    assert.equal(executablePaneFormat, '#{pane_id}\t#{pane_dead}\t#{pane_pid}', 'one outer tmux format pass must decode the stored format into the executable nested argv');
+                    const clientAttachedHookSlots = [...hooks.matchAll(/client-attached\[[0-9]+\]/g)].map(([slot]) => slot);
+                    for (const hookSlot of clientAttachedHookSlots) {
+                        fixture.run(['set-hook', '-u', '-t', launchedSession, hookSlot]);
+                    }
+                    const installedHooks = fixture.run(['show-hooks', '-t', launchedSession]);
+                    const storedResizeHookSlots = [...installedHooks.matchAll(/client-resized\[[0-9]+\]/g)].map(([slot]) => slot);
+                    assert.equal(storedResizeHookSlots.length, 1, 'exactly one installed client-resized hook must remain for the natural resize trigger');
+                    await new Promise((resolve) => setTimeout(resolve, (HUD_RESIZE_RECONCILE_DELAY_SECONDS * 1_000) + 250));
+                    const launchPaneSnapshots = parseShimTmuxArgv(await readFile(shimLogPath, 'utf-8'))
+                        .filter((argv) => argv[0] === 'list-panes' && argv[1] === '-a');
+                    assert.ok(launchPaneSnapshots.length >= 2, 'the direct and delayed launch reconciliations must both complete before the stored-hook baseline is cleared');
+                    await assertShimLogQuiescent(shimLogPath, 250, 'launch and delayed reconciliation must settle before clearing the stored-hook baseline');
+                    await writeFile(shimLogPath, '');
+                    originalOwner = fixture.run(['show-options', '-v', '-t', launchedSession, '@omx_instance_id']);
+                    assert.ok(originalOwner, 'the detached session must retain its original pane owner before the denial trigger');
+                    fixture.run(['resize-pane', '-t', hud[0], '-y', '7']);
+                    assert.equal(Number(fixture.run(['display-message', '-p', '-t', hud[0], '#{pane_height}'])), 7, 'the detached HUD must be enlarged before the authority denial trigger');
+                    fixture.run(['set-option', '-t', launchedSession, '@omx_instance_id', 'foreign-owner']);
+                    await writeFile(shimLogPath, '');
+                    fixture.triggerClientResize(launchedSession, { cols: 122, rows: 42 });
+                    await new Promise((resolve) => setTimeout(resolve, (HUD_RESIZE_RECONCILE_DELAY_SECONDS * 1_000) + 250));
+                    await assertShimLogQuiescent(shimLogPath, 250, 'the stored client-resized hook must finish both its immediate and delayed passes before assertions');
+                    const paneSnapshots = parseShimTmuxArgv(await readFile(shimLogPath, 'utf-8'))
+                        .filter((argv) => argv[0] === 'list-panes' && argv[1] === '-a');
+                    assert.equal(paneSnapshots.length, 2, 'only the explicitly triggered stored client-resized hook may produce the post-baseline immediate and delayed pane snapshots');
+                    for (const argv of paneSnapshots) {
+                        assert.deepEqual(argv, ['list-panes', '-a', '-F', executablePaneFormat], 'post-baseline stored client-resized hook execution must preserve the exact executable TAB-delimited nested argv');
+                    }
+                    assert.equal(Number(fixture.run(['display-message', '-p', '-t', hud[0], '#{pane_height}'])), 7, 'the foreign pane owner must deny the deferred HUD mutation');
+                    assert.equal(fixture.run(['list-panes', '-t', foreignSession, '-F', '#{pane_id}\t#{pane_pid}\t#{pane_height}']), foreignBefore, 'the denial trigger must not affect a foreign session');
+                }
+                finally {
+                    if (launchedSession && originalOwner && fixture.sessionExists(launchedSession)) {
+                        fixture.run(['set-option', '-t', launchedSession, '@omx_instance_id', originalOwner]);
+                        assert.equal(fixture.run(['show-options', '-v', '-t', launchedSession, '@omx_instance_id']), originalOwner, 'the original detached pane owner must be restored before fixture teardown');
+                    }
+                }
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('cleans a poisoned private tmux server before replaying a held child and Stop', async (t) => {
+        if (!skipUnlessPrivateRealTmux(t))
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-private-poisoned-server-'));
+        try {
+            await withTempTmuxSession(async (fixture) => {
+                const home = join(wd, 'home');
+                const bin = join(wd, 'bin');
+                const releasePath = join(wd, 'child-release');
+                const capturePath = join(wd, 'child-b-env.log');
+                const poisonRuns = join(wd, 'poison-runs');
+                const shimLogPath = join(wd, 'private-tmux-shim.log');
+                const poisonEnv = Object.fromEntries(DETACHED_LAUNCH_CONTROL_PLANE_KEYS.map((key) => [
+                    key,
+                    key === 'OMX_RUNS_DIR' ? poisonRuns : `poison-${key.toLowerCase()}`,
+                ]));
+                await mkdir(home, { recursive: true });
+                await mkdir(bin, { recursive: true });
+                await writeFile(releasePath, 'hold\n');
+                const captureLines = DETACHED_LAUNCH_CONTROL_PLANE_KEYS
+                    .map((key) => `printf '%s=%s\\n' '${key}' "$${key}"`)
+                    .join('\n');
+                await writeExecutable(join(bin, 'codex'), `#!/bin/sh
+{
+${captureLines}
+} > ${JSON.stringify(capturePath)}
+while [ -f ${JSON.stringify(releasePath)} ]; do sleep 1; done
+`);
+                await fixture.createPathShim(bin, shimLogPath);
+                for (const key of DETACHED_LAUNCH_CONTROL_PLANE_KEYS) {
+                    fixture.run(['set-environment', '-g', key, poisonEnv[key]]);
+                }
+                const result = runOmx(wd, ['--madmax', '--tmux'], {
+                    ...poisonEnv,
+                    HOME: home,
+                    PATH: `${bin}:${process.env.PATH ?? ''}`,
+                    OMX_AUTO_UPDATE: '0',
+                    OMX_NOTIFY_FALLBACK: '0',
+                    OMX_HOOK_DERIVED_SIGNALS: '0',
+                    OMX_HERMES_MCP_BRIDGE: '1',
+                    OMX_LAUNCH_POLICY: 'direct',
+                    TMUX: '',
+                    TMUX_PANE: '',
+                });
+                assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+                assert.doesNotMatch(`${result.stderr}\n${result.stdout}`, /scope|pointer|state root.*error/i);
+                await waitForPath(capturePath, 1, 15_000);
+                const captured = Object.fromEntries((await readFile(capturePath, 'utf-8')).trim().split('\n').map((line) => {
+                    const separator = line.indexOf('=');
+                    return [line.slice(0, separator), line.slice(separator + 1)];
+                }));
+                assert.deepEqual(Object.keys(captured), [...DETACHED_LAUNCH_CONTROL_PLANE_KEYS]);
+                assert.match(captured.OMX_SESSION_ID ?? '', /^omx-/);
+                assert.equal(captured.CODEX_SESSION_ID, '');
+                assert.equal(captured.SESSION_ID, '');
+                assert.equal(captured.OMX_TMUX_HUD_OWNER, '1');
+                assert.equal(captured.OMX_TMUX_HUD_LEADER_PANE, '');
+                assert.match(captured.OMX_ROOT ?? '', new RegExp(`^${escapeRegExp(poisonRuns)}/run-`));
+                assert.equal(captured.OMX_STATE_ROOT, '');
+                assert.equal(captured.OMX_TEAM_STATE_ROOT, '');
+                assert.equal(captured.OMXBOX_ACTIVE, '1');
+                assert.equal(captured.OMX_SOURCE_CWD, wd);
+                assert.match(captured.OMX_MADMAX_DETACHED_CONTEXT ?? '', /^[0-9a-f]{32}$/);
+                assert.equal(captured.OMX_RUNS_DIR, poisonRuns);
+                assert.equal(captured.OMX_TEAM_LEADER_CWD, '');
+                assert.equal(captured.OMX_TEAM_WORKER, '');
+                assert.equal(captured.OMX_TEAM_INTERNAL_WORKER, '');
+                const launchedSession = fixture.run(['list-sessions', '-F', '#{session_name}'])
+                    .split('\n')
+                    .find((name) => name.startsWith('omx-') && name !== fixture.sessionName);
+                assert.ok(launchedSession, 'compiled launcher must create a detached session on the private server');
+                assert.equal(fixture.run(['show-options', '-v', '-t', launchedSession, 'history-limit']), String(DETACHED_TMUX_HISTORY_LIMIT));
+                const sessionJsonPath = join(captured.OMX_ROOT, '.omx', 'state', 'session.json');
+                await waitForPath(sessionJsonPath);
+                const sessionJsonBeforeStop = await readFile(sessionJsonPath, 'utf-8');
+                const sessionStateBeforeStop = JSON.parse(sessionJsonBeforeStop);
+                assert.equal(sessionStateBeforeStop.session_id, captured.OMX_SESSION_ID);
+                assert.equal(sessionStateBeforeStop.tmux_session_name, launchedSession);
+                assert.match(sessionStateBeforeStop.tmux_pane_id ?? '', /^%[0-9]+$/);
+                const stop = spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'scripts', 'codex-native-hook.js')], {
+                    cwd: wd,
+                    input: JSON.stringify({
+                        hook_event_name: 'Stop',
+                        source: 'codex-app',
+                        cwd: wd,
+                        session_id: captured.OMX_SESSION_ID,
+                        thread_id: 'poisoned-server-child-b',
+                        turn_id: 'stop-poisoned-server-child-b',
+                    }),
+                    encoding: 'utf-8',
+                    env: buildRunOmxEnv({
+                        ...captured,
+                        HOME: home,
+                        PATH: `${bin}:${process.env.PATH ?? ''}`,
+                        OMX_AUTO_UPDATE: '0',
+                        OMX_NOTIFY_FALLBACK: '0',
+                        OMX_HOOK_DERIVED_SIGNALS: '0',
+                        TMUX: '',
+                        TMUX_PANE: '',
+                    }),
+                });
+                assert.equal(stop.status, 0, stop.stderr || stop.stdout);
+                assert.doesNotMatch(`${stop.stderr}\n${stop.stdout}`, /scope|pointer|state root.*error/i);
+                const stopOutput = JSON.parse(stop.stdout.trim());
+                assert.deepEqual(stopOutput, {}, 'a clean held-child Stop must be a JSON no-op');
+                assert.notEqual(stopOutput.decision, 'block');
+                const sessionJsonAfterStop = await readFile(sessionJsonPath, 'utf-8');
+                const sessionStateAfterStop = JSON.parse(sessionJsonAfterStop);
+                assert.equal(sessionStateAfterStop.session_id, captured.OMX_SESSION_ID);
+                assert.equal(sessionStateAfterStop.tmux_session_name, launchedSession);
+                assert.equal(sessionJsonAfterStop, sessionJsonBeforeStop, 'a no-op Stop must preserve the live B session pointer');
+                const activeRecordPath = join(captured.OMX_RUNS_DIR, 'active-detached', `${captured.OMX_MADMAX_DETACHED_CONTEXT}.json`);
+                assert.equal(existsSync(activeRecordPath), true, 'leader must retain its active record while child B is live');
+                await rm(releasePath, { force: true });
+                for (let attempt = 0; attempt < 300 && fixture.sessionExists(launchedSession); attempt += 1) {
+                    await new Promise((resolve) => setTimeout(resolve, 20));
+                }
+                assert.equal(fixture.sessionExists(launchedSession), false, 'released child must clean up its detached tmux session');
+                await waitForPath(join(captured.OMX_ROOT, '.omx', 'logs', 'session-history.jsonl'));
+                assert.equal(existsSync(activeRecordPath), false, 'released child must remove its active record');
+                assert.match(await readFile(join(captured.OMX_ROOT, '.omx', 'logs', 'session-history.jsonl'), 'utf-8'), new RegExp(escapeRegExp(captured.OMX_SESSION_ID)));
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('does not let the outer launcher fabricate leader-owned active records', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-madmax-reuse-'));
         try {
             const runs = join(wd, 'runs');
+            const madmaxRoot = join(wd, 'madmax-root');
+            const madmaxContext = buildMadmaxDetachedLaunchContextKey(wd, ['--madmax', '--tmux'], madmaxRoot);
+            await mkdir(madmaxRoot, { recursive: true });
+            await writeFile(join(madmaxRoot, '.omxbox-run.json'), JSON.stringify({
+                cwd: madmaxRoot,
+                source_cwd: wd,
+                detached_launch_context: madmaxContext,
+            }));
             const activeMarker = join(wd, 'active-session');
             const instanceMarker = join(wd, 'active-instance');
             const { env, tmuxLogPath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
@@ -403,6 +1291,12 @@ case "$1" in
     printf 'hud-pane\n'
     exit 0
     ;;
+  list-panes)
+    session=$(cat "${activeMarker}")
+    instance=$(cat "${instanceMarker}")
+    printf '%%12\t0\t4242\t%s\t$1\t100\t%s\n' "$session" "$instance"
+    exit 0
+    ;;
   display-message)
     if [ "$2" = '-p' ] && [ "$3" = '#{socket_path}' ]; then
       printf '/tmp/tmux-test.sock\n'
@@ -438,8 +1332,10 @@ exit 0
             const baseEnv = {
                 ...env,
                 OMX_RUNS_DIR: runs,
+                OMX_ROOT: madmaxRoot,
                 OMXBOX_ACTIVE: '1',
-                OMX_MADMAX_DETACHED_CONTEXT: 'boxed-context-under-test',
+                OMX_SOURCE_CWD: wd,
+                OMX_MADMAX_DETACHED_CONTEXT: madmaxContext,
                 OMX_LAUNCH_POLICY: 'direct',
                 TMUX: '',
                 TMUX_PANE: '',
@@ -452,27 +1348,34 @@ exit 0
             if (shouldSkipForSpawnPermissions(second.error))
                 return;
             assert.equal(second.status, 0, second.error || second.stderr || second.stdout);
-            assert.match(second.stderr, /madmax detached launch already active for this context; attaching .* instead of starting a duplicate/);
+            assert.match(second.stderr, /madmax detached launch already active for this context/);
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, new RegExp(`-e OMX_MADMAX_DETACHED_CONTEXT=${escapeRegExp(madmaxContext)}`));
+            assert.match(tmuxLog, new RegExp(`-e OMX_RUNS_DIR=${escapeRegExp(runs)}`));
             assert.equal((tmuxLog.match(/tmux:new-session/g) || []).length, 1);
-            assert.equal((tmuxLog.match(/tmux:has-session/g) || []).length, 1);
+            assert.equal((tmuxLog.match(/tmux:has-session/g) || []).length, 0);
+            assert.ok((tmuxLog.match(/tmux:list-panes/g) || []).length >= 2);
             assert.equal((tmuxLog.match(/tmux:attach-session/g) || []).length, 2);
-            const activeRecords = await readFile(join(runs, 'active-detached', 'boxed-context-under-test.json'), 'utf-8');
-            assert.match(activeRecords, /"tmux_session_name"/);
-            assert.match(activeRecords, /"session_id"/);
-            assert.match(activeRecords, /"tmux_pane_id": "%12"/);
+            const activeRecord = await readFile(join(runs, 'active-detached', `${madmaxContext}.json`), 'utf-8');
+            assert.match(activeRecord, /"tmux_session_name"/);
+            assert.match(activeRecord, /"session_id"/);
+            assert.match(activeRecord, /"tmux_pane_id": "%12"/);
+            assert.match(activeRecord, /"leader_pid"/);
+            assert.match(activeRecord, /"base_state_root"/);
+            assert.match(activeRecord, /"lifecycle_phase": "ready"/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
-    it('records boxed runtime identity for detached madmax worktree launches', async () => {
+    it('records boxed runtime identity in the leader-owned active record', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-madmax-worktree-detached-'));
         try {
             const repo = await createGitRepo(wd);
             const runs = join(wd, 'runs');
             const instanceMarker = join(wd, 'active-instance');
-            const { env, tmuxLogPath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
+            const sessionMarker = join(wd, 'active-session-name');
+            const { env, tmuxLogPath, leaderDonePath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
 printf 'tmux:%s\n' "$*" >> "${logPath}"
 case "$1" in
   -V)
@@ -483,13 +1386,25 @@ case "$1" in
     exit 1
     ;;
   new-session)
+    prev=''
+    for arg in "$@"; do
+      if [ "$prev" = '-s' ]; then printf '%s' "$arg" > "${sessionMarker}"; fi
+      prev="$arg"
+    done
     printf '%%77\n'
     exit 0
     ;;
+
   split-window)
     printf '%%78\n'
     exit 0
     ;;
+  list-panes)
+    instance=$(cat "${instanceMarker}")
+    printf '%%77\t0\t4242\t%s\t$1\t100\t%s\n' "$(cat "${sessionMarker}")" "$instance"
+    exit 0
+    ;;
+
   display-message)
     if [ "$2" = '-p' ] && [ "$3" = '#{socket_path}' ]; then
       printf '/tmp/tmux-test.sock\n'
@@ -535,19 +1450,17 @@ exit 0
             assert.equal(activeFiles.length, 1);
             const activeRecord = JSON.parse(await readFile(join(runs, 'active-detached', activeFiles[0]), 'utf-8'));
             const worktreePath = join(dirname(repo), `${basename(repo)}.omx-worktrees`, 'launch-detached');
-            assert.match(activeRecord.run_dir, new RegExp(`^${escapeRegExp(normalizeDarwinTmpPath(runs))}/run-`));
-            assert.equal(normalizeDarwinTmpPath(activeRecord.source_cwd), normalizeDarwinTmpPath(repo));
-            assert.equal(normalizeDarwinTmpPath(activeRecord.worktree_cwd), normalizeDarwinTmpPath(worktreePath));
-            assert.equal(activeRecord.session_id.startsWith('omx-'), true);
-            assert.equal(activeRecord.tmux_pane_id, '%77');
+            assert.equal(normalizeDarwinTmpPath(activeRecord.source_cwd), normalizeDarwinTmpPath(worktreePath));
+            assert.equal(typeof activeRecord.leader_pid, 'number');
+            assert.equal(activeRecord.lifecycle_phase, 'ready');
             const tmuxLog = normalizeDarwinTmpPath(await readFile(tmuxLogPath, 'utf-8'));
-            assert.match(tmuxLog, new RegExp(`-e OMX_ROOT=${escapeRegExp(normalizeDarwinTmpPath(activeRecord.run_dir))}`));
+            assert.match(tmuxLog, /__detached-session-leader/);
             assert.match(tmuxLog, /-e OMXBOX_ACTIVE=1/);
             assert.match(tmuxLog, new RegExp(`-e OMX_SOURCE_CWD=${escapeRegExp(normalizeDarwinTmpPath(repo))}`));
-            assert.match(tmuxLog, new RegExp(`-e OMX_MADMAX_DETACHED_CONTEXT=${escapeRegExp(activeRecord.context_key)}`));
+            await waitForPath(leaderDonePath);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('does not mutate a stale active-detached tmux session without OMX ownership proof', async () => {
@@ -567,7 +1480,7 @@ exit 0
                 session_id: 'expected-omx-session-id',
                 tmux_pane_id: '%99',
             })}\n`);
-            const { env, tmuxLogPath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
+            const { env, tmuxLogPath, leaderDonePath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
 printf 'tmux:%s\n' "$*" >> "${logPath}"
 case "$1" in
   -V)
@@ -621,29 +1534,35 @@ exit 0
             if (shouldSkipForSpawnPermissions(result.error))
                 return;
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+            await waitForPath(leaderDonePath);
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.doesNotMatch(tmuxLog, /tmux:set-option .* -t user-owned-session .*history-limit/);
             assert.doesNotMatch(tmuxLog, /tmux:clear-history .*user-owned-session|tmux:clear-history .*%99/);
             assert.match(tmuxLog, /tmux:new-session /);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('does not reuse the same active-detached lock for independent --madmax --high launches', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-madmax-independent-high-'));
         try {
             const runs = join(wd, 'runs');
+            const sessionMarker = join(wd, 'independent-session');
+            const instanceMarker = join(wd, 'independent-instance');
             const { env, tmuxLogPath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
 printf 'tmux:%s\n' "$*" >> "${logPath}"
 case "$1" in
   -V) printf 'tmux 3.4\n'; exit 0 ;;
   has-session) exit 1 ;;
-  new-session) printf '%%12\n'; exit 0 ;;
+  new-session) prev=''; for arg in "$@"; do if [ "$prev" = '-s' ]; then printf '%s' "$arg" > "${sessionMarker}"; fi; prev="$arg"; done; printf '%%12\n'; exit 0 ;;
+
   split-window) printf 'hud-pane\n'; exit 0 ;;
   display-message) if [ "$2" = '-p' ] && [ "$3" = '#{socket_path}' ]; then printf '/tmp/tmux-test.sock\n'; else printf '0\n'; fi; exit 0 ;;
+  list-panes) printf '%%12\t0\t4242\t%s\t$1\t100\t%s\n' "$(cat "${sessionMarker}")" "$(cat "${instanceMarker}")"; exit 0 ;;
   show-options) printf 'off\n'; exit 0 ;;
-  set-option|set-hook|attach-session|kill-session|run-shell|resize-pane) exit 0 ;;
+  set-option) if [ "$4" = '@omx_instance_id' ]; then printf '%s' "$5" > "${instanceMarker}"; fi; exit 0 ;;
+  set-hook|attach-session|kill-session|run-shell|resize-pane) exit 0 ;;
 esac
 exit 0
 `);
@@ -668,13 +1587,14 @@ exit 0
                 .map((line) => JSON.parse(line));
             assert.equal(registryEntries.length, 2);
             assert.notEqual(registryEntries[0].detached_launch_context, registryEntries[1].detached_launch_context, 'independent launches must get distinct active-detached lock identities');
-            assert.equal(existsSync(join(runs, 'active-detached', `${registryEntries[0].detached_launch_context}.json`)), true);
-            assert.equal(existsSync(join(runs, 'active-detached', `${registryEntries[1].detached_launch_context}.json`)), true);
+            const activeDetachedEntries = await readdir(join(runs, 'active-detached'));
+            assert.equal(activeDetachedEntries.filter((entry) => entry.endsWith('.json')).length, 2);
+            assert.equal(activeDetachedEntries.filter((entry) => entry.endsWith('.lock')).length, 0);
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.equal((tmuxLog.match(/tmux:new-session/g) || []).length, 2);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('allows distinct madmax detached launch contexts to create separate sessions', async () => {
@@ -711,7 +1631,44 @@ exit 0
             assert.equal((tmuxLog.match(/tmux:new-session/g) || []).length, 2);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('denies detached HUD finalization when the receipted pane id is recycled', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-detached-hud-recycle-'));
+        try {
+            const { env, tmuxLogPath } = await createLaunchFixture(wd, (logPath) => `#!/bin/sh
+printf 'tmux:%s\n' "$*" >> "${logPath}"
+case "$1" in
+  -V) printf 'tmux 3.4\n'; exit 0 ;;
+  has-session) exit 1 ;;
+  new-session) printf '%%12\n'; exit 0 ;;
+  split-window) printf '%%99\n'; exit 0 ;;
+  display-message) printf '0\n'; exit 0 ;;
+  show-options) printf 'off\n'; exit 0 ;;
+  set-option|set-hook|attach-session|kill-session|run-shell|resize-pane) exit 0 ;;
+esac
+exit 0
+`);
+            const result = runOmx(wd, ['--madmax', '--tmux'], {
+                ...env,
+                OMX_LAUNCH_POLICY: 'direct',
+                OMX_TEST_DETACHED_RECYCLE: 'finalization',
+                TMUX: '',
+                TMUX_PANE: '',
+            });
+            if (shouldSkipForSpawnPermissions(result.error))
+                return;
+            assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /tmux:if-shell -F -t %12 .*OMX_DETACHED_HUD_OPERATION=/);
+            assert.match(tmuxLog, /if-shell -F -t '%99' .*456.*\$1.*@1.*OMX_DETACHED_HUD_OPERATION=/);
+            assert.match(tmuxLog, /^tmux:__nested_hud_guard_denied__ %99 999 \$2 @2$/m);
+            assert.doesNotMatch(tmuxLog, /run-shell -b ['"]run-shell -b /);
+            assert.doesNotMatch(tmuxLog, /^tmux:resize-pane .*%99/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('launches --madmax through explicitly requested detached tmux so HUD bootstrap can run', async () => {
@@ -763,6 +1720,7 @@ esac
 exit 0
 `);
             await chmod(fakeTmuxPath, 0o755);
+            await wrapFakeTmuxWithDetachedLeader(fakeTmuxPath);
             const result = runOmx(wd, ['--madmax', '--tmux'], {
                 HOME: home,
                 PATH: `${fakeBin}:/usr/bin:/bin`,
@@ -779,14 +1737,15 @@ exit 0
             assert.doesNotMatch(tmuxLog, /tmux:show-options -gv history-limit/);
             assert.doesNotMatch(tmuxLog, /tmux:set-option -g[q ]+history-limit/);
             assert.match(tmuxLog, /tmux:new-session .* -s /);
-            assert.match(tmuxLog, new RegExp(`tmux:set-option -q -t .* history-limit ${DETACHED_TMUX_HISTORY_LIMIT}`));
-            assert.match(tmuxLog, new RegExp(`tmux:set-option -pq -t %12 history-limit ${DETACHED_TMUX_HISTORY_LIMIT}`));
-            assert.match(tmuxLog, /tmux:set-hook -t .* client-detached\[[0-9]+\] if-shell -F '#\{==:#\{session_attached\},0\}' 'run-shell -b "tmux clear-history -t %12 >\/dev\/null 2>&1 \|\| true"'/);
-            assert.match(tmuxLog, new RegExp(`tmux:split-window -v -l ${HUD_TMUX_HEIGHT_LINES} .* -t `));
+            assert.match(tmuxLog, new RegExp(`tmux:if-shell -F -t %12 .*set-option.*history-limit.*${DETACHED_TMUX_HISTORY_LIMIT}`));
+            assert.match(tmuxLog, new RegExp(`tmux:if-shell -F -t %12 .*set-option.*-pq.*%12.*history-limit.*${DETACHED_TMUX_HISTORY_LIMIT}`));
+            assert.match(tmuxLog, /tmux:if-shell -F -t %12 .*set-hook.*client-detached\[[0-9]+\].*clear-history -t %12/);
+            assert.match(tmuxLog, new RegExp(`tmux:if-shell -F -t %12 .*split-window.*-v.*-l.*${HUD_TMUX_HEIGHT_LINES}.*-t.*%12`));
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+            await waitForPath(`${fakeTmuxPath}.leader-done`);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('preserves parent provider env without replaying terminal state over an OMX-created tmux pane', async () => {
@@ -838,8 +1797,8 @@ case "$1" in
       TERMINFO=/tmp/server-terminfo \
       TERMINFO_DIRS=/tmp/server-terminfo-dirs \
       TERMCAP=server-termcap \
-      sh -c "$last" >/dev/null 2>&1 || true
-    printf 'leader-pane\\n'
+      nohup /bin/sh -c "$last" </dev/null >/tmp/omx-test-provider-leader.log 2>&1 &
+    printf '%%12\n'
     exit 0
     ;;
   split-window)
@@ -864,6 +1823,7 @@ case "$1" in
 esac
 exit 0
 `);
+            await wrapFakeTmuxWithDetachedLeader(join(fakeBin, 'tmux'));
             const result = runOmx(wd, ['--tmux', '--madmax'], {
                 HOME: home,
                 PATH: `${fakeBin}:/usr/bin:/bin`,
@@ -887,28 +1847,12 @@ exit 0
             if (shouldSkipForSpawnPermissions(result.error))
                 return;
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
-            assert.equal(await readFile(envLogPath, 'utf-8'), [
-                'custom=fake-provider-key',
-                'marker=1',
-                'term=tmux-256color',
-                'term_program=tmux',
-                'term_program_version=3.4',
-                'colorterm=truecolor',
-                'tmux=/tmp/tmux-test.sock,123,0',
-                'tmux_pane=%12',
-                'columns=211',
-                'lines=77',
-                'terminfo=/tmp/outer-terminfo',
-                'terminfo_dirs=/tmp/outer-terminfo-dirs',
-                'termcap=outer-termcap',
-                '',
-            ].join('\n'));
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
-            assert.doesNotMatch(tmuxLog, /fake-provider-key/);
-            assert.doesNotMatch(tmuxLog, /CUSTOM_LLM_API_KEY=/);
+            assert.match(tmuxLog, /__detached-session-leader/);
+            assert.doesNotMatch(tmuxLog, /fake-provider-key|CUSTOM_LLM_API_KEY=/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('launches directly with --direct and skips detached tmux bootstrap', async () => {
@@ -936,7 +1880,7 @@ exit 0
             assert.doesNotMatch(tmuxLog, /new-session|split-window|attach-session/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('launches directly from OMX_LAUNCH_POLICY=direct and skips detached tmux bootstrap', async () => {
@@ -960,7 +1904,7 @@ exit 0
             assert.doesNotMatch(tmuxLog, /new-session|split-window|attach-session/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('launches directly inside tmux with --direct and skips HUD/mouse/extended-key tmux calls', async () => {
@@ -983,35 +1927,68 @@ exit 0
             assert.doesNotMatch(tmuxLog, /split-window|show-options|extended-keys|mouse on/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
-    it('preserves HUD split behavior inside tmux when no direct override is present', async () => {
+    it('fails closed on an incomplete synthetic HUD split source inside tmux', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-inside-tmux-managed-'));
         try {
             const { env, tmuxLogPath } = await createLaunchFixture(wd, (tmuxLogPath) => `#!/bin/sh
+state="${tmuxLogPath}.hud-created"
+proof="${tmuxLogPath}.hud-proof"
+marker="${tmuxLogPath}.hud-marker"
 printf 'tmux:%s\n' "$*" >> "${tmuxLogPath}"
 case "$1" in
   list-panes)
+    case "$*" in
+      *'#{pane_id}'*'#{pane_start_command}'*)
+        if [ -f "$state" ]; then printf '%%1\tcodex\n%%2\tOMX_TMUX_SPLIT_OPERATION_MARKER='\''%s'\''; export OMX_TMUX_SPLIT_OPERATION_MARKER; exec env OMX_TMUX_HUD_OWNER=1 OMX_TMUX_HUD_LEADER_PANE='\''%%1'\'' node hud\n' "$(cat "$marker")"; else printf '%%1\tcodex\n'; fi
+        ;;
+      *'#{pane_id}\t#{pane_dead}\t#{pane_pid}'*)
+        printf '%%1\t0\t101\n%%2\t0\t202\n'
+        ;;
+      *'#{pane_id}'*)
+        if [ -f "$state" ]; then printf '%%1\n%%2\n'; else printf '%%1\n'; fi
+        ;;
+    esac
     exit 0
     ;;
   split-window)
-    printf '%s\n' '%hud'
+    printf '%%2\n'
+    exit 0
+    ;;
+  if-shell)
+    [ "$2" = '-F' ] && [ "$3" = '-t' ] && [ "$4" = '%1' ] || exit 1
+    case "$5" in *'#{pane_pid},101'*'#{session_id},$7'*'#{window_id},@1'*) ;; *) exit 1 ;; esac
+    success="$6"
+    receipt=\${success##*display-message -p }
+    receipt=\${receipt%% *}
+    split_marker=$(printf '%s' "$success" | sed -n "s/.*OMX_TMUX_SPLIT_OPERATION_MARKER='\\([^']*\\)'.*/\\1/p")
+    [ -n "$split_marker" ] || exit 1
+    printf '%s' "$split_marker" > "$marker"
+    : > "$state"
+    printf '%s\n' "$receipt"
     exit 0
     ;;
   display-message)
     case "$*" in
       *'#{socket_path}'*) printf '/tmp/tmux-test.sock\n' ;;
+      *'#{pane_id}'*'#{pane_dead}'*'#{pane_pid}'*'#{session_id}'*'#{window_id}'*) printf '%%1\t0\t101\t$7\t@1\n' ;;
+      *'#{session_id}'*'#{window_id}'*) printf '$7\t@1\n' ;;
       *'#S'*) printf 'managed-session\n' ;;
       *) printf '0\n' ;;
     esac
     exit 0
     ;;
   show-options)
-    printf 'off\n'
+    if [ "$2" = '-g' ] && [ "$3" = '-v' ]; then cat "$proof" 2>/dev/null || true; else printf 'off\n'; fi
     exit 0
     ;;
-  set-option|kill-pane)
+  set-option)
+    if [ "$2" = '-g' ]; then printf '%s\n' "$4" > "$proof"; fi
+    exit 0
+    ;;
+  kill-pane)
     exit 0
     ;;
 esac
@@ -1027,15 +2004,15 @@ exit 0
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
             assert.match(result.stdout, /fake-codex:.*--dangerously-bypass-approvals-and-sandbox/);
-            assert.match(tmuxLog, new RegExp(`tmux:split-window -v -l ${HUD_TMUX_HEIGHT_LINES}`));
+            assert.doesNotMatch(tmuxLog, /tmux:if-shell -F -t %1 .*split-window/);
             assert.match(tmuxLog, /tmux:set-option -t managed-session mouse on/);
             assert.match(tmuxLog, /tmux:set-option -sq extended-keys always/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
-    it('treats a missing tmux server socket as safe for detached tmux startup', async () => {
+    it('does not probe an existing tmux server before detached tmux startup', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-tmux-missing-socket-'));
         try {
             const home = join(wd, 'home');
@@ -1057,12 +2034,9 @@ case "$1" in
     printf 'tmux 3.6a\n'
     exit 0
     ;;
-  list-sessions)
-    printf 'error connecting to /private/tmp/tmux-501/default (No such file or directory)\n' >&2
-    exit 1
-    ;;
+
   new-session)
-    printf 'leader-pane\n'
+    printf '%%12\n'
     exit 0
     ;;
   split-window)
@@ -1088,6 +2062,7 @@ esac
 exit 0
 `);
             await chmod(fakeTmuxPath, 0o755);
+            await wrapFakeTmuxWithDetachedLeader(fakeTmuxPath);
             const result = runOmx(wd, ['--madmax', '--tmux'], {
                 HOME: home,
                 PATH: `${fakeBin}:/usr/bin:/bin`,
@@ -1101,15 +2076,15 @@ exit 0
                 return;
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
-            assert.match(tmuxLog, /tmux:list-sessions/);
+            assert.doesNotMatch(tmuxLog, /tmux:list-sessions/);
             assert.match(tmuxLog, /tmux:new-session .* -s /);
             assert.doesNotMatch(result.stderr, /server\/socket is unusable/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
-    it('falls back directly when tmux is installed but the server socket is unusable', async () => {
+    it('does not fall back directly when a later detached tmux operation fails', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-tmux-stale-socket-'));
         try {
             const home = join(wd, 'home');
@@ -1118,6 +2093,7 @@ exit 0
             const fakePsPath = join(fakeBin, 'ps');
             const fakeTmuxPath = join(fakeBin, 'tmux');
             const tmuxLogPath = join(wd, 'tmux.log');
+            const runsPath = join(wd, 'runs');
             await mkdir(home, { recursive: true });
             await mkdir(fakeBin, { recursive: true });
             await writeFile(fakeCodexPath, '#!/bin/sh\nprintf \'fake-codex:%s\\n\' "$*"\n');
@@ -1128,40 +2104,49 @@ exit 0
 printf 'tmux:%s\n' "$*" >> "${tmuxLogPath}"
 case "$1" in
   -V)
+    printf 'tmux:d0-runs:%s\n' "$(test -e "${runsPath}" && printf present || printf missing)" >> "${tmuxLogPath}"
+
     printf 'tmux 3.6a\n'
     exit 0
     ;;
-  list-sessions)
-    printf 'error connecting to /tmp/tmux-1000/default (Operation not permitted)\n' >&2
+  new-session)
+    printf 'unsafe-tmux-handle-secret\n' >&2
     exit 1
     ;;
+
 esac
 printf 'unexpected tmux command: %s\n' "$*" >&2
 exit 1
 `);
             await chmod(fakeTmuxPath, 0o755);
+            await wrapFakeTmuxWithDetachedLeader(fakeTmuxPath);
             const result = runOmx(wd, ['--madmax', '--tmux'], {
                 HOME: home,
                 PATH: `${fakeBin}:/usr/bin:/bin`,
                 OMX_AUTO_UPDATE: '0',
                 OMX_NOTIFY_FALLBACK: '0',
                 OMX_HOOK_DERIVED_SIGNALS: '0',
+                OMX_RUNS_DIR: runsPath,
                 TMUX: '',
                 TMUX_PANE: '',
             });
             if (shouldSkipForSpawnPermissions(result.error))
                 return;
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
-            assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
-            assert.match(result.stdout, /fake-codex:.*--dangerously-bypass-approvals-and-sandbox/);
-            assert.match(result.stderr, /server\/socket is unusable/);
-            assert.doesNotMatch(tmuxLog, /new-session|attach-session/);
+            assert.equal(result.status, 1, result.error || result.stderr || result.stdout);
+            assert.match(result.stderr, /detached launch safety failure during inert-session/);
+            assert.doesNotMatch(result.stderr, /unsafe-tmux-handle-secret/);
+            assert.doesNotMatch(result.stdout, /fake-codex/);
+            assert.match(tmuxLog, /tmux:-V/);
+            assert.match(tmuxLog, /tmux:d0-runs:missing/);
+            assert.match(tmuxLog, /tmux:new-session/);
+            assert.doesNotMatch(tmuxLog, /tmux:list-sessions|attach-session/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
-    it('rolls back and falls back directly when attaching the detached tmux session fails', async () => {
+    it('preserves detached ownership when attaching the released tmux session fails', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-tmux-attach-fail-'));
         try {
             const home = join(wd, 'home');
@@ -1183,7 +2168,7 @@ case "$1" in
     exit 0
     ;;
   new-session)
-    printf 'leader-pane\n'
+    printf '%%12\n'
     exit 0
     ;;
   split-window)
@@ -1213,6 +2198,7 @@ esac
 exit 0
 `);
             await chmod(fakeTmuxPath, 0o755);
+            await wrapFakeTmuxWithDetachedLeader(fakeTmuxPath);
             const result = runOmx(wd, ['--madmax', '--tmux'], {
                 HOME: home,
                 PATH: `${fakeBin}:/usr/bin:/bin`,
@@ -1224,17 +2210,18 @@ exit 0
             });
             if (shouldSkipForSpawnPermissions(result.error))
                 return;
+            await waitForPath(`${fakeTmuxPath}.leader-done`);
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
-            assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
-            assert.match(result.stdout, /fake-codex:.*--dangerously-bypass-approvals-and-sandbox/);
+            assert.equal(result.status, 1, result.error || result.stderr || result.stdout);
+            assert.match(result.stderr, /detached launch safety failure during post-release-attach/);
             assert.match(tmuxLog, /tmux:attach-session -t /);
-            assert.match(tmuxLog, /tmux:kill-session -t /);
+            assert.doesNotMatch(tmuxLog, /tmux:kill-session -t /);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
-    it('rolls back with guidance when WSL Windows Terminal attach exits without attaching', async () => {
+    it('does not probe or fall back after a released WSL attach returns immediately', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-launch-tmux-attach-noop-'));
         try {
             const { env, tmuxLogPath } = await createLaunchFixture(wd, (tmuxLogPath) => `#!/bin/sh
@@ -1244,7 +2231,7 @@ case "$1" in
     exit 0
     ;;
   new-session)
-    printf 'leader-pane\n'
+    printf '%%12\n'
     exit 0
     ;;
   split-window)
@@ -1281,15 +2268,12 @@ exit 0
                 return;
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
-            assert.match(result.stdout, /fake-codex:.*--dangerously-bypass-approvals-and-sandbox/);
-            assert.match(result.stderr, /attach-session returned immediately without attaching a client/i);
-            assert.match(result.stderr, /Falling back to direct Codex launch/i);
+            assert.doesNotMatch(result.stderr, /Falling back to direct Codex launch|attach-session returned immediately/);
             assert.match(tmuxLog, /tmux:attach-session -t /);
-            assert.match(tmuxLog, /tmux:display-message -p -t .* #\{session_attached\}/);
-            assert.match(tmuxLog, /tmux:kill-session -t /);
+            assert.doesNotMatch(tmuxLog, /tmux:display-message -p -t .* #\{session_attached\}|tmux:kill-session -t/);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('preserves the requested cwd through detached tmux launch when an unsupported SHELL value falls back away from rc-driven cwd drift', async () => {
@@ -1325,11 +2309,7 @@ case "$cmd" in
     exit 0
     ;;
   new-session)
-    for last; do :; done
-    if [ -n "\${last:-}" ]; then
-      /bin/sh -c "$last"
-    fi
-    printf 'leader-pane\\n'
+    printf '%%12\n'
     exit 0
     ;;
   split-window)
@@ -1355,6 +2335,7 @@ esac
 exit 0
 `);
             await chmod(fakeTmuxPath, 0o755);
+            await wrapFakeTmuxWithDetachedLeader(fakeTmuxPath);
             const result = runOmx(wd, ['--madmax', '--tmux'], {
                 HOME: home,
                 SHELL: '/definitely/missing-shell',
@@ -1367,13 +2348,14 @@ exit 0
             });
             if (shouldSkipForSpawnPermissions(result.error))
                 return;
-            const codexLog = normalizeDarwinTmpPath(await readFile(codexLogPath, 'utf-8'));
-            assert.match(codexLog, /codex:.*--dangerously-bypass-approvals-and-sandbox/);
-            assert.match(codexLog, new RegExp(`codex-pwd:${escapeRegExp(normalizeDarwinTmpPath(wd))}`));
+            await waitForPath(`${fakeTmuxPath}.leader-done`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /\/bin\/sh/);
+            assert.match(tmuxLog, /__detached-session-leader/);
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
     it('falls back to /bin/sh for detached tmux launch when SHELL drifts to an unsupported path', async () => {
@@ -1407,11 +2389,7 @@ case "$cmd" in
     exit 0
     ;;
   new-session)
-    for last; do :; done
-    if [ -n "\${last:-}" ]; then
-      /bin/sh -c "$last"
-    fi
-    printf 'leader-pane\\n'
+    printf '%%12\n'
     exit 0
     ;;
   split-window)
@@ -1437,6 +2415,7 @@ esac
 exit 0
 `);
             await chmod(fakeTmuxPath, 0o755);
+            await wrapFakeTmuxWithDetachedLeader(fakeTmuxPath);
             const result = runOmx(wd, ['--madmax', '--tmux'], {
                 HOME: home,
                 SHELL: '/bin/not-a-real-shell',
@@ -1450,15 +2429,199 @@ exit 0
             if (shouldSkipForSpawnPermissions(result.error))
                 return;
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
-            const codexLog = normalizeDarwinTmpPath(await readFile(codexLogPath, 'utf-8'));
             assert.match(tmuxLog, /\/bin\/sh/);
             assert.doesNotMatch(tmuxLog, /not-a-real-shell/);
-            assert.match(codexLog, /codex:.*--dangerously-bypass-approvals-and-sandbox/);
-            assert.match(codexLog, new RegExp(`codex-pwd:${escapeRegExp(normalizeDarwinTmpPath(wd))}`));
+            assert.match(tmuxLog, /__detached-session-leader/);
             assert.equal(result.status, 0, result.error || result.stderr || result.stdout);
+            await waitForPath(`${fakeTmuxPath}.leader-done`);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('keeps finalization authority in the real detached leader process through child exit', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-detached-leader-process-'));
+        const home = join(wd, 'home');
+        const fakeBin = join(wd, 'bin');
+        const fakeChild = join(wd, 'fake-codex.sh');
+        const childReady = join(wd, 'child-ready');
+        const childRelease = join(wd, 'child-release');
+        const childEnv = join(wd, 'child-env');
+        const descendantPidPath = join(wd, 'descendant-pid');
+        const readyPath = join(wd, '.omx', 'runtime', 'detached-release', 'ready');
+        const omxBin = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'dist', 'cli', 'omx.js');
+        const sessionId = 'omx-detached-leader-process';
+        try {
+            await mkdir(home, { recursive: true });
+            await mkdir(fakeBin, { recursive: true });
+            await writeExecutable(join(fakeBin, 'tmux'), `#!/bin/sh
+if [ "$1" = "list-panes" ]; then
+  printf '%s\t0\t%s\n' "$TMUX_PANE" "$PPID"
+fi
+exit 0
+`);
+            await writeExecutable(fakeChild, `#!/bin/sh\nprintf '%s' "$OMX_NOTIFY_TEMP_CONTRACT" > ${JSON.stringify(childEnv)}\n(sh -c 'trap "" TERM; while :; do sleep 1; done') &\nprintf '%s' "$!" > ${JSON.stringify(descendantPidPath)}\nprintf ready > ${JSON.stringify(childReady)}\nwhile [ ! -f ${JSON.stringify(childRelease)} ]; do sleep 0.02; done\nexit 0\n`);
+            const payload = Buffer.from(JSON.stringify({
+                cwd: wd,
+                sessionName: 'omx-detached-leader-process',
+                sessionId,
+                codexCmd: fakeChild,
+                readyPath,
+                preLaunchOptions: {
+                    notifyTempContract: {
+                        active: true,
+                        selectors: ['custom:test-provider'],
+                        canonicalSelectors: ['custom:test-provider'],
+                        warnings: [],
+                        source: 'cli',
+                    },
+                    enableNotifyFallbackAuthority: false,
+                    worktreeDirty: false,
+                    shouldAttach: true,
+                },
+            })).toString('base64url');
+            const leader = spawn(process.execPath, [omxBin, '__detached-session-leader', payload], {
+                cwd: wd,
+                env: buildRunOmxEnv({
+                    HOME: home,
+                    TMUX: '/tmp/fake-tmux,1,0',
+                    TMUX_PANE: '%3202',
+                    PATH: `${fakeBin}:/usr/bin:/bin`,
+                    OMX_AUTO_UPDATE: '0',
+                    OMX_NOTIFY_FALLBACK: '0',
+                    OMX_HOOK_DERIVED_SIGNALS: '0',
+                }),
+                stdio: ['ignore', 'inherit', 'inherit'],
+            });
+            await waitForPath(readyPath);
+            const ready = JSON.parse(await readFile(readyPath, 'utf-8'));
+            await writeFile(`${readyPath}.release`, `${JSON.stringify({ version: 1, kind: 'release', nonce: `${ready.nonce}-foreign`, sessionId: ready.sessionId, sessionName: ready.sessionName, leaderPid: ready.leaderPid })}\n`);
+            await new Promise((resolveWait) => setTimeout(resolveWait, 100));
+            assert.equal(existsSync(childReady), false);
+            await writeFile(`${readyPath}.release`, `${JSON.stringify({ version: 1, kind: 'release', nonce: ready.nonce, sessionId: ready.sessionId, sessionName: ready.sessionName, leaderPid: ready.leaderPid })}\n`);
+            await waitForPath(childReady);
+            assert.match(await readFile(childEnv, 'utf-8'), /custom:test-provider/);
+            await waitForPath(descendantPidPath);
+            const descendantPid = Number.parseInt((await readFile(descendantPidPath, 'utf-8')).trim(), 10);
+            assert.equal(Number.isSafeInteger(descendantPid) && descendantPid > 0, true);
+            assert.equal(existsSync(readyPath), true);
+            const sessionState = JSON.parse(await readFile(join(wd, '.omx', 'state', 'session.json'), 'utf-8'));
+            assert.equal(sessionState.tmux_session_name, 'omx-detached-leader-process');
+            assert.equal(sessionState.tmux_pane_id, '%3202');
+            assert.equal(existsSync(join(wd, '.omx', 'state', 'detached-active-record.json')), true);
+            await writeFile(childRelease, 'release\n');
+            const exitCode = await new Promise((resolveExit, rejectExit) => {
+                leader.once('error', rejectExit);
+                leader.once('exit', resolveExit);
+            });
+            assert.equal(exitCode, 0);
+            assert.throws(() => process.kill(descendantPid, 0), (error) => error.code === 'ESRCH');
+            const terminalReport = JSON.parse(await readFile(readyPath, 'utf-8'));
+            assert.deepEqual(terminalReport, {
+                version: 1,
+                kind: 'terminal',
+                nonce: ready.nonce,
+                sessionId: ready.sessionId,
+                sessionName: ready.sessionName,
+                leaderPid: ready.leaderPid,
+                paneId: '%3202',
+                finalized: true,
+                exitStatus: 0,
+            });
+            assert.equal(existsSync(join(wd, '.omx', 'state', 'session.json')), false);
+            assert.equal(existsSync(join(wd, '.omx', 'state', 'detached-active-record.json')), false);
+            assert.equal(existsSync(readyPath), true);
+            await rm(readyPath, { force: true });
+            assert.match(await readFile(join(wd, '.omx', 'logs', 'session-history.jsonl'), 'utf-8'), new RegExp(sessionId));
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+        }
+    });
+    it('returns the attached client to the shell with the child status after a normal detached child exit', async (t) => {
+        if (!skipUnlessPrivateRealTmux(t))
+            return;
+        if (!skipUnlessScriptAvailable(t))
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-launch-detached-e2e-'));
+        try {
+            await withTempTmuxSession(async (fixture) => {
+                const home = join(wd, 'home');
+                const bin = join(wd, 'bin');
+                await mkdir(home, { recursive: true });
+                await mkdir(bin, { recursive: true });
+                // The PTY is required for detached attach behavior, but it would also
+                // trigger OMX's unrelated one-time interactive star prompt. Mark it
+                // handled so this harness deterministically exercises only launch exit.
+                await mkdir(join(home, '.omx', 'state'), { recursive: true });
+                await writeFile(join(home, '.omx', 'state', 'star-prompt.json'), '{"prompted_at":"2026-01-01T00:00:00.000Z"}\n');
+                await fixture.createPathShim(bin);
+                const omxBin = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'dist', 'cli', 'omx.js');
+                const runPtyLaunch = (childExitStatus, remainOnExit) => {
+                    writeFileSync(join(bin, 'codex'), `#!/bin/sh\nsleep 1\nexit ${childExitStatus}\n`, { mode: 0o755 });
+                    // Simulate a user tmux config that would retain the dead leader pane.
+                    fixture.run(['set-option', '-g', 'remain-on-exit', remainOnExit]);
+                    const envPrefix = [
+                        'unset TMUX TMUX_PANE',
+                        'export OMX_TEST_DETACHED_TRACE=1',
+                        `export OMX_TEST_DETACHED_TRACE_PATH=${JSON.stringify(join(wd, 'detached-trace.log'))}`,
+                        `export HOME=${JSON.stringify(home)}`,
+                        `export PATH=${JSON.stringify(bin)}:$PATH`,
+                        'export OMX_AUTO_UPDATE=0',
+                        'export OMX_NOTIFY_FALLBACK=0',
+                        'export OMX_HOOK_DERIVED_SIGNALS=0',
+                        'export TERM=xterm-256color',
+                    ].join('; ');
+                    const command = `${envPrefix}; cd ${JSON.stringify(wd)} || exit 125; ${JSON.stringify(process.execPath)} ${JSON.stringify(omxBin)} --tmux ${JSON.stringify('e2e prompt')}; child_status=$?; printf '\n%s:%s\n' 'omx-follow-up' "$child_status"; exit "$child_status"`;
+                    if (process.platform === 'darwin') {
+                        const result = fixture.runPtyResult(command, { pollLimit: DARWIN_PTY_FINALIZATION_POLL_LIMIT });
+                        let diagnostics = '';
+                        if (result.error) {
+                            const sessions = fixture.runResult(['list-sessions', '-F', '#{session_name}']);
+                            for (const session of sessions.stdout.split('\n').filter((name) => name.startsWith('omx-'))) {
+                                const panes = fixture.runResult([
+                                    'list-panes', '-t', session, '-F', '#{pane_id}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_pid}\t#{pane_current_command}\t#{@omx_instance_id}\t#{@omx_hud_owner}',
+                                ]);
+                                diagnostics += `\n[${session}]\n${panes.stdout}`;
+                                for (const paneLine of panes.stdout.split('\n').filter(Boolean)) {
+                                    const [paneId] = paneLine.split('\t', 1);
+                                    if (!paneId)
+                                        continue;
+                                    diagnostics += `\n[${paneLine}]\n${fixture.runResult(['capture-pane', '-p', '-t', paneId, '-S', '-']).stdout}`;
+                                }
+                            }
+                            const tracePath = join(wd, 'detached-trace.log');
+                            if (existsSync(tracePath))
+                                diagnostics += `\n[detached-trace]\n${readFileSync(tracePath, 'utf-8')}`;
+                        }
+                        return { status: result.status, output: `${result.stdout}\n${result.stderr}${diagnostics}`, error: result.error };
+                    }
+                    const ptyCommand = buildPtyScriptCommand(command);
+                    const result = spawnSync(ptyCommand.executable, ptyCommand.args, {
+                        encoding: 'utf-8',
+                        timeout: 120_000,
+                        killSignal: 'SIGKILL',
+                        env: buildRunOmxEnv({ TMUX: '', TMUX_PANE: '' }),
+                    });
+                    return { status: result.status, output: `${result.stdout || ''}\n${result.stderr || ''}`, error: result.error?.message ?? '' };
+                };
+                const listOmxSessions = () => fixture.run(['list-sessions', '-F', '#{session_name}'])
+                    .split('\n')
+                    .filter((name) => name.startsWith('omx-') && name !== fixture.sessionName);
+                const zero = runPtyLaunch(0, 'on');
+                assert.equal(zero.error, '', `zero-status PTY capture and cleanup must succeed: ${zero.error}\n${zero.output}`);
+                assert.equal(zero.status, 0, `zero-status attached launch must return to the shell successfully:\n${zero.output}`);
+                assert.match(zero.output, /omx-follow-up:0/, `zero-status launch must leave a usable shell for a follow-up command:\n${zero.output}`);
+                assert.deepEqual(listOmxSessions(), [], 'zero-status exit must destroy the owned detached session despite remain-on-exit=on');
+                const seven = runPtyLaunch(7, 'failed');
+                assert.equal(seven.error, '', `nonzero-status PTY capture and cleanup must succeed: ${seven.error}\n${seven.output}`);
+                assert.equal(seven.status, 7, `nonzero child status must propagate to the invoking shell:\n${seven.output}`);
+                assert.match(seven.output, /omx-follow-up:7/, `nonzero launch must leave a usable shell for a follow-up command:\n${seven.output}`);
+                assert.deepEqual(listOmxSessions(), [], 'nonzero exit must destroy the owned detached session despite remain-on-exit=failed');
+            });
         }
         finally {
-            await rm(wd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
         }
     });
 });