oh-my-codex 0.18.6 → 0.18.8

package/dist/cli/index.js

@@ -8,7 +8,7 @@ import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync }
 import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, symlink, writeFile } from "fs/promises";
 import { constants as osConstants, homedir } from "os";
 import { createHash } from "crypto";
-import { setup, SETUP_MCP_MODES, SETUP_SCOPES, } from "./setup.js";
+import { setup, SETUP_MCP_MODES, SETUP_SCOPES, SETUP_TEAM_MODES, } from "./setup.js";
 import { uninstall } from "./uninstall.js";
 import { version } from "./version.js";
 import { tmuxHookCommand } from "./tmux-hook.js";
@@ -54,8 +54,8 @@ import { codexConfigPath, omxRoot, rememberOmxLaunchContext, resolveOmxEntryPath
 import { cleanCodexModelAvailabilityNuxIfNeeded, extractSharedMcpRegistryServersFromConfig, repairConfigIfNeeded, repairProjectScopeTrustStateForLaunch, syncProjectScopeTrustStateFromRuntime } from "../config/generator.js";
 import { OMX_FIRST_PARTY_MCP_SERVER_NAMES } from "../config/omx-first-party-mcp.js";
 import { HUD_TMUX_HEIGHT_LINES } from "../hud/constants.js";
-import { OMX_TMUX_HUD_OWNER_ENV } from "../hud/reconcile.js";
-import { createHudWatchPane as createSharedHudWatchPane, killTmuxPane as killSharedTmuxPane, listCurrentWindowHudPaneIds, listCurrentWindowPanes, OMX_TMUX_HUD_LEADER_PANE_ENV, parsePaneIdFromTmuxOutput, reapDeadHudPanes, registerHudResizeHook, } from "../hud/tmux.js";
+import { readUltragoalState } from "../hud/state.js";
+import { createHudWatchPane as createSharedHudWatchPane, killTmuxPane as killSharedTmuxPane, listCurrentWindowHudPaneIds, listCurrentWindowPanes, buildHudRuntimeEnv, parsePaneIdFromTmuxOutput, reapDeadHudPanes, registerHudResizeHook, resizeTmuxPane, } from "../hud/tmux.js";
 export { parseTmuxPaneSnapshot, isHudWatchPane, findHudWatchPaneIds } from "../hud/tmux.js";
 rememberOmxLaunchContext();
 import { classifySpawnError, resolveTmuxBinaryForPlatform, spawnPlatformCommandSync, } from "../utils/platform-command.js";
@@ -177,6 +177,11 @@ Options:
                 Explicit setup MCP mode (default: none; compat enables first-party MCP compatibility and shared registry sync)
   --no-mcp      Alias for --mcp=none
   --with-mcp    Alias for --mcp=compat
+  --disable-team
+                Disable Team skill/context generation for setup (default remains enabled)
+  --enable-team Re-enable Team skill/context generation for setup
+  --team-mode <enabled|disabled>
+                Explicit Team setup mode
   --keep-config Skip config.toml cleanup during uninstall
   --purge       Remove .omx/ cache directory during uninstall
   --verbose     Show detailed output
@@ -367,6 +372,45 @@ export function resolveSetupScopeArg(args) {
     }
     throw new Error(`Invalid setup scope: ${value}. Expected one of: ${SETUP_SCOPES.join(", ")}`);
 }
