oh-my-codex 0.18.16 → 0.19.0

package/dist/cli/index.js

@@ -5,7 +5,7 @@
 import { execFileSync, spawn } from "child_process";
 import { basename, dirname, join, posix, resolve, win32 } from "path";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
-import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, symlink, writeFile } from "fs/promises";
+import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, stat, symlink, writeFile } from "fs/promises";
 import { constants as osConstants, homedir } from "os";
 import { createHash } from "crypto";
 import { setup, SETUP_MCP_MODES, SETUP_SCOPES, SETUP_TEAM_MODES, } from "./setup.js";
@@ -43,6 +43,7 @@ import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, }
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { readPersistedSetupPreferences, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
 import { discoverProjectRuntimeCodexHomes } from "./project-runtime-codex-homes.js";
+import { materializePackagedOmxPluginCache, packagedOmxPluginVersion, resolvePackagedOmxMarketplace, upsertLocalOmxMarketplaceRegistration, upsertLocalOmxPluginEnablement, } from "./plugin-marketplace.js";
 import { escapeTomlString, readTopLevelTomlString, upsertTopLevelTomlString } from "../utils/toml.js";
 export { readPersistedSetupPreferences, readPersistedSetupScope, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
 import { SKILL_ACTIVE_STATE_MODE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, syncCanonicalSkillStateForMode, } from "../state/skill-active.js";
@@ -65,7 +66,7 @@ rememberOmxLaunchContext({ argv1: process.argv[1], cwd: process.cwd(), env: proc
 import { classifySpawnError, resolveTmuxBinaryForPlatform, spawnPlatformCommandSync, } from "../utils/platform-command.js";
 import { buildHookEvent } from "../hooks/extensibility/events.js";
 import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
-import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, } from "../team/model-contract.js";
+import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, parseTeamWorkerLaunchArgs, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, TEAM_WORKER_INHERITED_MODEL_ENV, } from "../team/model-contract.js";
 import { parseWorktreeMode, planWorktreeTarget, ensureWorktree, } from "../team/worktree.js";
 import { ensureReusableNodeModules } from "../utils/repo-deps.js";
 import { OMX_NOTIFY_TEMP_CONTRACT_ENV, parseNotifyTempContractFromArgs, serializeNotifyTempContract, } from "../notifications/temp-contract.js";
@@ -667,26 +668,43 @@ async function materializeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, s
         await copyFile(source, destination);
     }
 }
-async function mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, sourceCodexHome) {
+async function mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, sourceCodexHome, mergedHistorySourceRealpaths) {
     for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
         const source = join(sourceCodexHome, entryName);
         if (!existsSync(source))
             continue;
+        const sourceRealpath = realpathSync(source);
+        if (mergedHistorySourceRealpaths.has(sourceRealpath))
+            continue;
         const destination = join(runtimeCodexHome, entryName);
-        const sourceStat = await lstat(source);
+        const sourceStat = await stat(source);
         if (sourceStat.isDirectory()) {
             await mkdir(destination, { recursive: true });
             await cp(source, destination, { recursive: true, force: true, dereference: true });
+            mergedHistorySourceRealpaths.add(sourceRealpath);
             continue;
         }
+        if (entryName === "sessions")
+            continue;
+        if (!sourceStat.isFile())
+            continue;
         if (existsSync(destination)) {
+            const destinationStat = await stat(destination);
+            if (!destinationStat.isFile()) {
+                await rm(destination, { recursive: true, force: true });
+                await copyFile(source, destination);
+                mergedHistorySourceRealpaths.add(sourceRealpath);
+                continue;
+            }
             const existing = await readFile(destination, "utf-8").catch(() => "");
             const addition = await readFile(source, "utf-8");
             const separator = existing === "" || existing.endsWith("\n") || addition === "" ? "" : "\n";
             await writeFile(destination, `${existing}${separator}${addition}`, "utf-8");
+            mergedHistorySourceRealpaths.add(sourceRealpath);
             continue;
         }
         await copyFile(source, destination);
+        mergedHistorySourceRealpaths.add(sourceRealpath);
     }
 }
 export async function persistProjectLaunchRuntimeAuthState(runtimeCodexHome, projectCodexHome) {
@@ -730,9 +748,15 @@ export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, pr
     }
     await ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome);
     if (options.includeHistoryArtifacts === true && (options.extraHistoryCodexHomes?.length ?? 0) > 0) {
+        const mergedHistorySourceRealpaths = new Set();
+        for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+            const source = join(projectCodexHome, entryName);
+            if (existsSync(source))
+                mergedHistorySourceRealpaths.add(realpathSync(source));
+        }
         await materializeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, projectCodexHome);
         for (const extraCodexHome of options.extraHistoryCodexHomes ?? []) {
-            await mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, extraCodexHome);
+            await mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, extraCodexHome, mergedHistorySourceRealpaths);
         }
     }
     return runtimeCodexHome;
