oh-my-codex 0.15.2 → 0.16.0

package/dist/cli/index.js

@@ -5,7 +5,8 @@
 import { execFileSync, spawn } from "child_process";
 import { basename, dirname, join } from "path";
 import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
-import { constants as osConstants } from "os";
+import { copyFile, cp, lstat, mkdir, readdir, rm, symlink } from "fs/promises";
+import { constants as osConstants, homedir } from "os";
 import { setup, SETUP_SCOPES } from "./setup.js";
 import { uninstall } from "./uninstall.js";
 import { version } from "./version.js";
@@ -15,6 +16,8 @@ import { hudCommand } from "../hud/index.js";
 import { sidecarCommand } from "../sidecar/index.js";
 import { teamCommand } from "./team.js";
 import { ralphCommand } from "./ralph.js";
+import { ultragoalCommand } from "./ultragoal.js";
+import { performanceGoalCommand } from "./performance-goal.js";
 import { askCommand } from "./ask.js";
 import { questionCommand } from "./question.js";
 import { stateCommand } from "./state.js";
@@ -25,6 +28,7 @@ import { agentsInitCommand } from "./agents-init.js";
 import { agentsCommand } from "./agents.js";
 import { sessionCommand } from "./session-search.js";
 import { autoresearchCommand } from "./autoresearch.js";
+import { autoresearchGoalCommand } from "./autoresearch-goal.js";
 import { mcpParityCommand } from "./mcp-parity.js";
 import { mcpServeCommand } from "./mcp-serve.js";
 import { adaptCommand } from "./adapt.js";
@@ -41,9 +45,10 @@ import { generateOverlay, removeSessionModelInstructionsFile, resolveSessionOrch
 import { readSessionState, writeSessionStart, writeSessionEnd, resetSessionMetrics, } from "../hooks/session.js";
 import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isMsysOrGitBash, isNativeWindows, isTmuxAvailable, mitigateCopyModeUnderlineArtifacts, } from "../team/tmux-session.js";
 import { getPackageRoot } from "../utils/package.js";
-import { codexConfigPath, rememberOmxLaunchContext, resolveOmxEntryPath } from "../utils/paths.js";
+import { codexConfigPath, omxRoot, rememberOmxLaunchContext, resolveOmxEntryPath } from "../utils/paths.js";
 import { cleanCodexModelAvailabilityNuxIfNeeded, repairConfigIfNeeded } from "../config/generator.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, parsePaneIdFromTmuxOutput, } from "../hud/tmux.js";
 export { parseTmuxPaneSnapshot, isHudWatchPane, findHudWatchPaneIds } from "../hud/tmux.js";
 rememberOmxLaunchContext();
@@ -96,6 +101,11 @@ Usage:
                 Alias for agents-init (lightweight AGENTS bootstrap only)
   omx team      Spawn parallel worker panes in tmux and bootstrap inbox/task state
   omx ralph     Launch Codex with ralph persistence mode active
+  omx ultragoal Create, resume, and checkpoint durable multi-goal plans over Codex goal mode
+  omx performance-goal
+                Create, hand off, and gate evaluator-backed performance goals
+  omx autoresearch-goal
+                Create, hand off, and gate professor-critic research goals
   omx autoresearch [DEPRECATED] Use $autoresearch; direct CLI launch removed
   omx version   Show version information
   omx tmux-hook Manage tmux prompt injection workaround (init|status|validate|test)