+export function resolveSetupTeamModeArg(args) {
+    let value;
+    const setValue = (next, source) => {
+        if (value && value !== next) {
+            throw new Error(`Conflicting setup Team mode flags: ${source} selects ${next}, but another flag already selected ${value}`);
+        }
+        value = next;
+    };
+    const parseValue = (next) => {
+        if (!SETUP_TEAM_MODES.includes(next)) {
+            throw new Error(`Invalid setup Team mode: ${next}. Expected one of: enabled, disabled`);
+        }
+        return next;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--disable-team" || arg === "--no-team") {
+            setValue("disabled", arg);
+            continue;
+        }
+        if (arg === "--enable-team" || arg === "--team") {
+            setValue("enabled", arg);
+            continue;
+        }
+        if (arg === "--team-mode") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup Team mode value after --team-mode. Expected one of: enabled, disabled`);
+            }
+            setValue(parseValue(next), arg);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--team-mode=")) {
+            setValue(parseValue(arg.slice("--team-mode=".length)), "--team-mode");
+        }
+    }
+    return value;
+}
 export function resolveCliInvocation(args) {
     const firstArg = args[0];
     if (firstArg === "--help" || firstArg === "-h") {
@@ -597,6 +641,75 @@ function execTmuxFileSync(args, options) {
         ...(process.platform === "win32" ? { windowsHide: true } : {}),
     });
 }
+export const DETACHED_TMUX_HISTORY_LIMIT = 500;
+const TMUX_HOOK_INDEX_MAX = 1_000_000;
+function setDetachedTmuxSessionHistoryLimit(sessionName, leaderPaneId) {
+    const boundedHistoryLimit = String(DETACHED_TMUX_HISTORY_LIMIT);
+    try {
+        execTmuxFileSync(["set-option", "-q", "-t", sessionName, "history-limit", boundedHistoryLimit], { stdio: "ignore" });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    if (!leaderPaneId)
+        return;
+    try {
+        execTmuxFileSync(["set-option", "-pq", "-t", leaderPaneId, "history-limit", boundedHistoryLimit], { stdio: "ignore" });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+}
+function clearDetachedTmuxSessionHistoryIfUnattached(sessionName, leaderPaneId) {
+    try {
+        const attached = execTmuxFileSync(["display-message", "-p", "-t", sessionName, "#{session_attached}"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim();
+        if (attached !== "0")
+            return;
+        execTmuxFileSync(["clear-history", "-t", leaderPaneId], {
+            stdio: "ignore",
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+}
+function readTmuxSessionInstanceId(sessionName) {
+    try {
+        return execTmuxFileSync(["show-options", "-qv", "-t", sessionName, OMX_INSTANCE_OPTION], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function tmuxPaneBelongsToSession(paneId, sessionName) {
+    try {
+        const paneSessionName = execTmuxFileSync(["display-message", "-p", "-t", paneId, "#{session_name}"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim();
+        return paneSessionName === sessionName;
+    }
+    catch {
+        return false;
+    }
+}
+function buildDetachedHistoryPruneHookCommand(leaderPaneId) {
+    return `if-shell -F '#{==:#{session_attached},0}' 'clear-history -t ${leaderPaneId}'`;
+}
+function buildDetachedHistoryPruneHookSlot(sessionName, leaderPaneId) {
+    const key = `${sessionName}:${leaderPaneId}:omx-history-prune`;
+    let hash = 0;
+    for (let i = 0; i < key.length; i++) {
+        hash = ((hash << 5) - hash + key.charCodeAt(i)) | 0;
+    }
+    return `client-detached[${Math.abs(hash) % TMUX_HOOK_INDEX_MAX}]`;
+}
 function hasErrnoCode(error, code) {
     return Boolean(error &&
         typeof error === "object" &&
@@ -825,6 +938,42 @@ export function resolveOmxRootForLaunch(cwd, env = process.env) {
         return undefined;
     return isCrossPlatformAbsolutePath(raw) ? raw : join(cwd, raw);
 }
+function resolveLaunchPath(cwd, raw) {
+    return isCrossPlatformAbsolutePath(raw) ? raw : join(cwd, raw);
+}
+function resolveHudRuntimeRootSource(omxRootOverride, env = process.env) {
+    if (env.OMX_TEAM_STATE_ROOT?.trim())
+        return 'team-env';
+    if (env.OMX_ROOT?.trim() || omxRootOverride)
+        return 'omx-root-env';
+    if (env.OMX_STATE_ROOT?.trim())
+        return 'omx-state-root-env';
+    return 'cwd-default';
+}
+export function resolveHudRuntimeRootForLaunch(cwd, env = process.env) {
+    const omxTeamStateRoot = env.OMX_TEAM_STATE_ROOT?.trim();
+    if (omxTeamStateRoot) {
+        return {
+            omxTeamStateRoot: resolveLaunchPath(cwd, omxTeamStateRoot),
+            rootSource: 'team-env',
+        };
+    }
+    const omxRoot = env.OMX_ROOT?.trim();
+    if (omxRoot) {
+        return {
+            omxRoot: resolveLaunchPath(cwd, omxRoot),
+            rootSource: 'omx-root-env',
+        };
+    }
+    const omxStateRoot = env.OMX_STATE_ROOT?.trim();
+    if (omxStateRoot) {
+        return {
+            omxStateRoot: resolveLaunchPath(cwd, omxStateRoot),
+            rootSource: 'omx-state-root-env',
+        };
+    }
+    return { rootSource: 'cwd-default' };
+}
 function hasExplicitOmxRootEnv(env = process.env) {
     return [env.OMX_ROOT, env.OMX_STATE_ROOT].some((value) => typeof value === "string" && value.trim() !== "");
 }
@@ -945,12 +1094,24 @@ function readMadmaxDetachedActiveRecord(recordPath) {
             argv: [...parsed.argv],
             run_dir: parsed.run_dir,
             tmux_session_name: parsed.tmux_session_name,
+            ...(typeof parsed.session_id === "string" ? { session_id: parsed.session_id } : {}),
+            ...(typeof parsed.tmux_pane_id === "string" ? { tmux_pane_id: parsed.tmux_pane_id } : {}),
         };
     }
     catch {
         return null;
     }
 }
+function isReusableMadmaxDetachedActiveRecord(record) {
+    if (!detachedTmuxSessionExists(record.tmux_session_name))
+        return false;
+    if (!record.session_id || !record.tmux_pane_id)
+        return false;
+    if (readTmuxSessionInstanceId(record.tmux_session_name) !== record.session_id) {
+        return false;
+    }
+    return tmuxPaneBelongsToSession(record.tmux_pane_id, record.tmux_session_name);
+}
 function detachedTmuxSessionExists(sessionName) {
     try {
         execTmuxFileSync(["has-session", "-t", sessionName], { stdio: "ignore" });
@@ -1198,6 +1359,7 @@ export async function main(args) {
                     scope: resolveSetupScopeArg(args.slice(1)),
                     installMode: resolveSetupInstallModeArg(args.slice(1)),
                     mcpMode: resolveSetupMcpModeArg(args.slice(1)),
+                    teamMode: resolveSetupTeamModeArg(args.slice(1)),
                 });
                 break;
             case "update":
@@ -1363,7 +1525,12 @@ async function showStatus() {
     try {
         const refs = await listModeStateFilesWithScopePreference(cwd);
         const states = refs.map((ref) => ref.path);
+        const ultragoalState = await readUltragoalState(cwd).catch(() => null);
         if (states.length === 0) {
+            if (ultragoalState?.active) {
+                console.log(`ultragoal: ACTIVE (phase: ${ultragoalState.status})`);
+                return;
+            }
             console.log("No active modes.");
             return;
         }
@@ -1379,8 +1546,13 @@ async function showStatus() {
             }
             const file = basename(path);
             const mode = file.replace("-state.json", "");
+            if (mode === "ultragoal" && ultragoalState?.active)
+                continue;
             console.log(`${mode}: ${state.active === true ? "ACTIVE" : "inactive"} (phase: ${String(state.current_phase || "n/a")})`);
         }
+        if (ultragoalState?.active) {
+            console.log(`ultragoal: ACTIVE (phase: ${ultragoalState.status})`);
+        }
     }
     catch (err) {
         logCliOperationFailure(err);
@@ -2248,6 +2420,7 @@ function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId
         "};",
         "trap omx_detached_session_cleanup 0 INT TERM HUP;",
         parentEnvSource,
+        "unset OMX_HERMES_MCP_BRIDGE;",
         "omx_codex_started_at=$(date +%s 2>/dev/null || printf 0);",
         `${codexCmd} <&3 &`,
         "omx_codex_pid=$!;",
@@ -2433,6 +2606,23 @@ export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, h
     const detachedLeaderCmd = nativeWindows
         ? "powershell.exe"
         : buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnvFilePath);
+    const resolvedEnvStateRoot = env.OMX_STATE_ROOT?.trim()
+        ? resolveLaunchPath(cwd, env.OMX_STATE_ROOT.trim())
+        : undefined;
+    const hasExplicitRootOverride = Boolean(env.OMX_ROOT?.trim()
+        || (omxRootOverride && omxRootOverride !== resolvedEnvStateRoot));
+    const hudRuntimeRoot = env.OMX_TEAM_STATE_ROOT?.trim()
+        ? resolveHudRuntimeRootForLaunch(cwd, env)
+        : hasExplicitRootOverride
+            ? {
+                omxRoot: omxRootOverride,
+                rootSource: resolveHudRuntimeRootSource(omxRootOverride, env),
+            }
+            : resolveHudRuntimeRootForLaunch(cwd, env);
+    const hudRuntimeEnv = buildHudRuntimeEnv({
+        sessionId,
+        ...hudRuntimeRoot,
+    }).env;
     const newSessionArgs = [
         "new-session",
         "-d",
@@ -2446,12 +2636,9 @@ export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, h
         ...(workerLaunchArgs
             ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`]
             : []),