@@ -793,13 +817,46 @@ export function parseResumeCodexHomeSelection(args) {
         projectOnly,
     };
 }
+export async function preflightResumeOmxPluginState(codexHomeDir, pkgRoot = getPackageRoot()) {
+    const selectedCodexHomeDir = codexHomeDir && codexHomeDir.trim() !== ""
+        ? codexHomeDir
+        : join(homedir(), ".codex");
+    const packagedMarketplace = await resolvePackagedOmxMarketplace(pkgRoot);
+    if (!packagedMarketplace) {
+        return { status: "unavailable", prunedStaleDirs: [], configUpdated: false };
+    }
+    const materialized = await materializePackagedOmxPluginCache(selectedCodexHomeDir, packagedMarketplace);
+    const version = materialized.version ?? (await packagedOmxPluginVersion(packagedMarketplace)) ?? undefined;
+    const currentCacheDir = materialized.cacheDir ?? (version ? join(selectedCodexHomeDir, "plugins", "cache", "oh-my-codex-local", "oh-my-codex", version) : undefined);
+    const prunedStaleDirs = [];
+    const configPath = join(selectedCodexHomeDir, "config.toml");
+    const existingConfig = existsSync(configPath) ? await readFile(configPath, "utf-8") : "";
+    const nextConfig = upsertLocalOmxMarketplaceRegistration(upsertLocalOmxPluginEnablement(existingConfig), pkgRoot);
+    const configUpdated = nextConfig !== existingConfig;
+    if (configUpdated) {
+        await mkdir(dirname(configPath), { recursive: true });
+        await writeFile(configPath, nextConfig, "utf-8");
+    }
+    return {
+        status: "prepared",
+        version,
+        cacheDir: currentCacheDir,
+        prunedStaleDirs,
+        configUpdated,
+    };
+}
+function isResumeCodexLaunch(args) {
+    return args.includes("resume");
+}
 async function prepareResumeCodexHomeForLaunch(cwd, sessionId, args, env = process.env) {
     const selection = parseResumeCodexHomeSelection(args);
     if (selection.explicitCodexHome) {
+        const codexHomeOverride = resolve(selection.explicitCodexHome);
+        await preflightResumeOmxPluginState(codexHomeOverride);
         return {
             args: selection.args,
             prepared: {
-                codexHomeOverride: resolve(selection.explicitCodexHome),
+                codexHomeOverride,
             },
         };
     }
@@ -809,6 +866,7 @@ async function prepareResumeCodexHomeForLaunch(cwd, sessionId, args, env = proce
             const emptyRuntimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
             await rm(emptyRuntimeCodexHome, { recursive: true, force: true });
             await mkdir(join(emptyRuntimeCodexHome, "sessions"), { recursive: true });
+            await preflightResumeOmxPluginState(emptyRuntimeCodexHome);
             return {
                 args: selection.args,
                 prepared: {
@@ -821,6 +879,7 @@ async function prepareResumeCodexHomeForLaunch(cwd, sessionId, args, env = proce
             includeHistoryArtifacts: true,
             extraHistoryCodexHomes: projectHomes.slice(1).map((home) => home.path),
         });
+        await preflightResumeOmxPluginState(runtimeCodexHome);
         return {
             args: selection.args,
             prepared: {
@@ -832,6 +891,7 @@ async function prepareResumeCodexHomeForLaunch(cwd, sessionId, args, env = proce
         includeHistoryArtifacts: true,
         extraHistoryCodexHomes: projectHomes.map((home) => home.path),
     });
+    await preflightResumeOmxPluginState(prepared.codexHomeOverride);
     return { args: selection.args, prepared };
 }
 export async function persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHome, projectCodexHome) {
@@ -1362,20 +1422,88 @@ export function resolveDisposableWorktreeOmxRootForLaunch(ensuredWorktree, env =
         return undefined;
     return ensuredWorktree.repoRoot;
 }
+function buildMadmaxWorktreeRuntimeEnvOverlay(runtimeContext) {
+    if (!runtimeContext)
+        return {};
+    return {
+        OMX_ROOT: runtimeContext.omxRoot,
+        ...(runtimeContext.omxStateRoot ? { OMX_STATE_ROOT: runtimeContext.omxStateRoot } : {}),
+        ...(runtimeContext.boxedActive ? { OMXBOX_ACTIVE: "1" } : {}),
+        OMX_SOURCE_CWD: runtimeContext.sourceCwd,
+        ...(runtimeContext.madmaxDetachedContext
+            ? { [OMX_MADMAX_DETACHED_CONTEXT_ENV]: runtimeContext.madmaxDetachedContext }
+            : {}),
+    };
+}
+export function captureMadmaxWorktreeRuntimeContext(options) {
+    const env = options.env ?? process.env;
+    if (!options.worktreeEnabled)
+        return undefined;
+    if (!launchArgsRequestMadmaxIsolation(options.originalLaunchArgs))
+        return undefined;
+    if (env.OMXBOX_ACTIVE !== "1")
+        return undefined;
+    const inheritedRoot = resolveInheritedMadmaxRoot(env);
+    if (!inheritedRoot)
+        return undefined;
+    const sourceCwd = env.OMX_SOURCE_CWD?.trim() || options.sourceCwd;
+    const worktreeCwd = options.worktreeCwd?.trim();
+    const omxStateRoot = env.OMX_STATE_ROOT?.trim();
+    const madmaxDetachedContext = env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+    return {
+        omxRoot: resolveLaunchPath(options.sourceCwd, inheritedRoot),
+        ...(omxStateRoot ? { omxStateRoot: resolveLaunchPath(options.sourceCwd, omxStateRoot) } : {}),
+        sourceCwd,
+        ...(worktreeCwd && worktreeCwd !== sourceCwd ? { worktreeCwd } : {}),
+        ...(madmaxDetachedContext ? { madmaxDetachedContext } : {}),
+        boxedActive: true,
+    };
+}
 function applyDisposableWorktreeOmxRootForLaunch(ensuredWorktree, env = process.env) {
     const omxRootOverride = resolveDisposableWorktreeOmxRootForLaunch(ensuredWorktree, env);
     if (!omxRootOverride)
         return;
     env.OMX_ROOT = omxRootOverride;
 }
-export function shouldAutoIsolateMadmaxLaunch(command, launchArgs, env = process.env) {
+function launchArgRequestsDisposableWorktree(arg) {
+    return arg === "--worktree" ||
+        arg === "-w" ||
+        arg.startsWith("--worktree=") ||
+        // Covers both `-w=<name>` and `-w<name>`; an explicit `-w=` check would be a
+        // strict subset of this clause, so it is omitted as redundant.
+        (arg.startsWith("-w") && arg.length > 2);
+}
+function launchArgsRequestMadmaxIsolation(launchArgs) {
+    return launchArgs.some((arg) => arg === MADMAX_FLAG || arg === MADMAX_SPARK_FLAG);
+}
+function launchArgsRequestDisposableWorktree(launchArgs) {
+    return launchArgs.some((arg) => launchArgRequestsDisposableWorktree(arg));
+}
+function clearInheritedMadmaxRootForDisposableWorktreeLaunch(launchArgs, env = process.env) {
+    if (!launchArgsRequestDisposableWorktree(launchArgs))
+        return;
+    if (env.OMXBOX_ACTIVE !== "1")
+        return;
+    delete env.OMX_ROOT;
+    delete env.OMX_STATE_ROOT;
+    delete env.OMXBOX_ACTIVE;
+    delete env.OMX_SOURCE_CWD;
+    delete env[OMX_MADMAX_DETACHED_CONTEXT_ENV];
+}
+export function shouldAutoIsolateMadmaxLaunch(command, launchArgs, env = process.env, cwd = process.cwd()) {
     if (command !== "launch" && command !== "exec")
         return false;
-    if (env.OMX_NO_BOX === "1" || env.OMXBOX_ACTIVE === "1")
+    if (env.OMX_NO_BOX === "1")
         return false;
-    if (env.OMX_ROOT || env.OMX_STATE_ROOT)
+    if (!launchArgsRequestMadmaxIsolation(launchArgs))
         return false;
-    return launchArgs.some((arg) => arg === MADMAX_FLAG || arg === MADMAX_SPARK_FLAG);
+    const inheritedContext = env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+    if (env.OMXBOX_ACTIVE === "1" && inheritedContext && !resolveInheritedMadmaxRoot(env)) {
+        return false;
+    }
+    if (madmaxInheritedContextMatchesLaunch(cwd, launchArgs, env))
+        return false;
+    return true;
 }
 function sanitizeRunIdSegment(value) {
     return value.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -1474,6 +1602,7 @@ function readMadmaxDetachedActiveRecord(recordPath) {
             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 } : {}),
+            ...(typeof parsed.worktree_cwd === "string" ? { worktree_cwd: parsed.worktree_cwd } : {}),
         };
     }
     catch {
@@ -1607,6 +1736,43 @@ export function withMadmaxDetachedContextLock(runsRoot, contextKey, run, options
     }
     throw new MadmaxDetachedGuardError(`timed out waiting for madmax detached launch context lock: ${lockPath} (${lastDiagnostic})`);
 }
+function readMadmaxRunMetadata(runRoot) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(runRoot, ".omxbox-run.json"), "utf-8"));
+        return {
+            ...(typeof parsed.cwd === "string" ? { cwd: parsed.cwd } : {}),
+            ...(typeof parsed.detached_launch_context === "string"
+                ? { detached_launch_context: parsed.detached_launch_context }
+                : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function resolveInheritedMadmaxRoot(env) {
+    const root = env.OMX_ROOT?.trim() || env.OMX_STATE_ROOT?.trim();
+    return root || undefined;
+}
+function madmaxInheritedContextMatchesLaunch(cwd, launchArgs, env) {
+    if (env.OMXBOX_ACTIVE !== "1")
+        return false;
+    const context = env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+    if (!context)
+        return false;
+    const inheritedRoot = resolveInheritedMadmaxRoot(env);
+    if (!inheritedRoot)
+        return false;
+    const metadata = readMadmaxRunMetadata(inheritedRoot);
+    if (!metadata)
+        return false;
+    if (metadata.cwd && metadata.cwd !== inheritedRoot)
+        return false;
+    if (metadata.detached_launch_context !== context)
+        return false;
+    const expectedContext = buildMadmaxDetachedLaunchContextKey(cwd, [...launchArgs], inheritedRoot);
+    return expectedContext === context;
+}
 function isMadmaxDetachedGuardEnabled(env) {
     return env.OMXBOX_ACTIVE === "1" && typeof env[OMX_MADMAX_DETACHED_CONTEXT_ENV] === "string";
 }
@@ -1651,7 +1817,7 @@ export function createMadmaxIsolatedRoot(sourceCwd, argv, env = process.env) {
     return runDir;
 }
 function activateMadmaxIsolationIfNeeded(command, launchArgs, cwd, env = process.env) {
-    if (!shouldAutoIsolateMadmaxLaunch(command, launchArgs, env))
+    if (!shouldAutoIsolateMadmaxLaunch(command, launchArgs, env, cwd))
         return;
     const runDir = createMadmaxIsolatedRoot(cwd, launchArgs, env);
     env.OMX_ROOT = runDir;
@@ -2066,6 +2232,7 @@ export async function launchWithAuthHotswap(args) {
             }
         }
     }
+    clearInheritedMadmaxRootForDisposableWorktreeLaunch(parsedWorktree.remainingArgs);
     applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
     try {
         await maybeCheckAndPromptUpdate(cwd);
@@ -2165,6 +2332,14 @@ export async function launchWithHud(args) {
             }
         }
     }