@@ -213,6 +223,7 @@ const NESTED_HELP_COMMANDS = new Set([
     "cleanup",
     "adapt",
     "autoresearch",
+    "autoresearch-goal",
     "agents",
     "agents-init",
     "deepinit",
@@ -225,6 +236,8 @@ const NESTED_HELP_COMMANDS = new Set([
     "wiki",
     "mcp-serve",
     "ralph",
+    "ultragoal",
+    "performance-goal",
     "resume",
     "session",
     "sparkshell",
@@ -393,6 +406,65 @@ export function resolveCodexLaunchPolicy(env = process.env, _platform = process.
 function resolveTmuxExecutableForLaunch() {
     return resolveTmuxBinaryForPlatform() || "tmux";
 }
+export function runtimeCodexHomePath(cwd, sessionId) {
+    return join(omxRoot(cwd), "runtime", "codex-home", sessionId);
+}
+async function linkOrCopyCodexHomeEntry(source, destination) {
+    const stat = await lstat(source);
+    try {
+        await symlink(source, destination, stat.isDirectory() && process.platform === "win32" ? "junction" : undefined);
+    }
+    catch {
+        if (stat.isDirectory()) {
+            await cp(source, destination, { recursive: true, force: true, verbatimSymlinks: true });
+            return;
+        }
+        await copyFile(source, destination);
+    }
+}
+/**
+ * Project-scope setup keeps durable Codex config under <repo>/.codex, but the
+ * Codex TUI also stores model-availability NUX counters in CODEX_HOME/config.toml.
+ * Launch against a session mirror so those runtime writes never dirty the
+ * durable project config while preserving the project config as the launch input.
+ */
+export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectCodexHome) {
+    const runtimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
+    await rm(runtimeCodexHome, { recursive: true, force: true });
+    await mkdir(runtimeCodexHome, { recursive: true });
+    if (!existsSync(projectCodexHome))
+        return runtimeCodexHome;
+    for (const entry of await readdir(projectCodexHome, { withFileTypes: true })) {
+        const source = join(projectCodexHome, entry.name);
+        const destination = join(runtimeCodexHome, entry.name);
+        if (entry.name === "config.toml") {
+            await copyFile(source, destination);
+            continue;
+        }
+        await linkOrCopyCodexHomeEntry(source, destination);
+    }
+    return runtimeCodexHome;
+}
+export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.env) {
+    const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(cwd, env);
+    if (projectLocalCodexHomeForCleanup) {
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup);
+        return {
+            codexHomeOverride: runtimeCodexHome,
+            projectLocalCodexHomeForCleanup,
+            runtimeCodexHomeForCleanup: runtimeCodexHome,
+        };
+    }
+    return {
+        codexHomeOverride: resolveCodexHomeForLaunch(cwd, env),
+        projectLocalCodexHomeForCleanup,
+    };
+}
+async function cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup) {
+    if (!runtimeCodexHomeForCleanup)
+        return;
+    await rm(runtimeCodexHomeForCleanup, { recursive: true, force: true });
+}
 function execTmuxFileSync(args, options) {
     return execFileSync(resolveTmuxExecutableForLaunch(), args, {
         ...(options ?? {}),
@@ -423,6 +495,11 @@ function tmuxFailureMessage(error) {
     const detail = (stderr || stdout || err.message || String(error)).trim();
     return detail.replace(/\s+/g, " ");
 }
+function isUnsupportedTmuxExtendedKeysFailure(error) {
+    const message = tmuxFailureMessage(error).toLowerCase();
+    return (message.includes("extended-keys") &&
+        /(?:invalid|unknown|unsupported) (?:option|flag|argument)|no such option|unknown option/.test(message));
+}
 function isBenignMissingTmuxServerMessage(message) {
     return (/no server running/i.test(message) ||
         /error connecting to .*\(No such file or directory\)/i.test(message));
@@ -447,6 +524,42 @@ function warnDetachedTmuxFallback(reason) {
     const suffix = reason ? ` (${reason})` : "";
     console.warn(`[omx] warning: tmux is installed but its server/socket is unusable${suffix}. Falling back to direct Codex launch.`);
 }
+const QUICK_ATTACH_NOOP_THRESHOLD_MS = 2_000;
+function isWslWindowsTerminalEnvironment(env) {
+    return Boolean(env.WT_SESSION?.trim() &&
+        (env.WSL_INTEROP?.trim() ||
+            env.WSL_DISTRO_NAME?.trim() ||
+            env.WSLENV?.trim()));
+}
+function readDetachedSessionAttachedClientCount(sessionName) {
+    try {
+        const output = execTmuxFileSync(["display-message", "-p", "-t", sessionName, "#{session_attached}"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        const parsed = Number.parseInt(output, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        return null;
+    }
+}
+function assertDetachedAttachDidNotNoop(sessionName, elapsedMs, env) {
+    if (!isWslWindowsTerminalEnvironment(env))
+        return;
+    if (elapsedMs >= QUICK_ATTACH_NOOP_THRESHOLD_MS)
+        return;
+    const attachedClients = readDetachedSessionAttachedClientCount(sessionName);
+    if (attachedClients === null || attachedClients > 0)
+        return;
+    throw new Error([
+        "tmux attach-session returned immediately without attaching a client",
+        `(session=${sessionName}).`,
+        "This can happen on WSL2 under Windows Terminal.",
+        "Falling back to direct Codex launch.",
+    ].join(" "));
+}
 function resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows) {
     const launchPolicy = resolveCodexLaunchPolicy(process.env, process.platform, undefined, nativeWindows, undefined, undefined, explicitLaunchPolicy);
     if (launchPolicy !== "detached-tmux") {
@@ -541,6 +654,51 @@ export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leade
     }
     return [...targets];
 }
+export function resolveOmxRootForLaunch(cwd, env = process.env) {
+    const raw = env.OMX_ROOT || env.OMX_STATE_ROOT;
+    if (typeof raw !== "string" || raw.trim() === "")
+        return undefined;
+    return raw.startsWith("/") ? raw : join(cwd, raw);
+}
+export function shouldAutoIsolateMadmaxLaunch(command, launchArgs, env = process.env) {
+    if (command !== "launch" && command !== "exec")
+        return false;
+    if (env.OMX_NO_BOX === "1" || env.OMXBOX_ACTIVE === "1")
+        return false;
+    if (env.OMX_ROOT || env.OMX_STATE_ROOT)
+        return false;
+    return launchArgs.some((arg) => arg === MADMAX_FLAG || arg === MADMAX_SPARK_FLAG);
+}
+function sanitizeRunIdSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+export function createMadmaxIsolatedRoot(sourceCwd, argv, env = process.env) {
+    const runsRoot = env.OMX_RUNS_DIR || join(homedir(), ".omx-runs");
+    mkdirSync(runsRoot, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+    const suffix = Math.random().toString(16).slice(2, 6);
+    const runDir = join(runsRoot, sanitizeRunIdSegment(`run-${stamp}-${suffix}`));
+    mkdirSync(runDir, { recursive: false });
+    const metadata = {
+        launcher: "omx --madmax",
+        created_at: new Date().toISOString(),
+        cwd: runDir,
+        source_cwd: sourceCwd,
+        argv,
+    };
+    writeFileSync(join(runDir, ".omxbox-run.json"), `${JSON.stringify(metadata, null, 2)}\n`);
+    writeFileSync(join(runsRoot, "registry.jsonl"), `${JSON.stringify(metadata)}\n`, { flag: "a" });
+    return runDir;
+}
+function activateMadmaxIsolationIfNeeded(command, launchArgs, cwd, env = process.env) {
+    if (!shouldAutoIsolateMadmaxLaunch(command, launchArgs, env))
+        return;
+    const runDir = createMadmaxIsolatedRoot(cwd, launchArgs, env);
+    env.OMX_ROOT = runDir;
+    env.OMXBOX_ACTIVE = "1";
+    env.OMX_SOURCE_CWD = cwd;
+    process.stderr.write(`[omx] madmax isolated state: ${runDir} (source: ${cwd})\n`);
+}
 export async function main(args) {
     const knownCommands = new Set([
         "launch",
@@ -557,10 +715,13 @@ export async function main(args) {
         "ask",
         "question",
         "autoresearch",
+        "autoresearch-goal",
         "explore",
         "sparkshell",
         "team",
         "ralph",
+        "ultragoal",
+        "performance-goal",
         "session",
         "resume",
         "version",
@@ -590,6 +751,7 @@ export async function main(args) {
         console.log(HELP);
         return;
     }
+    activateMadmaxIsolationIfNeeded(command, launchArgs, process.cwd(), process.env);
     try {
         switch (command) {
             case "launch":
@@ -652,6 +814,9 @@ export async function main(args) {
             case "autoresearch":
                 await autoresearchCommand(args.slice(1));
                 break;
+            case "autoresearch-goal":
+                await autoresearchGoalCommand(args.slice(1));
+                break;
             case "explore":
                 await exploreCommand(args.slice(1));
                 break;
@@ -675,6 +840,12 @@ export async function main(args) {
             case "ralph":
                 await ralphCommand(args.slice(1));
                 break;
+            case "ultragoal":
+                await ultragoalCommand(args.slice(1));
+                break;
+            case "performance-goal":
+                await performanceGoalCommand(args.slice(1));
+                break;
             case "version":
                 version();
                 break;
@@ -832,11 +1003,10 @@ export async function launchWithHud(args) {
     const parsedWorktree = parseWorktreeMode(args);
     const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
     const explicitLaunchPolicy = resolveEffectiveLeaderLaunchPolicyOverride(notifyTempResult.passthroughArgs, process.env);
-    const codexHomeOverride = resolveCodexHomeForLaunch(launchCwd, process.env);
-    const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(launchCwd, process.env);
+    const persistentCodexHomeForLaunch = resolveCodexHomeForLaunch(launchCwd, process.env);
     const { launchPolicy, effectiveExplicitLaunchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
     const enableNotifyFallbackAuthority = launchPolicy === "direct";
-    const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, codexHomeOverride);
+    const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, persistentCodexHomeForLaunch);
     const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
     let cwd = launchCwd;
     let worktreeDirty = false;
@@ -891,6 +1061,9 @@ export async function launchWithHud(args) {
     catch {
         // Non-fatal: repair failure must not block launch
     }
+    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env);
+    const codexHomeOverride = preparedCodexHome.codexHomeOverride;
+    const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
     // ── Phase 1: preLaunch ──────────────────────────────────────────────────
     try {
         await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, enableNotifyFallbackAuthority, worktreeDirty);
@@ -900,23 +1073,26 @@ export async function launchWithHud(args) {
         console.error(`[omx] preLaunch warning: ${err instanceof Error ? err.message : err}`);
     }
     // ── Phase 2: run ────────────────────────────────────────────────────────
+    let postLaunchHandledExternally = false;
     try {
         const notifyTempContractRaw = notifyTempResult.contract.active
             ? serializeNotifyTempContract(notifyTempResult.contract)
             : null;
-        runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, notifyTempContractRaw, effectiveExplicitLaunchPolicy);
+        const launchResult = runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, notifyTempContractRaw, effectiveExplicitLaunchPolicy, projectLocalCodexHomeForCleanup, preparedCodexHome.runtimeCodexHomeForCleanup);
+        postLaunchHandledExternally = launchResult.postLaunchHandledExternally;
     }
     finally {
         // ── Phase 3: postLaunch ─────────────────────────────────────────────
-        await postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority, projectLocalCodexHomeForCleanup);
+        if (!postLaunchHandledExternally) {
+            await postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority, projectLocalCodexHomeForCleanup);
+            await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup).catch(logCliOperationFailure);
+        }
     }
 }
 export async function execWithOverlay(args) {
     const launchCwd = process.cwd();
     const parsedWorktree = parseWorktreeMode(args);
     const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
-    const codexHomeOverride = resolveCodexHomeForLaunch(launchCwd, process.env);
-    const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(launchCwd, process.env);
     const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
     let cwd = launchCwd;
     let worktreeDirty = false;
@@ -965,6 +1141,9 @@ export async function execWithOverlay(args) {
     catch {
         // Non-fatal
     }
+    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env);
+    const codexHomeOverride = preparedCodexHome.codexHomeOverride;
+    const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
     try {
         await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, true, worktreeDirty);
     }
@@ -976,9 +1155,12 @@ export async function execWithOverlay(args) {
             ? serializeNotifyTempContract(notifyTempResult.contract)
             : null;
         const codexArgs = injectModelInstructionsBypassArgs(cwd, ["exec", ...normalizedArgs], process.env, sessionModelInstructionsPath(cwd, sessionId));
-        const codexEnvBase = codexHomeOverride
-            ? { ...process.env, CODEX_HOME: codexHomeOverride }
-            : process.env;
+        const omxRootOverride = resolveOmxRootForLaunch(cwd, process.env);
+        const codexEnvBase = {
+            ...process.env,
+            ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
+            ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+        };
         const codexEnv = notifyTempContractRaw
             ? {
                 ...codexEnvBase,
@@ -989,6 +1171,7 @@ export async function execWithOverlay(args) {
     }
     finally {
         await postLaunch(cwd, sessionId, codexHomeOverride, true, projectLocalCodexHomeForCleanup);
+        await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup).catch(logCliOperationFailure);
     }
 }
 export function normalizeCodexLaunchArgs(args) {
@@ -1338,7 +1521,7 @@ function blockMs(ms) {
     Atomics.wait(view, 0, 0, delay);
 }
 function tmuxExtendedKeysLeaseRoot(cwd) {
-    return join(cwd, ".omx", "state", TMUX_EXTENDED_KEYS_LEASE_DIR);
+    return join(omxRoot(cwd), "state", TMUX_EXTENDED_KEYS_LEASE_DIR);
 }
 function resolveTmuxSocketPath(execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
     encoding: "utf-8",
@@ -1509,7 +1692,10 @@ function withTmuxExtendedKeysLeaseLock(cwd, socketPath, run) {
     }
     throw new Error(`timed out waiting for tmux extended-keys lease lock: ${lockPath}`);
 }
-function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd) {
+function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    const detachedPostLaunchHelper = sessionId
+        ? `${buildDetachedSessionPostLaunchHelperCommand(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup)} >/dev/null 2>&1 || true;`
+        : "";
     const wrapped = [
         buildTmuxExtendedKeysAcquireShellSnippet(cwd),
         'exec 3<&0;',
@@ -1523,6 +1709,7 @@ function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd) {
         "fi;",
         'exec 3<&- 2>/dev/null || true;',
         buildTmuxExtendedKeysReleaseShellSnippet(cwd),
+        detachedPostLaunchHelper,
         'if [ "$status" -lt 128 ]; then',
         `tmux kill-session -t "${escapeShellDoubleQuotedValue(sessionName)}" >/dev/null 2>&1 || true;`,
         "fi;",
@@ -1535,6 +1722,27 @@ function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd) {
     ].join(" ");
     return `/bin/sh -c ${quoteShellArg(wrapped)}`;
 }
+function buildDetachedSessionPostLaunchHelperCommand(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    const cwdLiteral = JSON.stringify(cwd);
+    const sessionIdLiteral = JSON.stringify(sessionId);
+    const codexHomeLiteral = typeof codexHomeOverride === "string" && codexHomeOverride.length > 0
+        ? JSON.stringify(codexHomeOverride)
+        : "undefined";
+    const projectLocalCleanupLiteral = typeof projectLocalCodexHomeForCleanup === "string" &&
+        projectLocalCodexHomeForCleanup.length > 0
+        ? JSON.stringify(projectLocalCodexHomeForCleanup)
+        : "undefined";
+    const runtimeCodexHomeCleanupLiteral = typeof runtimeCodexHomeForCleanup === "string" &&
+        runtimeCodexHomeForCleanup.length > 0
+        ? JSON.stringify(runtimeCodexHomeForCleanup)
+        : "undefined";
+    const moduleUrlLiteral = JSON.stringify(import.meta.url);
+    const script = [
+        `const mod = await import(${moduleUrlLiteral});`,
+        `await mod.runDetachedSessionPostLaunch(${cwdLiteral}, ${sessionIdLiteral}, ${codexHomeLiteral}, ${projectLocalCleanupLiteral}, ${runtimeCodexHomeCleanupLiteral});`,
+    ].join(" ");
+    return `${quoteShellArg(process.execPath)} --input-type=module -e ${quoteShellArg(script)}`;
+}
 function execTmuxSync(args, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
     encoding: "utf-8",
     ...(process.platform === "win32" ? { windowsHide: true } : {}),
@@ -1573,7 +1781,9 @@ export function acquireTmuxExtendedKeysLease(cwd, execFileSyncImpl = (file, tmux
         return `${socketPath}\t${leaseId}`;
     }
     catch (err) {
-        logCliOperationFailure(err);
+        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
+            logCliOperationFailure(err);
+        }
         return null;
     }
 }
@@ -1612,7 +1822,9 @@ export function releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl
         });
     }
     catch (err) {
-        logCliOperationFailure(err);
+        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
+            logCliOperationFailure(err);
+        }
     }
 }
 function buildTmuxExtendedKeysHelperCommand(cwd, operation) {
@@ -1642,10 +1854,10 @@ export function withTmuxExtendedKeys(cwd, run, execFileSyncImpl = (file, tmuxArg
             releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl);
     }
 }
-export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false, sessionId) {
+export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, env = process.env) {
     const detachedLeaderCmd = nativeWindows
         ? "powershell.exe"
-        : buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd);
+        : buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup);
     const newSessionArgs = [
         "new-session",
         "-d",
@@ -1660,7 +1872,12 @@ export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, h
             ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`]
             : []),
         ...(sessionId ? ["-e", `OMX_SESSION_ID=${sessionId}`] : []),
+        ...(sessionId ? ["-e", `${OMX_TMUX_HUD_OWNER_ENV}=1`] : []),
         ...(codexHomeOverride ? ["-e", `CODEX_HOME=${codexHomeOverride}`] : []),
+        ...(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
             ? ["-e", `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`]
             : []),
@@ -1787,6 +2004,7 @@ export function buildNotifyFallbackWatcherEnv(env = process.env, options = {}) {
     return {
         ...nextEnv,
         ...(options.codexHomeOverride ? { CODEX_HOME: options.codexHomeOverride } : {}),
+        ...(options.omxRootOverride ? { OMX_ROOT: options.omxRootOverride } : {}),
         ...(options.sessionId ? { OMX_SESSION_ID: options.sessionId } : {}),
         OMX_HUD_AUTHORITY: options.enableAuthority ? "1" : "0",
     };
@@ -2094,7 +2312,7 @@ ${launchAppendix}${dirtyWorktreeGuidance}`
  * runCodex: Launch Codex CLI (blocks until exit).
  * All 3 paths (new tmux, existing tmux, no tmux) block via execSync/execFileSync.
  */
-function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, notifyTempContractRaw, explicitLaunchPolicy) {
+function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, notifyTempContractRaw, explicitLaunchPolicy, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
     const launchArgs = injectModelInstructionsBypassArgs(cwd, args, process.env, sessionModelInstructionsPath(cwd, sessionId));
     const nativeWindows = isNativeWindows();
     const omxBin = resolveOmxEntryPath();
@@ -2103,13 +2321,20 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
     }
     const hudCmd = nativeWindows
         ? buildWindowsPromptCommand("node", [omxBin, "hud", "--watch"])
-        : buildTmuxPaneCommand("env", [`OMX_SESSION_ID=${sessionId}`, "node", omxBin, "hud", "--watch"]);
+        : buildTmuxPaneCommand("env", [`OMX_SESSION_ID=${sessionId}`, `${OMX_TMUX_HUD_OWNER_ENV}=1`, "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 = codexHomeOverride
-        ? { ...process.env, CODEX_HOME: codexHomeOverride }
-        : process.env;
-    const codexEnvWithSession = { ...codexBaseEnv, OMX_SESSION_ID: sessionId };
+    const omxRootOverride = resolveOmxRootForLaunch(cwd, process.env);
+    const codexBaseEnv = {
+        ...process.env,
+        ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
+        ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+    };
+    const codexEnvWithSession = {
+        ...codexBaseEnv,
+        OMX_SESSION_ID: sessionId,
+        [OMX_TMUX_HUD_OWNER_ENV]: "1",
+    };
     const codexEnv = workerLaunchArgs
         ? { ...codexEnvWithSession, [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs }
         : codexEnvWithSession;
@@ -2119,7 +2344,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
     const { launchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows);
     if (isCodexVersionRequest(launchArgs)) {
         runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
-        return;
+        return { postLaunchHandledExternally: false };
     }
     if (launchPolicy === "inside-tmux") {
         // Already in tmux: launch codex in current pane, HUD in bottom split
@@ -2176,11 +2401,13 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
                 killTmuxPane(paneId);
             }
         }
+        return { postLaunchHandledExternally: false };
     }
     else if (launchPolicy === "direct") {
         // Detached HUD sessions require tmux. Skip the bootstrap entirely when the
         // binary is unavailable so direct launches do not emit noisy ENOENT logs.
         runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+        return { postLaunchHandledExternally: false };
     }
     else {
         // Not in tmux: create a new tmux session with codex + HUD pane
@@ -2198,7 +2425,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
         let registeredHookName = null;
         let registeredClientAttachedHookName = null;
         try {
-            const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId);
+            const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, process.env);
             for (const step of bootstrapSteps) {
                 const output = execTmuxFileSync(step.args, {
                     stdio: "pipe",
@@ -2238,7 +2465,11 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
                         }
                         const stdio = finalizeStep.name === "attach-session" ? "inherit" : "ignore";
                         try {
+                            const startedAtMs = Date.now();
                             execTmuxFileSync(finalizeStep.args, { stdio });
+                            if (finalizeStep.name === "attach-session") {
+                                assertDetachedAttachDidNotNoop(sessionName, Date.now() - startedAtMs, process.env);
+                            }
                         }
                         catch (err) {
                             logCliOperationFailure(err);
@@ -2259,6 +2490,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
                     }
                 }
             }
+            return { postLaunchHandledExternally: !nativeWindows };
         }
         catch (err) {
             logCliOperationFailure(err);
@@ -2276,6 +2508,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
             }
             // tmux not available or failed, just run codex directly
             runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+            return { postLaunchHandledExternally: false };
         }
     }
 }