-        ...(sessionId ? ["-e", `OMX_SESSION_ID=${sessionId}`] : []),
-        ...(sessionId ? ["-e", `${OMX_TMUX_HUD_OWNER_ENV}=1`] : []),
+        ...Object.entries(hudRuntimeEnv).map(([key, value]) => ["-e", `${key}=${value}`]).flat(),
         ...(codexHomeOverride ? ["-e", `CODEX_HOME=${codexHomeOverride}`] : []),
         ...(sqliteHomeOverride ? ["-e", `${CODEX_SQLITE_HOME_ENV}=${sqliteHomeOverride}`] : []),
-        ...(omxRootOverride ? ["-e", `OMX_ROOT=${omxRootOverride}`] : []),
-        ...(env.OMX_STATE_ROOT ? ["-e", `OMX_STATE_ROOT=${env.OMX_STATE_ROOT}`] : []),
         ...(env.OMXBOX_ACTIVE ? ["-e", `OMXBOX_ACTIVE=${env.OMXBOX_ACTIVE}`] : []),
         ...(env.OMX_SOURCE_CWD ? ["-e", `OMX_SOURCE_CWD=${env.OMX_SOURCE_CWD}`] : []),
         ...(notifyTempContractRaw
@@ -2501,8 +2688,27 @@ async function readLaunchAppendInstructions() {
     const { readFile } = await import("fs/promises");
     return (await readFile(appendixPath, "utf-8")).trim();
 }
-export function buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, enableMouse, nativeWindows = false) {
+export function shouldAttachDetachedTmuxSession(env = process.env) {
+    return env.OMX_HERMES_MCP_BRIDGE !== "1";
+}
+function stripHermesMcpBridgeEnv(env) {
+    const { OMX_HERMES_MCP_BRIDGE: _bridge, ...rest } = env;
+    return rest;
+}
+export function buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, enableMouse, nativeWindows = false, attachSession = true, leaderPaneId = null) {
     const steps = [];
+    if (!nativeWindows && leaderPaneId) {
+        steps.push({
+            name: "register-detached-history-prune-hook",
+            args: [
+                "set-hook",
+                "-t",
+                sessionName,
+                buildDetachedHistoryPruneHookSlot(sessionName, leaderPaneId),
+                buildDetachedHistoryPruneHookCommand(leaderPaneId),
+            ],
+        });
+    }
     if (!nativeWindows && hudPaneId && hookWindowIndex) {
         const hookTarget = buildResizeHookTarget(sessionName, hookWindowIndex);
         const hookName = buildResizeHookName("launch", sessionName, hookWindowIndex, hudPaneId);
@@ -2534,10 +2740,12 @@ export function buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWi
             args: [],
         });
     }