+    const madmaxWorktreeRuntimeContext = captureMadmaxWorktreeRuntimeContext({
+        originalLaunchArgs: args,
+        worktreeEnabled: Boolean(parsedWorktree.mode.enabled && ensuredLaunchWorktree?.enabled),
+        sourceCwd: launchCwd,
+        worktreeCwd: ensuredLaunchWorktree?.enabled ? ensuredLaunchWorktree.worktreePath : undefined,
+        env: process.env,
+    });
+    clearInheritedMadmaxRootForDisposableWorktreeLaunch(parsedWorktree.remainingArgs);
     applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
     const sessionId = `omx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     try {
@@ -2195,14 +2370,14 @@ export async function launchWithHud(args) {
     catch {
         // Non-fatal: repair failure must not block launch
     }
-    const resumePrepared = normalizedArgs[0] === "resume"
+    const resumePrepared = isResumeCodexLaunch(normalizedArgs)
         ? await prepareResumeCodexHomeForLaunch(launchCwd, sessionId, normalizedArgs, process.env)
         : null;
     if (resumePrepared) {
         normalizedArgs = resumePrepared.args;
     }
     const preparedCodexHome = resumePrepared?.prepared ?? await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env, {
-        includeHistoryArtifacts: normalizedArgs[0] === "resume",
+        includeHistoryArtifacts: isResumeCodexLaunch(normalizedArgs),
     });
     const codexHomeOverride = preparedCodexHome.codexHomeOverride;
     const sqliteHomeOverride = preparedCodexHome.sqliteHomeOverride;
@@ -2221,7 +2396,7 @@ export async function launchWithHud(args) {
         const notifyTempContractRaw = notifyTempResult.contract.active
             ? serializeNotifyTempContract(notifyTempResult.contract)
             : null;
-        const launchResult = runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, sqliteHomeOverride, notifyTempContractRaw, effectiveExplicitLaunchPolicy, projectLocalCodexHomeForCleanup, preparedCodexHome.runtimeCodexHomeForCleanup);
+        const launchResult = runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, sqliteHomeOverride, notifyTempContractRaw, effectiveExplicitLaunchPolicy, projectLocalCodexHomeForCleanup, preparedCodexHome.runtimeCodexHomeForCleanup, madmaxWorktreeRuntimeContext);
         postLaunchHandledExternally = launchResult.postLaunchHandledExternally;
     }
     finally {
@@ -2264,6 +2439,7 @@ export async function execWithOverlay(args) {
             }
         }
     }
+    clearInheritedMadmaxRootForDisposableWorktreeLaunch(parsedWorktree.remainingArgs);
     applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
     const sessionId = `omx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     try {
@@ -2982,7 +3158,7 @@ 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, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, env = process.env, sqliteHomeOverride, parentEnvFilePath) {
+export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, env = process.env, sqliteHomeOverride, parentEnvFilePath, inheritedWorkerModel) {
     const detachedLeaderCmd = nativeWindows
         ? "powershell.exe"
         : buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnvFilePath);