@@ -2517,6 +2750,10 @@ async function postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbac
         // Non-fatal
     }
 }
+export async function runDetachedSessionPostLaunch(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    await postLaunch(cwd, sessionId, codexHomeOverride, false, projectLocalCodexHomeForCleanup);
+    await cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup).catch(logCliOperationFailure);
+}
 async function emitNativeHookEvent(cwd, event, opts = {}) {
     const payload = buildHookEvent(event, {
         source: "native",
@@ -2532,10 +2769,10 @@ async function emitNativeHookEvent(cwd, event, opts = {}) {
     });
 }
 function notifyFallbackPidPath(cwd) {
-    return join(cwd, ".omx", "state", "notify-fallback.pid");
+    return join(omxRoot(cwd), "state", "notify-fallback.pid");
 }
 function hookDerivedWatcherPidPath(cwd) {
-    return join(cwd, ".omx", "state", "hook-derived-watcher.pid");
+    return join(omxRoot(cwd), "state", "hook-derived-watcher.pid");
 }
 export function shouldDetachBackgroundHelper(env = process.env, platform = process.platform) {
     // The long-running watcher/helper itself must stay detached so it can
@@ -2703,7 +2940,7 @@ async function startNotifyFallbackWatcher(cwd, options = {}) {
     const notifyScript = resolveNotifyHookScript(pkgRoot);
     if (!existsSync(watcherScript) || !existsSync(notifyScript))
         return;
-    await mkdir(join(cwd, ".omx", "state"), { recursive: true }).catch((error) => {
+    await mkdir(join(omxRoot(cwd), "state"), { recursive: true }).catch((error) => {
         console.warn("[omx] warning: failed to create notify fallback watcher state directory", {
             cwd,
             error: error instanceof Error ? error.message : String(error),
@@ -2711,6 +2948,7 @@ async function startNotifyFallbackWatcher(cwd, options = {}) {
     });
     const watcherEnv = buildNotifyFallbackWatcherEnv(process.env, {
         codexHomeOverride: options.codexHomeOverride,
+        omxRootOverride: resolveOmxRootForLaunch(cwd, process.env),
         enableAuthority: options.enableAuthority === true,
         sessionId: options.sessionId,
     });
@@ -2776,7 +3014,7 @@ async function startHookDerivedWatcher(cwd) {
             });
         }
     }
-    await mkdir(join(cwd, ".omx", "state"), { recursive: true }).catch((error) => {
+    await mkdir(join(omxRoot(cwd), "state"), { recursive: true }).catch((error) => {
         console.warn("[omx] warning: failed to create hook-derived watcher state directory", {
             cwd,
             error: error instanceof Error ? error.message : String(error),