-    steps.push({
-        name: "attach-session",
-        args: ["attach-session", "-t", sessionName],
-    });
+    if (attachSession) {
+        steps.push({
+            name: "attach-session",
+            args: ["attach-session", "-t", sessionName],
+        });
+    }
     return steps;
 }
 export function buildDetachedSessionRollbackSteps(sessionName, hookTarget, hookName, clientAttachedHookName) {
@@ -3027,27 +3235,26 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
     }
     const omxRootOverride = resolveOmxRootForLaunch(cwd, process.env);
     const currentPaneId = process.env.TMUX_PANE;
-    const hudEnvArgs = [
-        `OMX_SESSION_ID=${sessionId}`,
-        `${OMX_TMUX_HUD_OWNER_ENV}=1`,
-        ...(currentPaneId ? [`${OMX_TMUX_HUD_LEADER_PANE_ENV}=${currentPaneId}`] : []),
-        ...(omxRootOverride ? [`OMX_ROOT=${omxRootOverride}`] : []),
-    ];
+    const hudRuntimeRoot = resolveHudRuntimeRootForLaunch(cwd, process.env);
+    const hudEnvArgs = Object.entries(buildHudRuntimeEnv({
+        sessionId,
+        leaderPaneId: currentPaneId,
+        ...hudRuntimeRoot,
+    }).env).map(([key, value]) => `${key}=${value}`);
     const hudCmd = nativeWindows
         ? buildWindowsPromptCommand("node", [omxBin, "hud", "--watch"])
         : buildTmuxPaneCommand("env", [...hudEnvArgs, "node", omxBin, "hud", "--watch"]);
     const inheritLeaderFlags = process.env[TEAM_INHERIT_LEADER_FLAGS_ENV] !== "0";
     const workerLaunchArgs = resolveTeamWorkerLaunchArgsEnv(process.env[TEAM_WORKER_LAUNCH_ARGS_ENV], launchArgs, inheritLeaderFlags, workerDefaultModel);
     const codexBaseEnv = {
-        ...process.env,
+        ...stripHermesMcpBridgeEnv(process.env),
         ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
         ...(sqliteHomeOverride ? { [CODEX_SQLITE_HOME_ENV]: sqliteHomeOverride } : {}),
         ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
     };
     const codexEnvWithSession = {
         ...codexBaseEnv,
-        OMX_SESSION_ID: sessionId,
-        [OMX_TMUX_HUD_OWNER_ENV]: "1",
+        ...buildHudRuntimeEnv({ sessionId }).env,
     };
     const codexEnv = workerLaunchArgs
         ? { ...codexEnvWithSession, [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs }
@@ -3077,22 +3284,37 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
         const staleHudPaneIds = currentPaneId
             ? listHudWatchPaneIdsInCurrentWindow(currentPaneId, { sessionId, leaderPaneId: currentPaneId })
             : [];
-        for (const paneId of staleHudPaneIds) {
+        let hudPaneId = null;
+        const [keeperHudPaneId, ...duplicateHudPaneIds] = staleHudPaneIds;
+        for (const paneId of duplicateHudPaneIds) {
             killTmuxPane(paneId);
         }
-        let hudPaneId = null;
-        try {
-            hudPaneId = createHudWatchPane(cwd, hudCmd, {
-                heightLines: HUD_TMUX_HEIGHT_LINES,
-                targetPaneId: currentPaneId,
-            });
-            if (hudPaneId && currentPaneId) {
-                registerHudResizeHook(hudPaneId, currentPaneId, HUD_TMUX_HEIGHT_LINES);
+        if (keeperHudPaneId) {
+            hudPaneId = keeperHudPaneId;
+            try {
+                resizeTmuxPane(hudPaneId, HUD_TMUX_HEIGHT_LINES);
+                if (currentPaneId) {
+                    registerHudResizeHook(hudPaneId, currentPaneId, HUD_TMUX_HEIGHT_LINES);
+                }
+            }
+            catch (err) {
+                logCliOperationFailure(err);
             }
         }
-        catch (err) {
-            logCliOperationFailure(err);
-            // HUD split failed, continue without it
+        else {
+            try {
+                hudPaneId = createHudWatchPane(cwd, hudCmd, {
+                    heightLines: HUD_TMUX_HEIGHT_LINES,
+                    targetPaneId: currentPaneId,
+                });
+                if (hudPaneId && currentPaneId) {
+                    registerHudResizeHook(hudPaneId, currentPaneId, HUD_TMUX_HEIGHT_LINES);
+                }
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+                // HUD split failed, continue without it
+            }
         }
         // Enable mouse scrolling at session start so scroll works before team
         // expansion. Previously this was only called from createTeamSession().
@@ -3160,8 +3382,14 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                 : null;
             if (activeRecord &&
                 activeRecord.context_key === contextKey &&
-                detachedTmuxSessionExists(activeRecord.tmux_session_name)) {
+                isReusableMadmaxDetachedActiveRecord(activeRecord)) {
                 cleanupCurrentMadmaxReuseRunRoot(process.env, runsRoot);
+                setDetachedTmuxSessionHistoryLimit(activeRecord.tmux_session_name, activeRecord.tmux_pane_id);
+                if (!shouldAttachDetachedTmuxSession(process.env)) {
+                    clearDetachedTmuxSessionHistoryIfUnattached(activeRecord.tmux_session_name, activeRecord.tmux_pane_id);
+                    process.stderr.write(`[omx] madmax detached launch already active for this context; reusing ${activeRecord.tmux_session_name} without attaching because this launch is a Hermes MCP bridge.\n`);
+                    return { postLaunchHandledExternally: true };
+                }
                 process.stderr.write(`[omx] madmax detached launch already active for this context; attaching ${activeRecord.tmux_session_name} instead of starting a duplicate.\n`);
                 try {
                     execTmuxFileSync(["attach-session", "-t", activeRecord.tmux_session_name], {
@@ -3177,15 +3405,28 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
             if (activeRecordPath && activeRecord) {
                 rmSync(activeRecordPath, { force: true });
             }
-            void writeSessionStart(cwd, sessionId, { tmuxSessionName: sessionName }).catch((err) => {
-                logCliOperationFailure(err);
-                // Non-fatal: managed tmux recovery can still use compatibility fallback.
-            });
+            let detachedSessionBindingWrite = Promise.resolve();
+            const writeDetachedSessionBinding = (tmuxPaneId) => {
+                detachedSessionBindingWrite = detachedSessionBindingWrite
+                    .catch((err) => {
+                    logCliOperationFailure(err);
+                })
+                    .then(() => writeSessionStart(cwd, sessionId, {
+                    tmuxSessionName: sessionName,
+                    ...(tmuxPaneId ? { tmuxPaneId } : {}),
+                }));
+                void detachedSessionBindingWrite.catch((err) => {
+                    logCliOperationFailure(err);
+                    // Non-fatal: managed tmux recovery can still use compatibility fallback.
+                });
+            };
+            writeDetachedSessionBinding();
             let createdDetachedSession = false;
             let registeredHookTarget = null;
             let registeredHookName = null;
             let registeredClientAttachedHookName = null;
             let detachedParentEnvFilePath;
+            let detachedLeaderPaneId = null;
             try {
                 // This path is the user-shell interactive launch: OMX creates a tmux
                 // session and immediately attaches the user's terminal to it. If a tmux
@@ -3204,18 +3445,25 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                     });
                     if (step.name === "new-session") {
                         createdDetachedSession = true;
-                        if (activeRecordPath && contextKey) {
-                            writeMadmaxDetachedActiveRecord(activeRecordPath, {
-                                version: 1,
-                                context_key: contextKey,
-                                created_at: new Date().toISOString(),
-                                source_cwd: process.env.OMX_SOURCE_CWD || cwd,
-                                argv: args,
-                                run_dir: process.env.OMX_ROOT || cwd,
-                                tmux_session_name: sessionName,
-                            });
+                        const leaderPaneId = parsePaneIdFromTmuxOutput(output || "");
+                        if (leaderPaneId) {
+                            detachedLeaderPaneId = leaderPaneId;
+                            setDetachedTmuxSessionHistoryLimit(sessionName, leaderPaneId);
+                            if (activeRecordPath && contextKey) {
+                                writeMadmaxDetachedActiveRecord(activeRecordPath, {
+                                    version: 1,
+                                    context_key: contextKey,
+                                    created_at: new Date().toISOString(),
+                                    source_cwd: process.env.OMX_SOURCE_CWD || cwd,
+                                    argv: args,
+                                    run_dir: process.env.OMX_ROOT || cwd,
+                                    tmux_session_name: sessionName,
+                                    session_id: sessionId,
+                                    tmux_pane_id: leaderPaneId,
+                                });
+                            }
+                            writeDetachedSessionBinding(leaderPaneId);
                         }
-                        parsePaneIdFromTmuxOutput(output || "");
                     }
                     if (step.name === "split-and-capture-hud-pane") {
                         const hudPaneId = parsePaneIdFromTmuxOutput(output || "");
@@ -3231,7 +3479,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                         const clientAttachedHookName = hudPaneId && hookWindowIndex
                             ? buildClientAttachedReconcileHookName("launch", sessionName, hookWindowIndex, hudPaneId)
                             : null;
-                        const finalizeSteps = buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, process.env.OMX_MOUSE !== "0", nativeWindows);
+                        const finalizeSteps = buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, process.env.OMX_MOUSE !== "0", nativeWindows, shouldAttachDetachedTmuxSession(process.env), detachedLeaderPaneId);
                         if (nativeWindows && detachedWindowsCodexCmd) {
                             scheduleDetachedWindowsCodexLaunch(sessionName, detachedWindowsCodexCmd);
                         }