@@ -3013,17 +3189,19 @@ export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, h
         sessionName,
         "-c",
         cwd,
-        ...(workerLaunchArgs
-            ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`]
-            : []),
+        ...(workerLaunchArgs ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`] : []),
         ...Object.entries(hudRuntimeEnv).map(([key, value]) => ["-e", `${key}=${value}`]).flat(),
         ...(codexHomeOverride ? ["-e", `CODEX_HOME=${codexHomeOverride}`] : []),
         ...(sqliteHomeOverride ? ["-e", `${CODEX_SQLITE_HOME_ENV}=${sqliteHomeOverride}`] : []),
         ...(env.OMXBOX_ACTIVE ? ["-e", `OMXBOX_ACTIVE=${env.OMXBOX_ACTIVE}`] : []),
         ...(env.OMX_SOURCE_CWD ? ["-e", `OMX_SOURCE_CWD=${env.OMX_SOURCE_CWD}`] : []),
+        ...(env[OMX_MADMAX_DETACHED_CONTEXT_ENV]
+            ? ["-e", `${OMX_MADMAX_DETACHED_CONTEXT_ENV}=${env[OMX_MADMAX_DETACHED_CONTEXT_ENV]}`]
+            : []),
         ...(notifyTempContractRaw
             ? ["-e", `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`]
             : []),
+        ...(inheritedWorkerModel ? ["-e", `${TEAM_WORKER_INHERITED_MODEL_ENV}=${inheritedWorkerModel}`] : []),
         detachedLeaderCmd,
     ];
     const splitCaptureArgs = [
@@ -3606,42 +3784,59 @@ ${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, sqliteHomeOverride, notifyTempContractRaw, explicitLaunchPolicy, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, sqliteHomeOverride, notifyTempContractRaw, explicitLaunchPolicy, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, runtimeContext) {
     const launchArgs = injectModelInstructionsBypassArgs(cwd, args, process.env, sessionModelInstructionsPath(cwd, sessionId));
     const nativeWindows = isNativeWindows();
     const omxBin = resolveOmxCliEntryPath({ argv1: process.argv[1], cwd, env: process.env });
     if (!omxBin) {
         throw new Error("Unable to resolve OMX launcher path for tmux HUD bootstrap");
     }
-    const omxRootOverride = resolveOmxRootForLaunch(cwd, process.env);
+    const runtimeEnvOverlay = buildMadmaxWorktreeRuntimeEnvOverlay(runtimeContext);
+    const omxRootOverride = runtimeContext?.omxRoot ?? resolveOmxRootForLaunch(cwd, process.env);
     const currentPaneId = process.env.TMUX_PANE;
-    const hudRuntimeRoot = resolveHudRuntimeRootForLaunch(cwd, process.env);
-    const hudEnvArgs = Object.entries(buildHudRuntimeEnv({
-        sessionId,
-        leaderPaneId: currentPaneId,
-        ...hudRuntimeRoot,
-    }).env).map(([key, value]) => `${key}=${value}`);
+    const hudRuntimeRoot = runtimeContext
+        ? { omxRoot: runtimeContext.omxRoot, rootSource: 'omx-root-env' }
+        : resolveHudRuntimeRootForLaunch(cwd, process.env);
+    const hudRuntimeEnv = {
+        ...buildHudRuntimeEnv({
+            sessionId,
+            leaderPaneId: currentPaneId,
+            ...hudRuntimeRoot,
+        }).env,
+        ...runtimeEnvOverlay,
+    };
+    const hudEnvArgs = Object.entries(hudRuntimeEnv).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 inheritedWorkerLaunchArgs = inheritLeaderFlags
+        ? collectInheritableTeamWorkerArgsShared(launchArgs)
+        : [];
+    const inheritedWorkerModel = parseTeamWorkerLaunchArgs(inheritedWorkerLaunchArgs).modelOverride ?? undefined;
     const workerLaunchArgs = resolveTeamWorkerLaunchArgsEnv(process.env[TEAM_WORKER_LAUNCH_ARGS_ENV], launchArgs, inheritLeaderFlags, workerDefaultModel);
     const codexBaseEnv = prependOmxRuntimeCommandShimToEnv(cwd, {
         ...stripHermesMcpBridgeEnv(process.env),
         ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
         ...(sqliteHomeOverride ? { [CODEX_SQLITE_HOME_ENV]: sqliteHomeOverride } : {}),
         ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+        ...runtimeEnvOverlay,
     }, omxBin);
     const codexEnvWithSession = {
         ...codexBaseEnv,
         ...buildHudRuntimeEnv({ sessionId }).env,
     };
     const codexEnv = workerLaunchArgs
-        ? { ...codexEnvWithSession, [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs }
+        ? {
+            ...codexEnvWithSession,
+            [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs,
+            ...(inheritedWorkerModel ? { [TEAM_WORKER_INHERITED_MODEL_ENV]: inheritedWorkerModel } : {}),
+        }
         : codexEnvWithSession;
     const codexEnvWithNotify = notifyTempContractRaw
         ? { ...codexEnv, [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw }
         : codexEnv;
+    const runtimeHookEnv = { ...process.env, ...runtimeEnvOverlay };
     const { launchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows);
     if (isCodexVersionRequest(launchArgs)) {
         runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
@@ -3679,6 +3874,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                     cwd,
                     sessionId,
                     omxRootOverride,
+                    baseEnv: runtimeHookEnv,
                 });
             }
             catch (err) {
@@ -3705,6 +3901,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                     cwd,
                     sessionId,
                     omxRootOverride,
+                    baseEnv: runtimeHookEnv,
                 });
             }
             catch (err) {
@@ -3771,7 +3968,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
             : null;
         const sessionName = buildDetachedTmuxSessionName(cwd, sessionId);
         const launchDetachedSession = () => {
-            const contextKey = process.env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+            const contextKey = runtimeContext?.madmaxDetachedContext ?? process.env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
             const runsRoot = resolveMadmaxRunsRoot(process.env);
             const activeRecordPath = contextKey
                 ? madmaxDetachedActiveRecordPath(runsRoot, contextKey)
@@ -3836,7 +4033,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                 if (!nativeWindows) {
                     detachedParentEnvFilePath = writeDetachedSessionParentEnvFile(cwd, sessionId, codexEnvWithNotify);
                 }
-                const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, process.env, sqliteHomeOverride, detachedParentEnvFilePath);
+                const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, runtimeHookEnv, sqliteHomeOverride, detachedParentEnvFilePath, inheritedWorkerModel);
                 for (const step of bootstrapSteps) {
                     const output = execTmuxFileSync(step.args, {
                         stdio: "pipe",
@@ -3853,9 +4050,10 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                                     version: 1,
                                     context_key: contextKey,
                                     created_at: new Date().toISOString(),
-                                    source_cwd: process.env.OMX_SOURCE_CWD || cwd,
+                                    source_cwd: runtimeContext?.sourceCwd ?? process.env.OMX_SOURCE_CWD ?? cwd,
+                                    ...(runtimeContext?.worktreeCwd ? { worktree_cwd: runtimeContext.worktreeCwd } : {}),
                                     argv: args,
-                                    run_dir: process.env.OMX_ROOT || cwd,
+                                    run_dir: runtimeContext?.omxRoot ?? process.env.OMX_ROOT ?? cwd,
                                     tmux_session_name: sessionName,
                                     session_id: sessionId,
                                     tmux_pane_id: leaderPaneId,
@@ -3924,6 +4122,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                                     sessionId,
                                     omxBin,
                                     omxRootOverride,
+                                    baseEnv: runtimeHookEnv,
                                 });
                             }
                         }
@@ -4663,6 +4862,7 @@ async function listHookVisibleRunDirStateRefs(cwd) {
             return;
         const record = raw;
         const sourceCwd = typeof record.source_cwd === "string" ? record.source_cwd.trim() : "";
+        const worktreeCwd = typeof record.worktree_cwd === "string" ? record.worktree_cwd.trim() : "";
         const runDir = typeof record.run_dir === "string"
             ? record.run_dir.trim()
             : typeof record.cwd === "string"
@@ -4671,7 +4871,8 @@ async function listHookVisibleRunDirStateRefs(cwd) {
         if (!sourceCwd || !runDir)
             return;
         try {
-            if (canonicalizePathForRunDirMatch(sourceCwd) !== canonicalCwd)
+            if (canonicalizePathForRunDirMatch(sourceCwd) !== canonicalCwd &&
+                (!worktreeCwd || canonicalizePathForRunDirMatch(worktreeCwd) !== canonicalCwd))
                 return;
             const resolvedRunDir = resolve(runDir);
             if (resolvedRunDir !== canonicalRunsRoot