oh-my-codex-pennix 0.18.13

package/dist/cli/index.js

@@ -0,0 +1,4590 @@
+/**
+ * oh-my-codex CLI
+ * Multi-agent orchestration for OpenAI Codex CLI
+ */
+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 { constants as osConstants, homedir } from "os";
+import { createHash } from "crypto";
+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";
+import { hooksCommand } from "./hooks.js";
+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";
+import { cleanupCommand, cleanupOmxMcpProcesses, findLaunchSafeCleanupCandidates, } from "./cleanup.js";
+import { exploreCommand } from "./explore.js";
+import { sparkshellCommand } from "./sparkshell.js";
+import { apiCommand } from "./api.js";
+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";
+import { listCommand } from "./list.js";
+import { authCommand } from "./auth.js";
+import { runAuthHotswap } from "../auth/hotswap.js";
+import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FLAG, SPARK_FLAG, MADMAX_SPARK_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, } from "./constants.js";
+import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from "../mcp/state-paths.js";
+import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
+import { readPersistedSetupPreferences, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.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";
+import { isTrackedWorkflowMode } from "../state/workflow-transition.js";
+import { maybeCheckAndPromptUpdate, runImmediateUpdate } from "./update.js";
+import { maybePromptGithubStar } from "./star-prompt.js";
+import { generateOverlay, removeSessionModelInstructionsFile, resolveSessionOrchestrationMode, sessionModelInstructionsPath, writeSessionModelInstructionsFile, } from "../hooks/agents-overlay.js";
+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, omxRoot, rememberOmxLaunchContext, resolveOmxCliEntryPath } from "../utils/paths.js";
+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, HUD_TMUX_MIN_LAUNCH_WINDOW_HEIGHT_LINES, isTmuxWindowTooCrampedForHudSplit } from "../hud/constants.js";
+import { OMX_TMUX_HUD_OWNER_ENV } from "../hud/reconcile.js";
+import { readUltragoalState } from "../hud/state.js";
+import { createHudWatchPane as createSharedHudWatchPane, killTmuxPane as killSharedTmuxPane, listCurrentWindowHudPaneIds, listCurrentWindowPanes, buildHudRuntimeEnv, parsePaneIdFromTmuxOutput, reapDeadHudPanes, registerHudResizeHook, OMX_TMUX_HUD_LEADER_PANE_ENV, readCurrentWindowSize, resizeTmuxPane, unregisterHudResizeHook, } from "../hud/tmux.js";
+export { parseTmuxPaneSnapshot, isHudWatchPane, findHudWatchPaneIds } from "../hud/tmux.js";
+rememberOmxLaunchContext({ argv1: process.argv[1], cwd: process.cwd(), env: process.env });
+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 { 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";
+import { execInjectCommand } from "../exec/followup.js";
+import { imagegenCommand } from "../imagegen/continuation.js";
+export function resolveNotifyFallbackWatcherScript(pkgRoot = getPackageRoot()) {
+    return resolveDistScript(pkgRoot, "notify-fallback-watcher.js");
+}
+export function resolveHookDerivedWatcherScript(pkgRoot = getPackageRoot()) {
+    return resolveDistScript(pkgRoot, "hook-derived-watcher.js");
+}
+export function resolveNotifyHookScript(pkgRoot = getPackageRoot()) {
+    return resolveDistScript(pkgRoot, "notify-hook.js");
+}
+function resolveDistScript(pkgRoot, scriptName) {
+    return join(pkgRoot, "dist", "scripts", scriptName);
+}
+export const HELP = `
+oh-my-codex (omx) - Multi-agent orchestration for Codex CLI
+
+Usage:
+  omx           Launch Codex CLI (detached tmux by default on supported interactive terminals)
+  omx exec      Run codex exec non-interactively with OMX AGENTS/overlay injection
+  omx exec inject <session-id> --prompt <text>
+                Queue audited follow-up instructions for a running non-interactive exec job
+  omx imagegen continuation <session-id> --artifact <name>
+                Queue a Stop-hook continuation for built-in image generation turns
+  omx setup     Install skills, prompts, CLI-first config, and scope-specific AGENTS.md
+                (user scope prompts for legacy vs plugin skill delivery when needed)
+  omx update    Install the stable channel now, then refresh setup
+  omx update --stable
+                Install/rollback to npm stable (oh-my-codex@latest), then refresh setup
+  omx update --dev
+                Install the upstream dev branch, then refresh setup
+  omx uninstall Remove OMX configuration and clean up installed artifacts
+  omx doctor    Check installation health
+  omx list      List packaged OMX skills and native agent prompts (--json)
+  omx cleanup   Kill orphaned OMX MCP server processes and remove stale OMX /tmp directories
+  omx doctor --team  Check team/swarm runtime health diagnostics
+  omx ask       Ask local provider CLI (claude|gemini) and write artifact output
+  omx auth      Manage Codex OAuth auth slots (add|list|use)
+  omx question  OMX-owned blocking question UI entrypoint for agent-invoked user questions
+  omx adapt     Scaffold OMX-owned adapter foundations for persistent external targets
+  omx resume    Resume a previous interactive Codex session
+  omx explore   DEPRECATED compatibility command; use normal repo inspection or omx sparkshell
+  omx api       Run native omx-api localhost gateway commands (serve|status|stop|generate)
+  omx session   Search prior local session transcripts and history artifacts
+  omx agents-init [path]
+                Bootstrap lightweight AGENTS.md files for a repo/subtree
+  omx agents    Manage Codex native agent TOML files
+  omx deepinit [path]
+                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)
+  omx hooks     Manage hook plugins (init|status|validate|test)
+  omx hud       Show HUD statusline (--watch, --json, --preset=NAME)
+  omx sidecar   Show read-only team/multi-agent visualization (--watch, --json, --tmux)
+  omx state     Read/write/list OMX mode state via CLI parity surface
+  omx notepad   JSON CLI surface for OMX notepad operations
+  omx project-memory
+                JSON CLI surface for OMX project-memory operations
+  omx trace     JSON CLI surface for OMX trace operations
+  omx code-intel
+                JSON CLI surface for OMX code-intel operations
+  omx wiki      JSON CLI surface for OMX wiki operations
+  omx mcp-serve Launch an OMX stdio MCP server target (plugin/runtime use)
+  omx sparkshell <command> [args...]
+  omx sparkshell --tmux-pane <pane-id> [--tail-lines <100-1000>]
+                Run native sparkshell sidecar for direct command execution or explicit tmux-pane summarization
+                (also used as an adaptive backend for qualifying read-only explore tasks)
+  omx help      Show this help message
+  omx status    Show active modes and state
+  omx cancel    Cancel active execution modes
+  omx reasoning Show or set model reasoning effort (low|medium|high|xhigh)
+
+Options:
+  --yolo        Launch Codex in yolo mode (shorthand for: omx launch --yolo)
+  --high        Launch Codex with high reasoning effort
+                (shorthand for: -c model_reasoning_effort="high")
+  --xhigh       Launch Codex with xhigh reasoning effort
+                (shorthand for: -c model_reasoning_effort="xhigh")
+  --madmax      DANGEROUS: bypass Codex approvals and sandbox
+                (alias for --dangerously-bypass-approvals-and-sandbox)
+  --spark       Use the Codex spark model (~1.3x faster) for team workers only
+                Workers get the configured low-complexity team model; leader model unchanged
+  --madmax-spark  spark model for workers + bypass approvals for leader and workers
+                (shorthand for: --spark --madmax)
+  --notify-temp  Enable temporary notification routing for this run/session only
+  --hotswap     Run a direct Codex session that rotates auth slots on 429/quota and resumes
+  --direct       Launch the interactive leader directly without OMX tmux/HUD management
+  --tmux         Launch the interactive leader session in detached tmux
+  --discord      Select Discord provider for temporary notification mode
+  --slack        Select Slack provider for temporary notification mode
+  --telegram     Select Telegram provider for temporary notification mode
+  --custom <name>
+                Select custom/OpenClaw gateway name for temporary notification mode
+  -w, --worktree[=<name>]
+                Launch Codex in a git worktree (detached when no name is given)
+  --force       Force reinstall (overwrite existing files)
+  --merge-agents
+                Merge OMX-managed AGENTS.md sections into an existing AGENTS.md
+                instead of overwriting user-authored content
+  --dry-run     Show what would be done without doing it
+  --plugin      Use Codex plugin delivery for omx setup and remove legacy OMX-managed user/project components
+  --legacy      Use legacy setup delivery for omx setup, overriding persisted plugin mode
+  --install-mode <legacy|plugin>
+                Explicit setup install mode (canonical form; --legacy/--plugin are aliases)
+  --mcp <none|compat>
+                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
+  --scope       Setup scope for "omx setup" only:
+                user | project
+
+Launch policy:
+  OMX_LAUNCH_POLICY=auto
+                Use the default policy: detached tmux when supported, direct otherwise
+  OMX_LAUNCH_POLICY=direct
+                Run without OMX tmux/HUD management
+  OMX_LAUNCH_POLICY=tmux
+                Force OMX-managed detached tmux launch
+  OMX_LAUNCH_POLICY=detached-tmux
+                Force OMX-managed detached tmux launch
+  CLI policy flags (--direct/--tmux) override OMX_LAUNCH_POLICY; the last flag before -- wins.
+  Unset or empty OMX_LAUNCH_POLICY returns to auto/default behavior.
+  Config files are intentionally not used for launch policy in this release.
+`;
+const REASONING_KEY = "model_reasoning_effort";
+const MODEL_INSTRUCTIONS_FILE_KEY = "model_instructions_file";
+const TEAM_WORKER_LAUNCH_ARGS_ENV = "OMX_TEAM_WORKER_LAUNCH_ARGS";
+const TEAM_INHERIT_LEADER_FLAGS_ENV = "OMX_TEAM_INHERIT_LEADER_FLAGS";
+const OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV = "OMX_BYPASS_DEFAULT_SYSTEM_PROMPT";
+const OMX_MODEL_INSTRUCTIONS_FILE_ENV = "OMX_MODEL_INSTRUCTIONS_FILE";
+const OMX_INSTANCE_OPTION = "@omx_instance_id";
+const OMX_RALPH_APPEND_INSTRUCTIONS_FILE_ENV = "OMX_RALPH_APPEND_INSTRUCTIONS_FILE";
+const OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV = "OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE";
+const REASONING_MODES = ["low", "medium", "high", "xhigh"];
+const REASONING_MODE_SET = new Set(REASONING_MODES);
+const REASONING_USAGE = "Usage: omx reasoning <low|medium|high|xhigh>";
+const ALLOWED_SHELLS = new Set([
+    "/bin/sh",
+    "/bin/bash",
+    "/bin/zsh",
+    "/bin/dash",
+    "/bin/fish",
+    "/usr/bin/sh",
+    "/usr/bin/bash",
+    "/usr/bin/zsh",
+    "/usr/bin/dash",
+    "/usr/bin/fish",
+    "/usr/local/bin/bash",
+    "/usr/local/bin/zsh",
+    "/usr/local/bin/fish",
+    "/opt/local/bin/zsh",
+    "/opt/homebrew/bin/zsh",
+]);
+const WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS = 2500;
+const CODEX_VERSION_FLAGS = new Set(["--version", "-V"]);
+const TMUX_EXTENDED_KEYS_MODE = "always";
+const TMUX_EXTENDED_KEYS_FALLBACK_MODE = "off";
+const TMUX_EXTENDED_KEYS_LEASE_DIR = "tmux-extended-keys";
+const TMUX_EXTENDED_KEYS_LOCK_RETRY_MS = 20;
+const TMUX_EXTENDED_KEYS_LOCK_MAX_ATTEMPTS = 100;
+const TMUX_EXTENDED_KEYS_LOCK_STALE_MS = 30_000;
+const NESTED_HELP_COMMANDS = new Set([
+    "ask",
+    "question",
+    "cleanup",
+    "auth",
+    "adapt",
+    "explore",
+    "autoresearch",
+    "autoresearch-goal",
+    "agents",
+    "agents-init",
+    "deepinit",
+    "exec",
+    "imagegen",
+    "hooks",
+    "list",
+    "hud",
+    "sidecar",
+    "state",
+    "wiki",
+    "mcp-serve",
+    "ralph",
+    "ultragoal",
+    "performance-goal",
+    "resume",
+    "session",
+    "api",
+    "sparkshell",
+    "team",
+    "tmux-hook",
+]);
+export function resolveSetupInstallModeArg(args) {
+    let value;
+    const setValue = (next, source) => {
+        if (value && value !== next) {
+            throw new Error(`Conflicting setup install mode flags: ${source} selects ${next}, but another flag already selected ${value}`);
+        }
+        value = next;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--plugin") {
+            setValue("plugin", arg);
+            continue;
+        }
+        if (arg === "--legacy") {
+            setValue("legacy", arg);
+            continue;
+        }
+        if (arg === "--install-mode") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup install mode value after --install-mode. Expected one of: legacy, plugin`);
+            }
+            if (next !== "legacy" && next !== "plugin") {
+                throw new Error(`Invalid setup install mode: ${next}. Expected one of: legacy, plugin`);
+            }
+            setValue(next, arg);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--install-mode=")) {
+            const next = arg.slice("--install-mode=".length);
+            if (next !== "legacy" && next !== "plugin") {
+                throw new Error(`Invalid setup install mode: ${next}. Expected one of: legacy, plugin`);
+            }
+            setValue(next, "--install-mode");
+        }
+    }
+    return value;
+}
+export function resolveSetupMcpModeArg(args) {
+    let value;
+    const setValue = (next, source) => {
+        if (value && value !== next) {
+            throw new Error(`Conflicting setup MCP mode flags: ${source} selects ${next}, but another flag already selected ${value}`);
+        }
+        value = next;
+    };
+    const parseValue = (next) => {
+        if (!SETUP_MCP_MODES.includes(next)) {
+            throw new Error(`Invalid setup MCP mode: ${next}. Expected one of: none, compat`);
+        }
+        return next;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--no-mcp") {
+            setValue("none", arg);
+            continue;
+        }
+        if (arg === "--with-mcp") {
+            setValue("compat", arg);
+            continue;
+        }
+        if (arg === "--mcp") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup MCP mode value after --mcp. Expected one of: none, compat`);
+            }
+            setValue(parseValue(next), arg);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--mcp=")) {
+            setValue(parseValue(arg.slice("--mcp=".length)), "--mcp");
+        }
+    }
+    return value;
+}
+export function resolveSetupScopeArg(args) {
+    let value;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--scope") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup scope value after --scope. Expected one of: ${SETUP_SCOPES.join(", ")}`);
+            }
+            value = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--scope=")) {
+            value = arg.slice("--scope=".length);
+        }
+    }
+    if (!value)
+        return undefined;
+    if (SETUP_SCOPES.includes(value)) {
+        return value;
+    }
+    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") {
+        return { command: "help", launchArgs: [] };
+    }
+    if (firstArg === "--version" || firstArg === "-v") {
+        return { command: "version", launchArgs: [] };
+    }
+    if (!firstArg || firstArg.startsWith("--")) {
+        return { command: "launch", launchArgs: firstArg ? args : [] };
+    }
+    if (firstArg === "launch") {
+        return { command: "launch", launchArgs: args.slice(1) };
+    }
+    if (firstArg === "exec") {
+        return { command: "exec", launchArgs: args.slice(1) };
+    }
+    if (firstArg === "resume") {
+        return { command: "resume", launchArgs: args.slice(1) };
+    }
+    return { command: firstArg, launchArgs: [] };
+}
+export function resolveUpdateChannelArg(args) {
+    let channel = 'stable';
+    let sawStable = false;
+    let sawDev = false;
+    for (const arg of args) {
+        if (arg === '--stable') {
+            sawStable = true;
+            channel = 'stable';
+            continue;
+        }
+        if (arg === '--dev') {
+            sawDev = true;
+            channel = 'dev';
+            continue;
+        }
+        throw new Error(`Unknown omx update option: ${arg}. Expected no flags, --stable, or --dev.`);
+    }
+    if (sawStable && sawDev) {
+        throw new Error('omx update --dev and --stable are mutually exclusive.');
+    }
+    return channel;
+}
+export function resolveNotifyTempContract(args, env = process.env) {
+    return parseNotifyTempContractFromArgs(args, env);
+}
+export function commandOwnsLocalHelp(command) {
+    return NESTED_HELP_COMMANDS.has(command);
+}
+const OMX_LAUNCH_POLICY_ENV = "OMX_LAUNCH_POLICY";
+let warnedInvalidEnvLaunchPolicy = false;
+function splitLeaderLaunchPolicyArgs(args) {
+    const remainingArgs = [];
+    let explicitPolicy;
+    let passthroughOnly = false;
+    for (const arg of args) {
+        if (passthroughOnly) {
+            remainingArgs.push(arg);
+            continue;
+        }
+        if (arg === "--") {
+            passthroughOnly = true;
+            remainingArgs.push(arg);
+            continue;
+        }
+        if (arg === "--direct") {
+            explicitPolicy = "direct";
+            continue;
+        }
+        if (arg === "--tmux") {
+            explicitPolicy = "detached-tmux";
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return { explicitPolicy, remainingArgs };
+}
+export function resolveLeaderLaunchPolicyOverride(args) {
+    return splitLeaderLaunchPolicyArgs(args).explicitPolicy;
+}
+export function resolveEnvLaunchPolicyOverride(env = process.env) {
+    const rawValue = env[OMX_LAUNCH_POLICY_ENV]?.trim();
+    if (!rawValue)
+        return undefined;
+    const value = rawValue.toLowerCase();
+    if (value === "auto")
+        return undefined;
+    if (value === "direct")
+        return "direct";
+    if (value === "tmux" || value === "detached-tmux")
+        return "detached-tmux";
+    if (!warnedInvalidEnvLaunchPolicy) {
+        warnedInvalidEnvLaunchPolicy = true;
+        console.warn(`[omx] warning: invalid ${OMX_LAUNCH_POLICY_ENV}="${rawValue}". ` +
+            "Expected direct, tmux, detached-tmux, or auto. Falling back to auto/default launch policy.");
+    }
+    return undefined;
+}
+export function resolveEffectiveLeaderLaunchPolicyOverride(args, env = process.env) {
+    return (resolveLeaderLaunchPolicyOverride(args) ?? resolveEnvLaunchPolicyOverride(env));
+}
+export function resolveCodexLaunchPolicy(env = process.env, _platform = process.platform, tmuxAvailable = isTmuxAvailable(), nativeWindows = isNativeWindows(), stdinIsTTY = Boolean(process.stdin.isTTY), stdoutIsTTY = Boolean(process.stdout.isTTY), explicitPolicy) {
+    if (explicitPolicy === "direct")
+        return "direct";
+    if (env.TMUX)
+        return "inside-tmux";
+    if (explicitPolicy === "detached-tmux")
+        return tmuxAvailable ? "detached-tmux" : "direct";
+    if (_platform === "win32")
+        return "direct";
+    if (nativeWindows)
+        return "direct";
+    if (!stdinIsTTY || !stdoutIsTTY)
+        return "direct";
+    return tmuxAvailable ? "detached-tmux" : "direct";
+}
+function resolveTmuxExecutableForLaunch() {
+    return resolveTmuxBinaryForPlatform() || "tmux";
+}
+export const CODEX_SQLITE_HOME_ENV = "CODEX_SQLITE_HOME";
+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);
+    }
+}
+function isCodexSqliteArtifact(entryName) {
+    return /^(?:state|logs)_\d+\.sqlite(?:-(?:shm|wal))?$/.test(entryName);
+}
+const PROJECT_LAUNCH_PERSISTED_RUNTIME_ENTRY_NAMES = new Set([
+    // Codex CLI writes browser/OTP login state here when CODEX_HOME points at
+    // the per-session mirror. Persist only the opaque file itself; never parse or
+    // log the contents.
+    "auth.json",
+]);
+// Mirroring these files into the runtime CODEX_HOME would cause Codex to load
+// them as user-scope config alongside the canonical project-scope copies under
+// <cwd>/.codex, duplicating every native hook and asking the user to re-trust
+// hooks on every launch. See GH issue #2470.
+const PROJECT_LAUNCH_RUNTIME_SKIPPED_ENTRY_NAMES = new Set(["hooks.json"]);
+function shouldPersistProjectLaunchRuntimeEntry(entryName) {
+    return PROJECT_LAUNCH_PERSISTED_RUNTIME_ENTRY_NAMES.has(entryName);
+}
+export async function persistProjectLaunchRuntimeAuthState(runtimeCodexHome, projectCodexHome) {
+    if (!runtimeCodexHome || !projectCodexHome)
+        return;
+    if (!existsSync(runtimeCodexHome))
+        return;
+    await mkdir(projectCodexHome, { recursive: true });
+    for (const entry of await readdir(runtimeCodexHome, { withFileTypes: true })) {
+        if (!shouldPersistProjectLaunchRuntimeEntry(entry.name) || !entry.isFile())
+            continue;
+        await copyFile(join(runtimeCodexHome, entry.name), join(projectCodexHome, entry.name));
+    }
+}
+export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectCodexHome, options = {}) {
+    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 })) {
+        if (isCodexSqliteArtifact(entry.name) && !options.includeHistoryArtifacts)
+            continue;
+        if (PROJECT_LAUNCH_RUNTIME_SKIPPED_ENTRY_NAMES.has(entry.name))
+            continue;
+        const source = join(projectCodexHome, entry.name);
+        const destination = join(runtimeCodexHome, entry.name);
+        if (entry.name === "config.toml") {
+            const projectHooksPath = join(projectCodexHome, "hooks.json");
+            const projectConfig = await readFile(source, "utf-8");
+            const launchConfig = repairProjectScopeTrustStateForLaunch(projectConfig, projectHooksPath);
+            if (launchConfig !== projectConfig) {
+                await writeFile(source, launchConfig, "utf-8");
+            }
+            await writeFile(destination, launchConfig, "utf-8");
+            continue;
+        }
+        await linkOrCopyCodexHomeEntry(source, destination);
+    }
+    return runtimeCodexHome;
+}
+function resolveProjectSqliteHomeForLaunch(projectCodexHome, env) {
+    const configured = env[CODEX_SQLITE_HOME_ENV];
+    if (typeof configured === "string" && configured.trim() !== "")
+        return undefined;
+    return projectCodexHome;
+}
+export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.env, options = {}) {
+    const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(cwd, env);
+    if (projectLocalCodexHomeForCleanup) {
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup, { includeHistoryArtifacts: options.includeHistoryArtifacts });
+        return {
+            codexHomeOverride: runtimeCodexHome,
+            sqliteHomeOverride: resolveProjectSqliteHomeForLaunch(projectLocalCodexHomeForCleanup, env),
+            projectLocalCodexHomeForCleanup,
+            runtimeCodexHomeForCleanup: runtimeCodexHome,
+        };
+    }
+    return {
+        codexHomeOverride: resolveCodexHomeForLaunch(cwd, env),
+        projectLocalCodexHomeForCleanup,
+    };
+}
+export async function persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHome, projectCodexHome) {
+    if (!runtimeCodexHome || !projectCodexHome)
+        return;
+    const runtimeConfigPath = join(runtimeCodexHome, "config.toml");
+    if (!existsSync(runtimeConfigPath))
+        return;
+    const projectConfigPath = join(projectCodexHome, "config.toml");
+    const runtimeConfig = await readFile(runtimeConfigPath, "utf-8");
+    const projectConfig = existsSync(projectConfigPath)
+        ? await readFile(projectConfigPath, "utf-8")
+        : "";
+    const projectHooksPath = join(projectCodexHome, "hooks.json");
+    const nextProjectConfig = syncProjectScopeTrustStateFromRuntime(projectConfig, runtimeConfig, projectHooksPath);
+    if (nextProjectConfig !== projectConfig) {
+        await mkdir(projectCodexHome, { recursive: true });
+        await writeFile(projectConfigPath, nextProjectConfig, "utf-8");
+    }
+}
+export async function cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence) {
+    if (!runtimeCodexHomeForCleanup)
+        return;
+    await persistProjectLaunchRuntimeAuthState(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
+    await persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
+    await rm(runtimeCodexHomeForCleanup, { recursive: true, force: true });
+}
+function execTmuxFileSync(args, options) {
+    return execFileSync(resolveTmuxExecutableForLaunch(), args, {
+        ...(options ?? {}),
+        ...(process.platform === "win32" ? { windowsHide: true } : {}),
+    });
+}
+function readTmuxEnvValueForTarget(targetPaneId) {
+    if (!targetPaneId.startsWith("%"))
+        return undefined;
+    try {
+        const raw = execTmuxFileSync(["display-message", "-p", "-t", targetPaneId, "#{socket_path},#{pid},#{session_id}"], { encoding: "utf-8" }).trim();
+        return raw.replace(/,\$(\d+)$/, ",$1") || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildInsideTmuxHudHookEnv(baseEnv, sessionId, currentPaneId, omxRootOverride) {
+    return {
+        ...baseEnv,
+        OMX_SESSION_ID: sessionId,
+        [OMX_TMUX_HUD_OWNER_ENV]: "1",
+        ...(currentPaneId ? { [OMX_TMUX_HUD_LEADER_PANE_ENV]: currentPaneId } : {}),
+        ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+    };
+}
+export function registerInsideTmuxHudResizeHook(options) {
+    const { hudPaneId, currentPaneId } = options;
+    if (!hudPaneId || !currentPaneId)
+        return false;
+    return (options.register ?? registerHudResizeHook)(hudPaneId, currentPaneId, HUD_TMUX_HEIGHT_LINES, {
+        cwd: options.cwd,
+        env: buildInsideTmuxHudHookEnv(options.baseEnv ?? process.env, options.sessionId, currentPaneId, options.omxRootOverride),
+    });
+}
+export function buildDetachedHudHookEnv(baseEnv, sessionId, detachedLeaderPaneId, tmuxEnvValue, omxBin, omxRootOverride) {
+    return {
+        ...baseEnv,
+        TMUX: tmuxEnvValue,
+        TMUX_PANE: detachedLeaderPaneId,
+        OMX_SESSION_ID: sessionId,
+        [OMX_TMUX_HUD_OWNER_ENV]: "1",
+        ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+        OMX_ENTRY_PATH: omxBin,
+    };
+}
+export function registerDetachedHudLayoutReconcileHook(options) {
+    const { hudPaneId, detachedLeaderPaneId } = options;
+    if (!hudPaneId || !detachedLeaderPaneId)
+        return false;
+    const tmuxEnvValue = (options.readTmuxEnvValue ?? readTmuxEnvValueForTarget)(detachedLeaderPaneId);
+    if (!tmuxEnvValue)
+        return false;
+    return (options.register ?? registerHudResizeHook)(hudPaneId, detachedLeaderPaneId, HUD_TMUX_HEIGHT_LINES, {
+        cwd: options.cwd,
+        env: buildDetachedHudHookEnv(options.baseEnv ?? process.env, options.sessionId, detachedLeaderPaneId, tmuxEnvValue, options.omxBin, options.omxRootOverride),
+    });
+}
+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) {
+    // The leader pane can be gone by the time the hook fires (e.g. crashed
+    // leader with a lingering session); suppress errors so tmux does not queue
+    // "(null):0: can't find pane" for the next attaching client.
+    return `if-shell -F '#{==:#{session_attached},0}' 'run-shell -b "tmux clear-history -t ${leaderPaneId} >/dev/null 2>&1 || true"'`;
+}
+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" &&
+        "code" in error &&
+        error.code === code);
+}
+function isMissingTmuxLaunchNoise(error) {
+    return error instanceof Error && /spawnSync tmux ENOENT/i.test(error.message);
+}
+function logCliOperationFailure(error) {
+    if (isMissingTmuxLaunchNoise(error))
+        return;
+    process.stderr.write(`[cli/index] operation failed: ${error}
+`);
+}
+function tmuxFailureMessage(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const err = error;
+    const stderr = typeof err.stderr === "string" ? err.stderr : err.stderr?.toString();
+    const stdout = typeof err.stdout === "string" ? err.stdout : err.stdout?.toString();
+    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));
+}
+export function checkDetachedTmuxLaunchHealth() {
+    try {
+        execTmuxFileSync(["list-sessions"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return { usable: true };
+    }
+    catch (err) {
+        const reason = tmuxFailureMessage(err);
+        if (isBenignMissingTmuxServerMessage(reason)) {
+            return { usable: true };
+        }
+        return { usable: false, reason };
+    }
+}
+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") {
+        return { launchPolicy, effectiveExplicitLaunchPolicy: explicitLaunchPolicy };
+    }
+    const tmuxHealth = checkDetachedTmuxLaunchHealth();
+    if (tmuxHealth.usable) {
+        return { launchPolicy, effectiveExplicitLaunchPolicy: explicitLaunchPolicy };
+    }
+    warnDetachedTmuxFallback(tmuxHealth.reason);
+    return { launchPolicy: "direct", effectiveExplicitLaunchPolicy: "direct" };
+}
+export function resolveSignalExitCode(signal) {
+    if (!signal)
+        return 1;
+    const signalNumber = osConstants.signals[signal];
+    if (typeof signalNumber === "number" && Number.isFinite(signalNumber)) {
+        return 128 + signalNumber;
+    }
+    return 1;
+}
+export function classifyCodexExecFailure(error) {
+    if (!error || typeof error !== "object") {
+        return {
+            kind: "launch-error",
+            message: String(error),
+        };
+    }
+    const err = error;
+    const code = typeof err.code === "string" ? err.code : undefined;
+    const message = typeof err.message === "string" && err.message.length > 0
+        ? err.message
+        : "unknown codex launch failure";
+    const hasExitStatus = typeof err.status === "number";
+    const hasSignal = typeof err.signal === "string" && err.signal.length > 0;
+    if (hasExitStatus || hasSignal) {
+        return {
+            kind: "exit",
+            code,
+            message,
+            exitCode: hasExitStatus
+                ? err.status
+                : resolveSignalExitCode(err.signal),
+            signal: hasSignal ? err.signal : undefined,
+        };
+    }
+    return {
+        kind: "launch-error",
+        code,
+        message,
+    };
+}
+export async function resolveLaunchConfigRepairOptions(cwd, configPath) {
+    let content;
+    const readConfig = async () => {
+        if (content !== undefined)
+            return content;
+        if (!existsSync(configPath))
+            return undefined;
+        content = await readFile(configPath, "utf-8");
+        return content;
+    };
+    const existingContent = await readConfig();
+    const sharedMcpRegistry = existingContent
+        ? extractSharedMcpRegistryServersFromConfig(existingContent)
+        : { servers: [] };
+    const sharedMcpOptions = sharedMcpRegistry.servers.length > 0
+        ? {
+            sharedMcpServers: sharedMcpRegistry.servers,
+            sharedMcpRegistrySource: sharedMcpRegistry.sourcePath,
+        }
+        : {};
+    if (readPersistedSetupPreferences(cwd)?.mcpMode === "compat") {
+        return { includeFirstPartyMcp: true, ...sharedMcpOptions };
+    }
+    if (existingContent) {
+        const hasExistingFirstPartyMcp = OMX_FIRST_PARTY_MCP_SERVER_NAMES.some((name) => new RegExp(`^\\s*\\[mcp_servers\\.${name}\\]\\s*$`, "m").test(existingContent));
+        if (hasExistingFirstPartyMcp || sharedMcpRegistry.servers.length > 0) {
+            return { includeFirstPartyMcp: hasExistingFirstPartyMcp, ...sharedMcpOptions };
+        }
+    }
+    return {
+        includeFirstPartyMcp: false,
+    };
+}
+function runCodexBlocking(cwd, launchArgs, codexEnv) {
+    const { result } = spawnPlatformCommandSync("codex", launchArgs, {
+        cwd,
+        stdio: "inherit",
+        env: codexEnv,
+        encoding: "utf-8",
+    });
+    if (result.error) {
+        const errno = result.error;
+        const kind = classifySpawnError(errno);
+        if (kind === "missing") {
+            console.error("[omx] failed to launch codex: executable not found in PATH");
+        }
+        else if (kind === "blocked") {
+            console.error(`[omx] failed to launch codex: executable is present but blocked in the current environment (${errno.code || "blocked"})`);
+        }
+        else {
+            console.error(`[omx] failed to launch codex: ${errno.message}`);
+        }
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        process.exitCode =
+            typeof result.status === "number"
+                ? result.status
+                : resolveSignalExitCode(result.signal);
+        if (result.signal) {
+            console.error(`[omx] codex exited due to signal ${result.signal}`);
+        }
+        else if (typeof result.status === "number") {
+            console.error(`[omx] codex exited with code ${result.status}`);
+        }
+    }
+}
+export function omxRuntimeCommandShimFileName(platform = process.platform) {
+    return platform === "win32" ? "omx.cmd" : "omx";
+}
+export function omxRuntimeCommandShimPath(cwd, platform = process.platform) {
+    return join(omxRoot(cwd), "runtime", "bin", omxRuntimeCommandShimFileName(platform));
+}
+function ensureRuntimeShimDirectory(path) {
+    if (existsSync(path)) {
+        const current = lstatSync(path);
+        if (current.isSymbolicLink()) {
+            throw new Error(`Refusing to create OMX runtime command shim through symlink directory: ${path}`);
+        }
+        if (!current.isDirectory()) {
+            throw new Error(`Refusing to create OMX runtime command shim because path is not a directory: ${path}`);
+        }
+        return;
+    }
+    mkdirSync(path, { mode: 0o700 });
+}
+function buildOmxRuntimeCommandShim(nodePath, omxBin, platform = process.platform) {
+    if (platform === "win32") {
+        return [
+            "@echo off",
+            `"${nodePath}" "${omxBin}" %*`,
+            "",
+        ].join("\r\n");
+    }
+    return [
+        "#!/bin/sh",
+        `exec ${quoteShellArg(nodePath)} ${quoteShellArg(omxBin)} "$@"`,
+        "",
+    ].join("\n");
+}
+export function ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath = process.execPath, platform = process.platform) {
+    const shimPath = omxRuntimeCommandShimPath(cwd, platform);
+    const shimDir = dirname(shimPath);
+    const rootDir = omxRoot(cwd);
+    const runtimeDir = dirname(shimDir);
+    ensureRuntimeShimDirectory(rootDir);
+    ensureRuntimeShimDirectory(runtimeDir);
+    ensureRuntimeShimDirectory(shimDir);
+    if (existsSync(shimPath)) {
+        const current = lstatSync(shimPath);
+        if (current.isDirectory()) {
+            throw new Error(`Refusing to replace OMX runtime command shim directory: ${shimPath}`);
+        }
+        if (current.isSymbolicLink()) {
+            rmSync(shimPath, { force: true });
+        }
+    }
+    writeFileSync(shimPath, buildOmxRuntimeCommandShim(nodePath, omxBin, platform), {
+        encoding: "utf-8",
+        mode: 0o700,
+    });
+    if (platform !== "win32") {
+        chmodSync(shimPath, 0o700);
+    }
+    return shimDir;
+}
+export function prependOmxRuntimeCommandShimToEnv(cwd, env, omxBin, nodePath = process.execPath, platform = process.platform) {
+    const shimDir = ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath, platform);
+    const pathDelimiter = platform === "win32" ? win32.delimiter : posix.delimiter;
+    const result = { ...env };
+    if (platform === "win32") {
+        // Windows env var names are case-insensitive; the inherited key is usually
+        // `Path`, not `PATH`. Find every case variant, preserve the existing value,
+        // prepend the shim directory, and collapse to a single key so the child does
+        // not see an empty `PATH` shadowing the real `Path` (which drops System32,
+        // WindowsPowerShell, etc.).
+        const pathVariants = Object.keys(result).filter((key) => key.toLowerCase() === "path");
+        let pathKey = "Path";
+        let currentPath = "";
+        for (const variant of pathVariants) {
+            const value = result[variant];
+            if (typeof value === "string" && value.length > 0) {
+                pathKey = variant;
+                currentPath = value;
+                break;
+            }
+        }
+        for (const variant of pathVariants) {
+            delete result[variant];
+        }
+        result[pathKey] = currentPath
+            ? `${shimDir}${pathDelimiter}${currentPath}`
+            : shimDir;
+    }
+    else {
+        const currentPath = typeof result.PATH === "string" ? result.PATH : "";
+        result.PATH = currentPath ? `${shimDir}${pathDelimiter}${currentPath}` : shimDir;
+    }
+    result.OMX_ENTRY_PATH = omxBin;
+    result.OMX_STARTUP_CWD =
+        typeof result.OMX_STARTUP_CWD === "string" && result.OMX_STARTUP_CWD.trim()
+            ? result.OMX_STARTUP_CWD
+            : cwd;
+    return result;
+}
+export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leaderPaneId) {
+    const targets = new Set(existingPaneIds.filter((id) => id.startsWith("%")));
+    if (createdPaneId && createdPaneId.startsWith("%")) {
+        targets.add(createdPaneId);
+    }
+    // Guard: never kill the leader's own pane under any circumstances.
+    if (leaderPaneId && leaderPaneId.startsWith("%")) {
+        targets.delete(leaderPaneId);
+    }
+    return [...targets];
+}
+function isCrossPlatformAbsolutePath(raw) {
+    return posix.isAbsolute(raw) || win32.isAbsolute(raw);
+}
+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 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() !== "");
+}
+export function resolveDisposableWorktreeOmxRootForLaunch(ensuredWorktree, env = process.env) {
+    if (!ensuredWorktree?.enabled)
+        return undefined;
+    if (hasExplicitOmxRootEnv(env))
+        return undefined;
+    return ensuredWorktree.repoRoot;
+}
+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) {
+    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, "");
+}
+const MADMAX_DETACHED_ACTIVE_DIR = "active-detached";
+const MADMAX_DETACHED_LOCK_STALE_MS = 30_000;
+const MADMAX_DETACHED_LOCK_RETRY_MS = 50;
+const MADMAX_DETACHED_LOCK_MAX_ATTEMPTS = 100;
+const OMX_MADMAX_DETACHED_CONTEXT_ENV = "OMX_MADMAX_DETACHED_CONTEXT";
+function resolveMadmaxRunsRoot(env = process.env) {
+    return env.OMX_RUNS_DIR || join(homedir(), ".omx-runs");
+}
+function canonicalizeLaunchCwd(cwd) {
+    try {
+        return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim() || cwd;
+    }
+    catch {
+        return cwd;
+    }
+}
+function normalizeMadmaxDetachedLaunchArgv(argv) {
+    const passthrough = [];
+    const semanticFlags = new Set();
+    let reasoningFlag = null;
+    let afterEndOfOptions = false;
+    for (const arg of argv) {
+        if (afterEndOfOptions) {
+            passthrough.push(arg);
+            continue;
+        }
+        if (arg === "--") {
+            afterEndOfOptions = true;
+            passthrough.push(arg);
+            continue;
+        }
+        if (arg === "--tmux" || arg === "--direct") {
+            continue;
+        }
+        if (arg === MADMAX_FLAG ||
+            arg === MADMAX_SPARK_FLAG) {
+            semanticFlags.add(arg);
+            continue;
+        }
+        if (arg === HIGH_REASONING_FLAG || arg === XHIGH_REASONING_FLAG) {
+            reasoningFlag = arg;
+            continue;
+        }
+        passthrough.push(arg);
+    }
+    return [
+        ...Array.from(semanticFlags).sort(),
+        ...(reasoningFlag ? [reasoningFlag] : []),
+        ...passthrough,
+    ];
+}
+export function buildMadmaxDetachedLaunchContextKey(sourceCwd, argv, runIdentity = "") {
+    // The boxed run root is part of the lock identity for auto-isolated madmax
+    // launches. That lets independent `omx --madmax --high` sessions share the
+    // same source cwd/argv without contending on one active-detached lock, while
+    // callers that intentionally reuse the same boxed context keep one key.
+    const payload = JSON.stringify({
+        source_cwd: canonicalizeLaunchCwd(sourceCwd),
+        argv: normalizeMadmaxDetachedLaunchArgv(argv),
+        run_identity: runIdentity,
+    });
+    return createHash("sha256").update(payload).digest("hex").slice(0, 32);
+}
+function madmaxDetachedActiveRecordPath(runsRoot, contextKey) {
+    return join(runsRoot, MADMAX_DETACHED_ACTIVE_DIR, `${contextKey}.json`);
+}
+function readMadmaxDetachedActiveRecord(recordPath) {
+    if (!existsSync(recordPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(recordPath, "utf-8"));
+        if (parsed.version !== 1 ||
+            typeof parsed.context_key !== "string" ||
+            typeof parsed.source_cwd !== "string" ||
+            typeof parsed.run_dir !== "string" ||
+            typeof parsed.tmux_session_name !== "string" ||
+            !Array.isArray(parsed.argv) ||
+            !parsed.argv.every((arg) => typeof arg === "string")) {
+            return null;
+        }
+        return {
+            version: 1,
+            context_key: parsed.context_key,
+            created_at: typeof parsed.created_at === "string" ? parsed.created_at : "",
+            source_cwd: parsed.source_cwd,
+            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" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readMadmaxDetachedLockOwner(lockPath) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(lockPath, "owner.json"), "utf-8"));
+        if (parsed.version !== 1 ||
+            typeof parsed.pid !== "number" ||
+            !Number.isSafeInteger(parsed.pid) ||
+            parsed.pid <= 0 ||
+            typeof parsed.context_key !== "string" ||
+            typeof parsed.acquired_at !== "string") {
+            return null;
+        }
+        return {
+            version: 1,
+            pid: parsed.pid,
+            context_key: parsed.context_key,
+            acquired_at: parsed.acquired_at,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readMadmaxDetachedLockPid(lockPath) {
+    const owner = readMadmaxDetachedLockOwner(lockPath);
+    if (owner)
+        return owner.pid;
+    try {
+        const holderPid = Number.parseInt(readFileSync(join(lockPath, "pid"), "utf-8").trim(), 10);
+        return Number.isSafeInteger(holderPid) && holderPid > 0 ? holderPid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function inspectMadmaxDetachedContextLock(lockPath) {
+    const lockStat = statSync(lockPath, { throwIfNoEntry: false });
+    if (!lockStat) {
+        return { stale: false, diagnostic: "lock disappeared while waiting" };
+    }
+    const ageMs = Math.max(0, Date.now() - lockStat.mtimeMs);
+    const owner = readMadmaxDetachedLockOwner(lockPath);
+    const holderPid = owner?.pid ?? readMadmaxDetachedLockPid(lockPath);
+    if (holderPid) {
+        if (!isProcessAlive(holderPid)) {
+            return {
+                stale: true,
+                diagnostic: `stale holder pid ${holderPid} is not running; lock age ${Math.round(ageMs)}ms`,
+            };
+        }
+        const ownerContext = owner ? `, owner context ${owner.context_key}` : ", legacy pid-only lock";
+        const sameDirectoryGuidance = "Another madmax detached launch is active for this directory; close the existing madmax session or use --worktree for concurrent work. Multiple madmax sessions in one directory are unsafe";
+        return {
+            stale: false,
+            diagnostic: `holder pid ${holderPid} is still running${ownerContext}; lock age ${Math.round(ageMs)}ms. ${sameDirectoryGuidance}`,
+        };
+    }
+    if (ageMs > MADMAX_DETACHED_LOCK_STALE_MS) {
+        return {
+            stale: true,
+            diagnostic: `legacy lock has no readable owner pid and is older than ${MADMAX_DETACHED_LOCK_STALE_MS}ms; lock age ${Math.round(ageMs)}ms`,
+        };
+    }
+    return {
+        stale: false,
+        diagnostic: `lock has no readable owner pid yet; lock age ${Math.round(ageMs)}ms`,
+    };
+}
+export function withMadmaxDetachedContextLock(runsRoot, contextKey, run, options = {}) {
+    const lockPath = join(runsRoot, MADMAX_DETACHED_ACTIVE_DIR, `${contextKey}.lock`);
+    const maxAttempts = options.maxAttempts ?? MADMAX_DETACHED_LOCK_MAX_ATTEMPTS;
+    const retryMs = options.retryMs ?? MADMAX_DETACHED_LOCK_RETRY_MS;
+    let lastDiagnostic = "lock was busy";
+    mkdirSync(dirname(lockPath), { recursive: true });
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            mkdirSync(lockPath);
+            try {
+                const owner = {
+                    version: 1,
+                    pid: process.pid,
+                    context_key: contextKey,
+                    acquired_at: new Date().toISOString(),
+                };
+                writeFileSync(join(lockPath, "owner.json"), `${JSON.stringify(owner, null, 2)}\n`, { mode: 0o600 });
+                writeFileSync(join(lockPath, "pid"), String(process.pid));
+                return run();
+            }
+            finally {
+                rmSync(lockPath, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            const code = err && typeof err === "object" && "code" in err
+                ? String(err.code)
+                : "";
+            if (code !== "EEXIST")
+                throw err;
+            const inspection = inspectMadmaxDetachedContextLock(lockPath);
+            lastDiagnostic = inspection.diagnostic;
+            if (inspection.stale) {
+                rmSync(lockPath, { recursive: true, force: true });
+                continue;
+            }
+            blockMs(retryMs);
+        }
+    }
+    throw new MadmaxDetachedGuardError(`timed out waiting for madmax detached launch context lock: ${lockPath} (${lastDiagnostic})`);
+}
+function isMadmaxDetachedGuardEnabled(env) {
+    return env.OMXBOX_ACTIVE === "1" && typeof env[OMX_MADMAX_DETACHED_CONTEXT_ENV] === "string";
+}
+function cleanupCurrentMadmaxReuseRunRoot(env, runsRoot) {
+    const runRoot = env.OMX_ROOT;
+    if (!runRoot || !env.OMXBOX_ACTIVE)
+        return;
+    const normalizedRunsRoot = runsRoot.endsWith("/") ? runsRoot : `${runsRoot}/`;
+    if (runRoot !== runsRoot && !runRoot.startsWith(normalizedRunsRoot))
+        return;
+    rmSync(runRoot, { recursive: true, force: true });
+}
+function writeMadmaxDetachedActiveRecord(recordPath, record) {
+    mkdirSync(dirname(recordPath), { recursive: true });
+    writeFileSync(recordPath, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+}
+class MadmaxDetachedReuseError extends Error {
+    failClosed = true;
+}
+class MadmaxDetachedGuardError extends Error {
+    failClosed = true;
+}
+export function createMadmaxIsolatedRoot(sourceCwd, argv, env = process.env) {
+    const runsRoot = resolveMadmaxRunsRoot(env);
+    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 detachedLaunchContext = buildMadmaxDetachedLaunchContextKey(sourceCwd, argv, runDir);
+    const metadata = {
+        launcher: "omx --madmax",
+        created_at: new Date().toISOString(),
+        cwd: runDir,
+        source_cwd: sourceCwd,
+        argv,
+        detached_launch_context: detachedLaunchContext,
+    };
+    writeFileSync(join(runDir, ".omxbox-run.json"), `${JSON.stringify(metadata, null, 2)}\n`);
+    writeFileSync(join(runsRoot, "registry.jsonl"), `${JSON.stringify(metadata)}\n`, { flag: "a" });
+    env[OMX_MADMAX_DETACHED_CONTEXT_ENV] = detachedLaunchContext;
+    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",
+        "exec",
+        "imagegen",
+        "setup",
+        "update",
+        "list",
+        "agents",
+        "agents-init",
+        "deepinit",
+        "uninstall",
+        "doctor",
+        "cleanup",
+        "auth",
+        "ask",
+        "question",
+        "autoresearch",
+        "autoresearch-goal",
+        "explore",
+        "api",
+        "sparkshell",
+        "team",
+        "ralph",
+        "ultragoal",
+        "performance-goal",
+        "session",
+        "resume",
+        "version",
+        "tmux-hook",
+        "hooks",
+        "hud",
+        "sidecar",
+        "state",
+        "mcp-serve",
+        "status",
+        "cancel",
+        "help",
+        "--help",
+        "-h",
+    ]);
+    const firstArg = args[0];
+    const { command, launchArgs } = resolveCliInvocation(args);
+    const flags = new Set(args.filter((a) => a.startsWith("--")));
+    const options = {
+        force: flags.has("--force"),
+        mergeAgents: flags.has("--merge-agents"),
+        dryRun: flags.has("--dry-run"),
+        verbose: flags.has("--verbose"),
+        team: flags.has("--team"),
+    };
+    if (flags.has("--help") && !commandOwnsLocalHelp(command)) {
+        console.log(HELP);
+        return;
+    }
+    activateMadmaxIsolationIfNeeded(command, launchArgs, process.cwd(), process.env);
+    try {
+        switch (command) {
+            case "launch":
+                if (launchArgs.includes("--hotswap")) {
+                    await launchWithAuthHotswap(launchArgs);
+                }
+                else {
+                    await launchWithHud(launchArgs);
+                }
+                break;
+            case "resume":
+                await launchWithHud(["resume", ...launchArgs]);
+                break;
+            case "setup":
+                await setup({
+                    force: options.force,
+                    mergeAgents: options.mergeAgents,
+                    dryRun: options.dryRun,
+                    verbose: options.verbose,
+                    scope: resolveSetupScopeArg(args.slice(1)),
+                    installMode: resolveSetupInstallModeArg(args.slice(1)),
+                    mcpMode: resolveSetupMcpModeArg(args.slice(1)),
+                    teamMode: resolveSetupTeamModeArg(args.slice(1)),
+                });
+                break;
+            case "update":
+                await runImmediateUpdate(process.cwd(), {}, { channel: resolveUpdateChannelArg(args.slice(1)) });
+                break;
+            case "list":
+                await listCommand(args.slice(1));
+                break;
+            case "agents":
+                await agentsCommand(args.slice(1));
+                break;
+            case "agents-init":
+                await agentsInitCommand(args.slice(1));
+                break;
+            case "deepinit":
+                await agentsInitCommand(args.slice(1));
+                break;
+            case "uninstall":
+                await uninstall({
+                    dryRun: options.dryRun,
+                    keepConfig: flags.has("--keep-config"),
+                    verbose: options.verbose,
+                    purge: flags.has("--purge"),
+                    scope: resolveSetupScopeArg(args.slice(1)),
+                });
+                break;
+            case "doctor": {
+                const { doctor } = await import("./doctor.js");
+                await doctor(options);
+                break;
+            }
+            case "ask":
+                await askCommand(args.slice(1));
+                break;
+            case "question":
+                await questionCommand(args.slice(1));
+                break;
+            case "adapt":
+                await adaptCommand(args.slice(1));
+                break;
+            case "cleanup":
+                await cleanupCommand(args.slice(1));
+                break;
+            case "auth":
+                await authCommand(args.slice(1));
+                break;
+            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;
+            case "api":
+                await apiCommand(args.slice(1));
+                break;
+            case "exec":
+                if (launchArgs[0] === "inject") {
+                    await execInjectCommand(launchArgs);
+                }
+                else {
+                    await execWithOverlay(launchArgs);
+                }
+                break;
+            case "imagegen":
+                await imagegenCommand(args.slice(1));
+                break;
+            case "sparkshell":
+                await sparkshellCommand(args.slice(1));
+                break;
+            case "team":
+                await teamCommand(args.slice(1), options);
+                break;
+            case "session":
+                await sessionCommand(args.slice(1));
+                break;
+            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;
+            case "hud":
+                await hudCommand(args.slice(1));
+                break;
+            case "sidecar":
+                await sidecarCommand(args.slice(1));
+                break;
+            case "state":
+                await stateCommand(args.slice(1));
+                break;
+            case "notepad":
+                await mcpParityCommand("notepad", args.slice(1));
+                break;
+            case "project-memory":
+                await mcpParityCommand("project-memory", args.slice(1));
+                break;
+            case "trace":
+                await mcpParityCommand("trace", args.slice(1));
+                break;
+            case "code-intel":
+                await mcpParityCommand("code-intel", args.slice(1));
+                break;
+            case "wiki":
+                await mcpParityCommand("wiki", args.slice(1));
+                break;
+            case "mcp-serve":
+                await mcpServeCommand(args.slice(1));
+                break;
+            case "tmux-hook":
+                await tmuxHookCommand(args.slice(1));
+                break;
+            case "hooks":
+                await hooksCommand(args.slice(1));
+                break;
+            case "status":
+                await showStatus();
+                break;
+            case "cancel":
+                await cancelModes();
+                break;
+            case "reasoning":
+                await reasoningCommand(args.slice(1));
+                break;
+            case "codex-native-hook": {
+                const { runCodexNativeHookCli } = await import("../scripts/codex-native-hook.js");
+                await runCodexNativeHookCli();
+                break;
+            }
+            case "help":
+            case "--help":
+            case "-h":
+                console.log(HELP);
+                break;
+            default:
+                if (firstArg &&
+                    firstArg.startsWith("-") &&
+                    !knownCommands.has(firstArg)) {
+                    await launchWithHud(args);
+                    break;
+                }
+                console.error(`Unknown command: ${command}`);
+                console.log(HELP);
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}
+async function showStatus() {
+    const { readFile } = await import("fs/promises");
+    const cwd = process.cwd();
+    try {
+        let refs = await listModeStateFilesWithScopePreference(cwd);
+        // Reconcile with hook-visible run-dir state when the worktree-scoped state
+        // list reports no active workflow mode (parity with `omx cancel`). This
+        // surfaces detached/madmax sessions whose state lives under the run dir.
+        const hasActiveWorkflowMode = async (candidate) => {
+            for (const ref of candidate) {
+                const mode = basename(ref.path).replace("-state.json", "");
+                if (mode === SKILL_ACTIVE_STATE_MODE)
+                    continue;
+                try {
+                    const parsed = JSON.parse(await readFile(ref.path, "utf-8"));
+                    if (parsed.active === true)
+                        return true;
+                }
+                catch {
+                    continue;
+                }
+            }
+            return false;
+        };
+        if (!(await hasActiveWorkflowMode(refs))) {
+            const runDirRefs = await listHookVisibleRunDirStateRefs(cwd);
+            if (await hasActiveWorkflowMode(runDirRefs))
+                refs = runDirRefs;
+        }
+        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;
+        }
+        for (const path of states) {
+            const content = await readFile(path, "utf-8");
+            let state;
+            try {
+                state = JSON.parse(content);
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+                continue;
+            }
+            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);
+        console.log("No active modes.");
+    }
+}
+async function reasoningCommand(args) {
+    const mode = args[0];
+    const configPath = codexConfigPath();
+    if (!mode) {
+        if (!existsSync(configPath)) {
+            console.log(`model_reasoning_effort is not set (${configPath} does not exist).`);
+            console.log(REASONING_USAGE);
+            return;
+        }
+        const { readFile } = await import("fs/promises");
+        const content = await readFile(configPath, "utf-8");
+        const current = readTopLevelTomlString(content, REASONING_KEY);
+        if (current) {
+            console.log(`Current ${REASONING_KEY}: ${current}`);
+            return;
+        }
+        console.log(`${REASONING_KEY} is not set in ${configPath}.`);
+        console.log(REASONING_USAGE);
+        return;
+    }
+    if (!REASONING_MODE_SET.has(mode)) {
+        throw new Error(`Invalid reasoning mode "${mode}". Expected one of: ${REASONING_MODES.join(", ")}.\n${REASONING_USAGE}`);
+    }
+    const { mkdir, readFile, writeFile } = await import("fs/promises");
+    await mkdir(dirname(configPath), { recursive: true });
+    const existing = existsSync(configPath)
+        ? await readFile(configPath, "utf-8")
+        : "";
+    const updated = upsertTopLevelTomlString(existing, REASONING_KEY, mode);
+    await writeFile(configPath, updated);
+    console.log(`Set ${REASONING_KEY}="${mode}" in ${configPath}`);
+}
+export async function launchWithAuthHotswap(args) {
+    const launchCwd = process.cwd();
+    const parsedWorktree = parseWorktreeMode(args);
+    let cwd = launchCwd;
+    let worktreeDirty = false;
+    let ensuredLaunchWorktree;
+    if (parsedWorktree.mode.enabled) {
+        const planned = planWorktreeTarget({
+            cwd: launchCwd,
+            scope: "launch",
+            mode: parsedWorktree.mode,
+        });
+        const ensured = ensureWorktree(planned, { allowDirtyReuse: true });
+        ensuredLaunchWorktree = ensured;
+        if (ensured.enabled) {
+            cwd = ensured.worktreePath;
+            worktreeDirty = Boolean(ensured.dirty);
+            if (ensured.dirty) {
+                process.stderr.write(`[omx] Caution: worktree at ${cwd} has uncommitted changes.\n` +
+                    `  The hotswap session will launch as-is.\n`);
+            }
+            const depBootstrap = ensureReusableNodeModules(cwd);
+            if (depBootstrap.strategy === "symlink") {
+                console.log(`[omx] Reusing node_modules from ${depBootstrap.sourceNodeModulesPath}`);
+            }
+            else if (depBootstrap.strategy === "missing" && depBootstrap.warning) {
+                console.warn(`[omx] ${depBootstrap.warning}`);
+            }
+        }
+    }
+    applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
+    try {
+        await maybeCheckAndPromptUpdate(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    try {
+        await maybePromptGithubStar();
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    try {
+        const configPath = resolveCodexConfigPathForLaunch(launchCwd, process.env);
+        const repaired = await repairConfigIfNeeded(configPath, getPackageRoot(), await resolveLaunchConfigRepairOptions(launchCwd, configPath));
+        if (repaired)
+            console.log("[omx] Repaired managed config.toml compatibility issue.");
+    }
+    catch {
+        // Non-fatal: repair failure must not block launch
+    }
+    const status = await runAuthHotswap({
+        cwd,
+        argv: parsedWorktree.remainingArgs,
+        lifecycle: {
+            prepareCodexHomeForLaunch,
+            preLaunch: (launchPath, sessionId, notifyTempContract, codexHomeOverride, enableAuthority) => preLaunch(launchPath, sessionId, notifyTempContract, codexHomeOverride, enableAuthority, worktreeDirty),
+            postLaunch,
+            cleanupRuntimeCodexHome,
+            normalizeCodexLaunchArgs,
+            injectModelInstructionsBypassArgs,
+            sessionModelInstructionsPath,
+            resolveOmxRootForLaunch,
+            resolveNotifyTempContract,
+        },
+    });
+    process.exitCode = status;
+}
+export async function launchWithHud(args) {
+    if (isNativeWindows()) {
+        const { result } = spawnPlatformCommandSync("tmux", ["-V"], {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (result.error) {
+            const errno = result.error;
+            const kind = classifySpawnError(errno);
+            if (kind === "missing") {
+                console.warn("[omx] warning: tmux was not found on native Windows. Continuing without tmux/HUD.\n" +
+                    "[omx] To enable tmux-backed features, install psmux:\n" +
+                    "[omx]   winget install psmux\n" +
+                    "[omx] See: https://github.com/marlocarlo/psmux");
+            }
+            else {
+                console.warn(`[omx] warning: tmux probe failed on native Windows (${errno.code || errno.message}). Continuing without tmux/HUD.`);
+            }
+        }
+        else if (result.status !== 0 && !isTmuxAvailable()) {
+            const stderr = (result.stderr || "").trim();
+            console.warn(`[omx] warning: tmux reported an error on native Windows${stderr ? ` (${stderr})` : ""}. Continuing without tmux/HUD.`);
+        }
+    }
+    const launchCwd = process.cwd();
+    const parsedWorktree = parseWorktreeMode(args);
+    const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
+    const explicitLaunchPolicy = resolveEffectiveLeaderLaunchPolicyOverride(notifyTempResult.passthroughArgs, process.env);
+    const persistentCodexHomeForLaunch = resolveCodexHomeForLaunch(launchCwd, process.env);
+    const { launchPolicy, effectiveExplicitLaunchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
+    const enableNotifyFallbackAuthority = launchPolicy === "direct";
+    const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, persistentCodexHomeForLaunch);
+    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
+    let cwd = launchCwd;
+    let worktreeDirty = false;
+    let ensuredLaunchWorktree;
+    if (parsedWorktree.mode.enabled) {
+        const planned = planWorktreeTarget({
+            cwd: launchCwd,
+            scope: "launch",
+            mode: parsedWorktree.mode,
+        });
+        const ensured = ensureWorktree(planned, { allowDirtyReuse: true });
+        ensuredLaunchWorktree = ensured;
+        if (ensured.enabled) {
+            cwd = ensured.worktreePath;
+            if (ensured.dirty) {
+                worktreeDirty = true;
+                process.stderr.write(`[omx] Caution: worktree at ${cwd} has uncommitted changes.\n` +
+                    `  The session will launch as-is. Resolve the dirty state with OMX after launch, then proceed with your task.\n`);
+            }
+            const depBootstrap = ensureReusableNodeModules(cwd);
+            if (depBootstrap.strategy === "symlink") {
+                console.log(`[omx] Reusing node_modules from ${depBootstrap.sourceNodeModulesPath}`);
+            }
+            else if (depBootstrap.strategy === "missing" && depBootstrap.warning) {
+                console.warn(`[omx] ${depBootstrap.warning}`);
+            }
+        }
+    }
+    applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
+    const sessionId = `omx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await maybeCheckAndPromptUpdate(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: update checks must never block launch
+    }
+    try {
+        await maybePromptGithubStar();
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: star prompt must never block launch
+    }
+    // ── Phase 0.5: config repair ────────────────────────────────────────────
+    // After an omx version upgrade the OLD setup code (still in memory) may
+    // have written a config.toml with duplicate [tui] sections.  Codex CLI's
+    // TOML parser rejects duplicates, so we repair before spawning the CLI.
+    try {
+        const configPath = resolveCodexConfigPathForLaunch(launchCwd, process.env);
+        const repaired = await repairConfigIfNeeded(configPath, getPackageRoot(), await resolveLaunchConfigRepairOptions(launchCwd, configPath));
+        if (repaired) {
+            console.log("[omx] Repaired managed config.toml compatibility issue.");
+        }
+    }
+    catch {
+        // Non-fatal: repair failure must not block launch
+    }
+    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env, {
+        includeHistoryArtifacts: normalizedArgs[0] === "resume",
+    });
+    const codexHomeOverride = preparedCodexHome.codexHomeOverride;
+    const sqliteHomeOverride = preparedCodexHome.sqliteHomeOverride;
+    const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
+    // ── Phase 1: preLaunch ──────────────────────────────────────────────────
+    try {
+        await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, enableNotifyFallbackAuthority, worktreeDirty);
+    }
+    catch (err) {
+        // preLaunch errors must NOT prevent Codex from starting
+        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;
+        const launchResult = runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, sqliteHomeOverride, notifyTempContractRaw, effectiveExplicitLaunchPolicy, projectLocalCodexHomeForCleanup, preparedCodexHome.runtimeCodexHomeForCleanup);
+        postLaunchHandledExternally = launchResult.postLaunchHandledExternally;
+    }
+    finally {
+        // ── Phase 3: postLaunch ─────────────────────────────────────────────
+        if (!postLaunchHandledExternally) {
+            await postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority, projectLocalCodexHomeForCleanup);
+            await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch(logCliOperationFailure);
+        }
+    }
+}
+export async function execWithOverlay(args) {
+    const launchCwd = process.cwd();
+    const parsedWorktree = parseWorktreeMode(args);
+    const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
+    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
+    let cwd = launchCwd;
+    let worktreeDirty = false;
+    let ensuredLaunchWorktree;
+    if (parsedWorktree.mode.enabled) {
+        const planned = planWorktreeTarget({
+            cwd: launchCwd,
+            scope: "launch",
+            mode: parsedWorktree.mode,
+        });
+        const ensured = ensureWorktree(planned, { allowDirtyReuse: true });
+        ensuredLaunchWorktree = ensured;
+        if (ensured.enabled) {
+            cwd = ensured.worktreePath;
+            if (ensured.dirty) {
+                worktreeDirty = true;
+                process.stderr.write(`[omx] Caution: worktree at ${cwd} has uncommitted changes.\n` +
+                    `  The session will launch as-is. Resolve the dirty state with OMX after launch, then proceed with your task.\n`);
+            }
+            const depBootstrap = ensureReusableNodeModules(cwd);
+            if (depBootstrap.strategy === "symlink") {
+                console.log(`[omx] Reusing node_modules from ${depBootstrap.sourceNodeModulesPath}`);
+            }
+            else if (depBootstrap.strategy === "missing" && depBootstrap.warning) {
+                console.warn(`[omx] ${depBootstrap.warning}`);
+            }
+        }
+    }
+    applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
+    const sessionId = `omx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await maybeCheckAndPromptUpdate(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    try {
+        await maybePromptGithubStar();
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    try {
+        const configPath = resolveCodexConfigPathForLaunch(launchCwd, process.env);
+        const repaired = await repairConfigIfNeeded(configPath, getPackageRoot(), await resolveLaunchConfigRepairOptions(launchCwd, configPath));
+        if (repaired) {
+            console.log("[omx] Repaired managed config.toml compatibility issue.");
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env);
+    const codexHomeOverride = preparedCodexHome.codexHomeOverride;
+    const sqliteHomeOverride = preparedCodexHome.sqliteHomeOverride;
+    const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
+    try {
+        await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, true, worktreeDirty);
+    }
+    catch (err) {
+        console.error(`[omx] preLaunch warning: ${err instanceof Error ? err.message : err}`);
+    }
+    try {
+        const notifyTempContractRaw = notifyTempResult.contract.active
+            ? serializeNotifyTempContract(notifyTempResult.contract)
+            : null;
+        const codexArgs = injectModelInstructionsBypassArgs(cwd, ["exec", ...normalizedArgs], process.env, sessionModelInstructionsPath(cwd, sessionId));
+        const omxRootOverride = resolveOmxRootForLaunch(cwd, process.env);
+        const codexEnvBase = {
+            ...process.env,
+            ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
+            ...(sqliteHomeOverride ? { [CODEX_SQLITE_HOME_ENV]: sqliteHomeOverride } : {}),
+            ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+        };
+        const codexEnv = notifyTempContractRaw
+            ? {
+                ...codexEnvBase,
+                [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw,
+            }
+            : codexEnvBase;
+        runCodexBlocking(cwd, codexArgs, codexEnv);
+    }
+    finally {
+        await postLaunch(cwd, sessionId, codexHomeOverride, true, projectLocalCodexHomeForCleanup);
+        await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch(logCliOperationFailure);
+    }
+}
+export function normalizeCodexLaunchArgs(args) {
+    const parsed = parseWorktreeMode(args);
+    const launchPolicyParsed = splitLeaderLaunchPolicyArgs(parsed.remainingArgs);
+    const normalized = [];
+    let wantsBypass = false;
+    let hasBypass = false;
+    let reasoningMode = null;
+    for (const arg of launchPolicyParsed.remainingArgs) {
+        if (arg === MADMAX_FLAG) {
+            wantsBypass = true;
+            continue;
+        }
+        if (arg === CODEX_BYPASS_FLAG) {
+            wantsBypass = true;
+            if (!hasBypass) {
+                normalized.push(arg);
+                hasBypass = true;
+            }
+            continue;
+        }
+        if (arg === HIGH_REASONING_FLAG) {
+            reasoningMode = "high";
+            continue;
+        }
+        if (arg === XHIGH_REASONING_FLAG) {
+            reasoningMode = "xhigh";
+            continue;
+        }
+        if (arg === SPARK_FLAG) {
+            // Spark model is injected into worker env only (not the leader). Consume flag.
+            continue;
+        }
+        if (arg === MADMAX_SPARK_FLAG) {
+            // Bypass applies to leader; spark model goes to workers only. Consume flag.
+            wantsBypass = true;
+            continue;
+        }
+        normalized.push(arg);
+    }
+    if (wantsBypass && !hasBypass) {
+        normalized.push(CODEX_BYPASS_FLAG);
+    }
+    if (reasoningMode) {
+        normalized.push(CONFIG_FLAG, `${REASONING_KEY}="${reasoningMode}"`);
+    }
+    return normalized;
+}
+/**
+ * Returns the spark model string if --spark or --madmax-spark appears in the
+ * raw (pre-normalize) args, or undefined if neither flag is present.
+ * Used to route the spark model to team workers without affecting the leader.
+ */
+export function resolveWorkerSparkModel(args, codexHomeOverride) {
+    for (const arg of args) {
+        if (arg === SPARK_FLAG || arg === MADMAX_SPARK_FLAG) {
+            return resolveTeamLowComplexityDefaultModel(codexHomeOverride);
+        }
+    }
+    return undefined;
+}
+function isModelInstructionsOverride(value) {
+    return new RegExp(`^${MODEL_INSTRUCTIONS_FILE_KEY}\\s*=`).test(value.trim());
+}
+function hasModelInstructionsOverride(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === CONFIG_FLAG || arg === LONG_CONFIG_FLAG) {
+            const maybeValue = args[i + 1];
+            if (typeof maybeValue === "string" &&
+                isModelInstructionsOverride(maybeValue)) {
+                return true;
+            }
+            continue;
+        }
+        if (arg.startsWith(`${LONG_CONFIG_FLAG}=`)) {
+            const inlineValue = arg.slice(`${LONG_CONFIG_FLAG}=`.length);
+            if (isModelInstructionsOverride(inlineValue))
+                return true;
+        }
+    }
+    return false;
+}
+function shouldBypassDefaultSystemPrompt(env) {
+    return env[OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV] !== "0";
+}
+function buildModelInstructionsOverride(cwd, env, defaultFilePath) {
+    const filePath = env[OMX_MODEL_INSTRUCTIONS_FILE_ENV] ||
+        defaultFilePath ||
+        join(cwd, "AGENTS.md");
+    return `${MODEL_INSTRUCTIONS_FILE_KEY}="${escapeTomlString(filePath)}"`;
+}
+function tryReadGitValue(cwd, args) {
+    try {
+        const value = execFileSync("git", args, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }).trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractIssueNumber(text) {
+    const explicit = text.match(/\bissue\s*#(\d+)\b/i);
+    if (explicit)
+        return Number.parseInt(explicit[1], 10);
+    const generic = text.match(/(^|[^\w/])#(\d+)\b/);
+    return generic ? Number.parseInt(generic[2], 10) : undefined;
+}
+export function resolveNativeSessionName(cwd, sessionId, env = process.env) {
+    if (env.TMUX) {
+        try {
+            const tmuxPaneTarget = env.TMUX_PANE?.trim();
+            const displayArgs = tmuxPaneTarget
+                ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+                : ["display-message", "-p", "#S"];
+            const tmuxSession = execTmuxFileSync(displayArgs, {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 2000,
+            }).trim();
+            if (tmuxSession)
+                return tmuxSession;
+        }
+        catch {
+            // best effort only
+        }
+    }
+    return buildTmuxSessionName(cwd, sessionId);
+}
+function tagTmuxSessionWithInstance(sessionName, sessionId) {
+    const target = sessionName.trim();
+    const instanceId = sessionId.trim();
+    if (!target || !instanceId)
+        return;
+    execFileSync("tmux", ["set-option", "-t", target, OMX_INSTANCE_OPTION, instanceId], {
+        stdio: ["ignore", "ignore", "ignore"],
+        timeout: 2000,
+    });
+}
+function tagCurrentTmuxSessionWithInstance(sessionId) {
+    if (!process.env.TMUX)
+        return;
+    try {
+        const tmuxPaneTarget = process.env.TMUX_PANE;
+        const displayArgs = tmuxPaneTarget
+            ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+            : ["display-message", "-p", "#S"];
+        const sessionName = execFileSync("tmux", displayArgs, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }).trim();
+        if (sessionName)
+            tagTmuxSessionWithInstance(sessionName, sessionId);
+    }
+    catch {
+        // Best effort only: launch should not fail just because tmux tagging failed.
+    }
+}
+function buildNativeHookBaseContext(cwd, sessionId, normalizedEvent, extra = {}) {
+    const repoPath = tryReadGitValue(cwd, ["rev-parse", "--show-toplevel"]) || cwd;
+    const branch = tryReadGitValue(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const issueNumber = extractIssueNumber([branch, basename(cwd)].filter(Boolean).join(" "));
+    return {
+        normalized_event: normalizedEvent,
+        session_name: resolveNativeSessionName(cwd, sessionId),
+        repo_path: repoPath,
+        repo_name: basename(repoPath),
+        worktree_path: cwd,
+        ...(branch ? { branch } : {}),
+        ...(issueNumber !== undefined ? { issue_number: issueNumber } : {}),
+        ...extra,
+    };
+}
+export function injectModelInstructionsBypassArgs(cwd, args, env = process.env, defaultFilePath) {
+    if (!shouldBypassDefaultSystemPrompt(env))
+        return [...args];
+    if (hasModelInstructionsOverride(args))
+        return [...args];
+    return [
+        ...args,
+        CONFIG_FLAG,
+        buildModelInstructionsOverride(cwd, env, defaultFilePath),
+    ];
+}
+export function collectInheritableTeamWorkerArgs(codexArgs) {
+    return collectInheritableTeamWorkerArgsShared(codexArgs);
+}
+export function resolveTeamWorkerLaunchArgsEnv(existingRaw, codexArgs, inheritLeaderFlags = true, defaultModel) {
+    const inheritedArgs = inheritLeaderFlags
+        ? collectInheritableTeamWorkerArgs(codexArgs)
+        : [];
+    const normalized = resolveTeamWorkerLaunchArgs({
+        existingRaw,
+        inheritedArgs,
+        fallbackModel: defaultModel,
+    });
+    if (normalized.length === 0)
+        return null;
+    return normalized.join(" ");
+}
+export { readTopLevelTomlString, upsertTopLevelTomlString } from "../utils/toml.js";
+function sanitizeTmuxToken(value) {
+    const cleaned = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return cleaned || "unknown";
+}
+export function buildTmuxSessionName(cwd, sessionId) {
+    const parentPath = dirname(cwd);
+    const parentDir = basename(parentPath);
+    const dirName = basename(cwd);
+    const grandparentPath = dirname(parentPath);
+    const grandparentDir = basename(grandparentPath);
+    const repoDir = parentDir.endsWith(".omx-worktrees")
+        ? parentDir.slice(0, -".omx-worktrees".length)
+        : parentDir === "worktrees" && grandparentDir === ".omx"
+            ? basename(dirname(grandparentPath))
+            : null;
+    const dirToken = repoDir
+        ? sanitizeTmuxToken(`${repoDir}-${dirName}`)
+        : sanitizeTmuxToken(dirName);
+    let branchToken = "detached";
+    const branch = tryReadGitValue(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (branch)
+        branchToken = sanitizeTmuxToken(branch);
+    const sessionToken = sanitizeTmuxToken(sessionId.replace(/^omx-/, ""));
+    const prefix = `omx-${dirToken}-${branchToken}`;
+    const name = `${prefix}-${sessionToken}`;
+    if (name.length <= 120)
+        return name;
+    const prefixBudget = Math.max(4, 120 - sessionToken.length - 1);
+    const trimmedPrefix = prefix.slice(0, prefixBudget).replace(/-+$/g, "");
+    return `${trimmedPrefix}-${sessionToken}`.slice(0, 120);
+}
+export function buildDetachedTmuxSessionName(cwd, sessionId) {
+    return buildTmuxSessionName(cwd, sessionId);
+}
+function parseWindowIndexFromTmuxOutput(rawOutput) {
+    const windowIndex = rawOutput.split("\n")[0]?.trim() || "";
+    return /^[0-9]+$/.test(windowIndex) ? windowIndex : null;
+}
+export function detectDetachedSessionWindowIndex(sessionName) {
+    try {
+        const output = execTmuxFileSync(["display-message", "-p", "-t", sessionName, "#{window_index}"], { encoding: "utf-8" });
+        return parseWindowIndexFromTmuxOutput(output);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        return null;
+    }
+}
+function escapeShellDoubleQuotedValue(value) {
+    return value.replace(/["\\$`]/g, "\\$&");
+}
+function sanitizeTmuxLeaseKey(value) {
+    const cleaned = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return cleaned || "default";
+}
+function blockMs(ms) {
+    const delay = Math.max(1, Math.floor(ms));
+    const shared = new SharedArrayBuffer(4);
+    const view = new Int32Array(shared);
+    Atomics.wait(view, 0, 0, delay);
+}
+function tmuxExtendedKeysLeaseRoot(cwd) {
+    return join(omxRoot(cwd), "state", TMUX_EXTENDED_KEYS_LEASE_DIR);
+}
+function resolveTmuxSocketPath(execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+})) {
+    return (execTmuxSync(["display-message", "-p", "#{socket_path}"], execFileSyncImpl) ||
+        "default");
+}
+function tmuxExtendedKeysLeasePath(cwd, socketPath) {
+    return join(tmuxExtendedKeysLeaseRoot(cwd), `${sanitizeTmuxLeaseKey(socketPath)}.json`);
+}
+function isTmuxExtendedKeysLeaseHolderRecord(holder) {
+    if (!holder || typeof holder !== "object")
+        return false;
+    const record = holder;
+    if (typeof record.id !== "string" || !record.id.trim())
+        return false;
+    if (!Number.isSafeInteger(record.pid) || Number(record.pid) <= 0)
+        return false;
+    if (record.platform !== undefined && typeof record.platform !== "string")
+        return false;
+    if (record.linuxStartTicks !== undefined &&
+        !Number.isSafeInteger(record.linuxStartTicks))
+        return false;
+    return true;
+}
+function isTmuxExtendedKeysLeaseHolder(holder) {
+    return typeof holder === "string" || isTmuxExtendedKeysLeaseHolderRecord(holder);
+}
+function readTmuxExtendedKeysLeaseState(leasePath) {
+    if (!existsSync(leasePath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(leasePath, "utf-8"));
+        if (typeof parsed.originalMode !== "string" ||
+            !Array.isArray(parsed.holders) ||
+            !parsed.holders.every(isTmuxExtendedKeysLeaseHolder)) {
+            return null;
+        }
+        return {
+            originalMode: parsed.originalMode,
+            holders: [...parsed.holders],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writeTmuxExtendedKeysLeaseState(leasePath, state) {
+    mkdirSync(dirname(leasePath), { recursive: true });
+    writeFileSync(leasePath, JSON.stringify(state, null, 2));
+}
+function parseTmuxExtendedKeysLeaseHolderPid(holder) {
+    const match = /^([1-9]\d*)-/.exec(holder);
+    if (!match)
+        return null;
+    const pid = Number.parseInt(match[1], 10);
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function getTmuxExtendedKeysLeaseHolderId(holder) {
+    return typeof holder === "string" ? holder : holder.id;
+}
+function getTmuxExtendedKeysLeaseHolderPid(holder) {
+    if (typeof holder === "string")
+        return parseTmuxExtendedKeysLeaseHolderPid(holder);
+    return Number.isSafeInteger(holder.pid) && holder.pid > 0 ? holder.pid : null;
+}
+function parseLinuxProcStartTicks(statContent) {
+    const commandEnd = statContent.lastIndexOf(")");
+    if (commandEnd === -1)
+        return null;
+    const remainder = statContent.slice(commandEnd + 1).trim();
+    const fields = remainder.split(/\s+/);
+    if (fields.length <= 19)
+        return null;
+    const startTicks = Number(fields[19]);
+    return Number.isSafeInteger(startTicks) ? startTicks : null;
+}
+function readLinuxProcessStartTicks(pid) {
+    try {
+        return parseLinuxProcStartTicks(readFileSync(`/proc/${pid}/stat`, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function createTmuxExtendedKeysLeaseHolder(id, pid) {
+    const linuxStartTicks = process.platform === "linux"
+        ? readLinuxProcessStartTicks(pid) ?? undefined
+        : undefined;
+    return {
+        id,
+        pid,
+        platform: process.platform,
+        ...(linuxStartTicks !== undefined ? { linuxStartTicks } : {}),
+    };
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : "";
+        return code === "EPERM";
+    }
+}
+function isTmuxExtendedKeysLeaseHolderAlive(holder) {
+    const pid = getTmuxExtendedKeysLeaseHolderPid(holder);
+    if (pid === null || !isProcessAlive(pid))
+        return false;
+    if (typeof holder === "string")
+        return true;
+    if (holder.platform !== "linux" || process.platform !== "linux")
+        return true;
+    if (holder.linuxStartTicks === undefined)
+        return true;
+    return readLinuxProcessStartTicks(pid) === holder.linuxStartTicks;
+}
+function reapDeadTmuxExtendedKeysLeaseHolders(state) {
+    return {
+        originalMode: state.originalMode,
+        holders: state.holders.filter(isTmuxExtendedKeysLeaseHolderAlive),
+    };
+}
+function withTmuxExtendedKeysLeaseLock(cwd, socketPath, run) {
+    const leaseRoot = tmuxExtendedKeysLeaseRoot(cwd);
+    mkdirSync(leaseRoot, { recursive: true });
+    const lockPath = join(leaseRoot, `${sanitizeTmuxLeaseKey(socketPath)}.lock`);
+    for (let attempt = 0; attempt < TMUX_EXTENDED_KEYS_LOCK_MAX_ATTEMPTS; attempt++) {
+        try {
+            mkdirSync(lockPath);
+            try {
+                writeFileSync(join(lockPath, "pid"), String(process.pid));
+                return run();
+            }
+            finally {
+                rmSync(lockPath, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            const code = err && typeof err === "object" && "code" in err
+                ? String(err.code)
+                : "";
+            if (code !== "EEXIST")
+                throw err;
+            const lockStat = statSync(lockPath, { throwIfNoEntry: false });
+            if (lockStat && Date.now() - lockStat.mtimeMs > TMUX_EXTENDED_KEYS_LOCK_STALE_MS) {
+                let holderAlive = false;
+                try {
+                    const holderPid = Number.parseInt(readFileSync(join(lockPath, "pid"), "utf-8").trim(), 10);
+                    if (Number.isFinite(holderPid) && holderPid > 0) {
+                        process.kill(holderPid, 0);
+                        holderAlive = true;
+                    }
+                }
+                catch {
+                    // PID file missing/unreadable or process dead (ESRCH) — treat as stale
+                }
+                if (!holderAlive) {
+                    rmSync(lockPath, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            blockMs(TMUX_EXTENDED_KEYS_LOCK_RETRY_MS);
+        }
+    }
+    throw new Error(`timed out waiting for tmux extended-keys lease lock: ${lockPath}`);
+}
+function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnvFilePath) {
+    const detachedPostLaunchHelper = sessionId
+        ? `${buildDetachedSessionPostLaunchHelperCommand(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup)} >/dev/null 2>&1 || true;`
+        : "";
+    const parentEnvSource = parentEnvFilePath && parentEnvFilePath.trim()
+        ? `if [ -r ${quoteShellArg(parentEnvFilePath)} ]; then . ${quoteShellArg(parentEnvFilePath)}; rm -f ${quoteShellArg(parentEnvFilePath)}; fi;`
+        : "";
+    const parentEnvCleanup = parentEnvFilePath && parentEnvFilePath.trim()
+        ? `rm -f ${quoteShellArg(parentEnvFilePath)} 2>/dev/null || true;`
+        : "";
+    const wrapped = [
+        buildTmuxExtendedKeysAcquireShellSnippet(cwd),
+        'exec 3<&0;',
+        'omx_codex_pid="";',
+        "omx_detached_session_cleanup() {",
+        "status=$?;",
+        "trap - 0 INT TERM HUP;",
+        'if [ -n "$omx_codex_pid" ] && kill -0 "$omx_codex_pid" 2>/dev/null; then',
+        'kill -TERM "$omx_codex_pid" 2>/dev/null || true;',
+        'wait "$omx_codex_pid" 2>/dev/null || true;',
+        "fi;",
+        'exec 3<&- 2>/dev/null || true;',
+        buildTmuxExtendedKeysReleaseShellSnippet(cwd),
+        parentEnvCleanup,
+        detachedPostLaunchHelper,
+        'if [ "$status" -eq 0 ]; then',
+        `tmux kill-session -t "${escapeShellDoubleQuotedValue(sessionName)}" >/dev/null 2>&1 || true;`,
+        "fi;",
+        "exit $status;",
+        "};",
+        "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=$!;",
+        'wait "$omx_codex_pid";',
+        "omx_codex_status=$?;",
+        "omx_codex_finished_at=$(date +%s 2>/dev/null || printf 0);",
+        'omx_codex_elapsed=$((omx_codex_finished_at - omx_codex_started_at));',
+        'if [ "$omx_codex_status" -eq 0 ] && [ "$omx_codex_elapsed" -le 2 ]; then',
+        'printf "\\n[omx] codex exited immediately with code 0 during startup. The detached tmux session is being kept open so any output above remains visible. Press Enter to close this OMX session.\\n" >&2;',
+        'IFS= read -r _omx_close || true;',
+        'elif [ "$omx_codex_status" -gt 0 ] && [ "$omx_codex_status" -lt 128 ] && [ "$omx_codex_elapsed" -le 2 ]; then',
+        'printf "\\n[omx] codex exited with code %s during startup. The detached tmux session is being kept open so the error above remains visible. Press Enter to close this OMX session.\\n" "$omx_codex_status" >&2;',
+        'IFS= read -r _omx_close || true;',
+        'elif [ "$omx_codex_status" -gt 0 ] && [ "$omx_codex_status" -lt 128 ]; then',
+        'printf "\\n[omx] codex exited with code %s. The detached tmux session is being kept open so the error above remains visible. Press Enter to close this OMX session.\\n" "$omx_codex_status" >&2;',
+        'IFS= read -r _omx_close || true;',
+        "fi;",
+        'exit "$omx_codex_status";',
+    ].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 } : {}),
+})) {
+    return execFileSyncImpl(resolveTmuxExecutableForLaunch(), [...args]).trim();
+}
+export function acquireTmuxExtendedKeysLease(cwd, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+}), ownerPid = process.pid) {
+    try {
+        const socketPath = resolveTmuxSocketPath(execFileSyncImpl);
+        const leasePath = tmuxExtendedKeysLeasePath(cwd, socketPath);
+        const holderPid = Number.isSafeInteger(ownerPid) && ownerPid > 0 ? ownerPid : process.pid;
+        const leaseId = `${holderPid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        withTmuxExtendedKeysLeaseLock(cwd, socketPath, () => {
+            const stateRaw = readTmuxExtendedKeysLeaseState(leasePath);
+            const state = stateRaw ? reapDeadTmuxExtendedKeysLeaseHolders(stateRaw) : null;
+            if (stateRaw && state?.holders.length === 0) {
+                execTmuxSync(["set-option", "-sq", "extended-keys", state.originalMode], execFileSyncImpl);
+                rmSync(leasePath, { force: true });
+            }
+            if (!state || state.holders.length === 0) {
+                const previousMode = execTmuxSync(["show-options", "-sv", "extended-keys"], execFileSyncImpl) ||
+                    TMUX_EXTENDED_KEYS_FALLBACK_MODE;
+                execTmuxSync(["set-option", "-sq", "extended-keys", TMUX_EXTENDED_KEYS_MODE], execFileSyncImpl);
+                writeTmuxExtendedKeysLeaseState(leasePath, {
+                    originalMode: previousMode,
+                    holders: [createTmuxExtendedKeysLeaseHolder(leaseId, holderPid)],
+                });
+                return;
+            }
+            state.holders.push(createTmuxExtendedKeysLeaseHolder(leaseId, holderPid));
+            writeTmuxExtendedKeysLeaseState(leasePath, state);
+        });
+        return `${socketPath}\t${leaseId}`;
+    }
+    catch (err) {
+        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
+            logCliOperationFailure(err);
+        }
+        return null;
+    }
+}
+export function releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+})) {
+    if (!leaseHandle.trim())
+        return;
+    const [socketPathRaw = "", leaseId = ""] = leaseHandle.split("\t");
+    const socketPath = socketPathRaw.trim() || "default";
+    if (!leaseId)
+        return;
+    try {
+        const leasePath = tmuxExtendedKeysLeasePath(cwd, socketPath);
+        withTmuxExtendedKeysLeaseLock(cwd, socketPath, () => {
+            const stateRaw = readTmuxExtendedKeysLeaseState(leasePath);
+            const state = stateRaw ? reapDeadTmuxExtendedKeysLeaseHolders(stateRaw) : null;
+            if (!state || state.holders.length === 0) {
+                if (stateRaw) {
+                    execTmuxSync(["set-option", "-sq", "extended-keys", stateRaw.originalMode], execFileSyncImpl);
+                }
+                rmSync(leasePath, { force: true });
+                return;
+            }
+            const holders = state.holders.filter((holder) => getTmuxExtendedKeysLeaseHolderId(holder) !== leaseId);
+            if (holders.length > 0) {
+                writeTmuxExtendedKeysLeaseState(leasePath, {
+                    originalMode: state.originalMode,
+                    holders,
+                });
+                return;
+            }
+            execTmuxSync(["set-option", "-sq", "extended-keys", state.originalMode], execFileSyncImpl);
+            rmSync(leasePath, { force: true });
+        });
+    }
+    catch (err) {
+        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
+            logCliOperationFailure(err);
+        }
+    }
+}
+function buildTmuxExtendedKeysHelperCommand(cwd, operation) {
+    const cwdLiteral = JSON.stringify(cwd);
+    const moduleUrlLiteral = JSON.stringify(import.meta.url);
+    const script = operation === "acquire"
+        ? `const mod = await import(${moduleUrlLiteral}); const ownerPid = Number.parseInt(process.argv[1] ?? "", 10); const lease = mod.acquireTmuxExtendedKeysLease(${cwdLiteral}, undefined, Number.isSafeInteger(ownerPid) && ownerPid > 0 ? ownerPid : undefined); if (lease) process.stdout.write(lease);`
+        : `const mod = await import(${moduleUrlLiteral}); mod.releaseTmuxExtendedKeysLease(${cwdLiteral}, process.argv[1] ?? "");`;
+    return `${quoteShellArg(process.execPath)} --input-type=module -e ${quoteShellArg(script)}`;
+}
+function buildTmuxExtendedKeysAcquireShellSnippet(cwd) {
+    return `OMX_TMUX_EXTENDED_KEYS_LEASE=$(${buildTmuxExtendedKeysHelperCommand(cwd, "acquire")} "$$" 2>/dev/null || true);`;
+}
+function buildTmuxExtendedKeysReleaseShellSnippet(cwd) {
+    return `if [ -n "\${OMX_TMUX_EXTENDED_KEYS_LEASE:-}" ]; then ${buildTmuxExtendedKeysHelperCommand(cwd, "release")} "\${OMX_TMUX_EXTENDED_KEYS_LEASE}" >/dev/null 2>&1 || true; fi;`;
+}
+const SHELL_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export function serializeDetachedSessionParentEnv(env) {
+    const lines = [];
+    for (const key of Object.keys(env).sort()) {
+        if (!SHELL_ENV_NAME_PATTERN.test(key))
+            continue;
+        const value = env[key];
+        if (typeof value !== "string")
+            continue;
+        if (value.includes("\0"))
+            continue;
+        lines.push(`export ${key}=${quoteShellArg(value)}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function detachedSessionParentEnvFilePath(cwd, sessionId) {
+    const safeSessionId = sessionId.replace(/[^A-Za-z0-9_.-]/g, "_");
+    return join(omxRoot(cwd), "runtime", "tmux-env", `${safeSessionId}.env`);
+}
+export function writeDetachedSessionParentEnvFile(cwd, sessionId, env) {
+    const filePath = detachedSessionParentEnvFilePath(cwd, sessionId);
+    mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+    writeFileSync(filePath, serializeDetachedSessionParentEnv(env), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    return filePath;
+}
+export function withTmuxExtendedKeys(cwd, run, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+})) {
+    const leaseHandle = acquireTmuxExtendedKeysLease(cwd, execFileSyncImpl);
+    try {
+        return run();
+    }
+    finally {
+        if (leaseHandle)
+            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) {
+    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",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-s",
+        sessionName,
+        "-c",
+        cwd,
+        ...(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}`] : []),
+        ...(notifyTempContractRaw
+            ? ["-e", `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`]
+            : []),
+        detachedLeaderCmd,
+    ];
+    const splitCaptureArgs = [
+        "split-window",
+        "-v",
+        "-l",
+        String(HUD_TMUX_HEIGHT_LINES),
+        "-d",
+        "-t",
+        sessionName,
+        "-c",
+        cwd,
+        "-P",
+        "-F",
+        "#{pane_id}",
+        hudCmd,
+    ];
+    return [
+        { name: "new-session", args: newSessionArgs },
+        ...(sessionId
+            ? [
+                {
+                    name: "tag-session",
+                    args: ["set-option", "-t", sessionName, OMX_INSTANCE_OPTION, sessionId],
+                },
+            ]
+            : []),
+        { name: "split-and-capture-hud-pane", args: splitCaptureArgs },
+    ];
+}
+async function readLaunchAppendInstructions() {
+    const appendixCandidates = [
+        process.env[OMX_RALPH_APPEND_INSTRUCTIONS_FILE_ENV]?.trim(),
+        process.env[OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV]?.trim(),
+    ].filter((value) => typeof value === "string" && value.length > 0);
+    if (appendixCandidates.length === 0)
+        return "";
+    const appendixPath = appendixCandidates[0];
+    if (!existsSync(appendixPath)) {
+        throw new Error(`launch instructions file not found: ${appendixPath}`);
+    }
+    const { readFile } = await import("fs/promises");
+    return (await readFile(appendixPath, "utf-8")).trim();
+}
+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);
+        const clientAttachedHookName = buildClientAttachedReconcileHookName("launch", sessionName, hookWindowIndex, hudPaneId);
+        steps.push({
+            name: "register-resize-hook",
+            args: buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId, HUD_TMUX_HEIGHT_LINES),
+        });
+        steps.push({
+            name: "register-client-attached-reconcile",
+            args: buildRegisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName, hudPaneId, HUD_TMUX_HEIGHT_LINES),
+        });
+        steps.push({
+            name: "schedule-delayed-resize",
+            args: buildScheduleDelayedHudResizeArgs(hudPaneId, undefined, HUD_TMUX_HEIGHT_LINES),
+        });
+        steps.push({
+            name: "reconcile-hud-resize",
+            args: buildReconcileHudResizeArgs(hudPaneId, HUD_TMUX_HEIGHT_LINES),
+        });
+    }
+    if (enableMouse) {
+        steps.push({
+            name: "set-mouse",
+            args: ["set-option", "-t", sessionName, "mouse", "on"],
+        });
+        steps.push({
+            name: "sanitize-copy-mode-style",
+            args: [],
+        });
+    }
+    if (attachSession) {
+        steps.push({
+            name: "attach-session",
+            args: ["attach-session", "-t", sessionName],
+        });
+    }
+    return steps;
+}
+export function buildDetachedSessionRollbackSteps(sessionName, hookTarget, hookName, clientAttachedHookName) {
+    const steps = [];
+    if (hookTarget && clientAttachedHookName) {
+        steps.push({
+            name: "unregister-client-attached-reconcile",
+            args: buildUnregisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName),
+        });
+    }
+    if (hookTarget && hookName) {
+        steps.push({
+            name: "unregister-resize-hook",
+            args: buildUnregisterResizeHookArgs(hookTarget, hookName),
+        });
+    }
+    steps.push({
+        name: "kill-session",
+        args: ["kill-session", "-t", sessionName],
+    });
+    return steps;
+}
+export function buildNotifyTempStartupMessages(contract, hasValidProviders) {
+    const providers = contract.canonicalSelectors.length > 0
+        ? contract.canonicalSelectors.join(",")
+        : "none";
+    const infoLines = [
+        `notify temp: active | providers=${providers} | persistent-routing=bypassed`,
+    ];
+    const warningLines = [...contract.warnings];
+    if (!hasValidProviders) {
+        warningLines.push("notify temp: no valid providers resolved; notifications skipped");
+    }
+    return { infoLines, warningLines };
+}
+export function buildNotifyFallbackWatcherEnv(env = process.env, options = {}) {
+    const nextEnv = { ...env };
+    delete nextEnv.TMUX;
+    delete nextEnv.TMUX_PANE;
+    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",
+    };
+}
+export function shouldEnableNotifyFallbackWatcher(env = process.env, platform = process.platform) {
+    const toggle = String(env.OMX_NOTIFY_FALLBACK ?? "").trim();
+    if (platform === "win32") {
+        return toggle === "1";
+    }
+    return toggle !== "0";
+}
+export async function cleanupLaunchOrphanedMcpProcesses(dependencies = {}) {
+    return cleanupOmxMcpProcesses([], {
+        ...dependencies,
+        selectCandidates: dependencies.selectCandidates ?? findLaunchSafeCleanupCandidates,
+        writeLine: dependencies.writeLine ?? (() => { }),
+    });
+}
+const POST_LAUNCH_MODE_STATE_RETRY_DELAY_MS = 10;
+const POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS = 2;
+function isLikelyTransientModeStateParseFailure(raw, err) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return true;
+    if (!(err instanceof SyntaxError))
+        return false;
+    if (!trimmed.startsWith("{") || trimmed.endsWith("}"))
+        return false;
+    return (/Unexpected end of JSON input/.test(err.message) ||
+        /Unterminated string in JSON/.test(err.message) ||
+        /Expected double-quoted property name in JSON/.test(err.message) ||
+        /Expected property name or '}' in JSON/.test(err.message) ||
+        /Expected ':' after property name in JSON/.test(err.message) ||
+        /Expected ',' or '}' after property value in JSON/.test(err.message));
+}
+async function readPostLaunchModeStateFile(path, dependencies = {}) {
+    const readFile = dependencies.readFile ?? (await import("fs/promises")).readFile;
+    const sleep = dependencies.sleep
+        ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    for (let attempt = 1; attempt <= POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS; attempt += 1) {
+        try {
+            const raw = await readFile(path, "utf-8");
+            const trimmed = raw.trim();
+            if (trimmed.length === 0) {
+                if (attempt < POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS) {
+                    await sleep(POST_LAUNCH_MODE_STATE_RETRY_DELAY_MS);
+                    continue;
+                }
+                return { kind: "recoverable" };
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (err) {
+                if (isLikelyTransientModeStateParseFailure(raw, err)) {
+                    if (attempt < POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS) {
+                        await sleep(POST_LAUNCH_MODE_STATE_RETRY_DELAY_MS);
+                        continue;
+                    }
+                    return { kind: "recoverable" };
+                }
+                return {
+                    kind: "malformed",
+                    message: err instanceof Error ? err.message : String(err),
+                };
+            }
+            if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+                return { kind: "malformed", message: "mode state must be a JSON object" };
+            }
+            return { kind: "ok", state: parsed };
+        }
+        catch (err) {
+            const error = err;
+            if (error?.code === "ENOENT")
+                return { kind: "missing" };
+            return {
+                kind: "malformed",
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    return { kind: "recoverable" };
+}
+function cleanPostLaunchString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function isAutopilotReviewPendingPostLaunchState(state) {
+    if (!state || state.active !== true)
+        return false;
+    const mode = cleanPostLaunchString(state.mode).toLowerCase();
+    if (mode && mode !== "autopilot")
+        return false;
+    const phase = cleanPostLaunchString(state.current_phase ?? state.currentPhase)
+        .toLowerCase()
+        .replace(/_/g, "-");
+    if (phase === "code-review" || phase === "review" || phase === "reviewing" || phase === "review-pending") {
+        return true;
+    }
+    const nestedState = state.state && typeof state.state === "object"
+        ? state.state
+        : {};
+    return state.review_pending === true
+        || state.reviewPending === true
+        || nestedState.review_pending === true
+        || nestedState.reviewPending === true;
+}
+function postLaunchUniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+async function scrubPostLaunchRootSkillActiveForSession(stateDir, sessionId, nowIso, writeFileFn, rootStateBeforeCleanup) {
+    const normalizedSessionId = cleanPostLaunchString(sessionId);
+    if (!normalizedSessionId)
+        return;
+    const { rootPath } = getSkillActiveStatePathsForStateDir(stateDir);
+    const rootState = rootStateBeforeCleanup ?? await readSkillActiveState(rootPath);
+    if (!rootState)
+        return;
+    const rootSessionIds = postLaunchUniqueStrings([
+        cleanPostLaunchString(rootState.session_id),
+        cleanPostLaunchString(extractSessionIdFromInitializedStatePath(rootState.initialized_state_path)),
+    ]);
+    const rootBelongsToSession = rootSessionIds.includes(normalizedSessionId);
+    const entries = listActiveSkills(rootState);
+    const keptEntries = entries.filter((entry) => {
+        const entrySessionId = cleanPostLaunchString(entry.session_id);
+        if (entrySessionId)
+            return entrySessionId !== normalizedSessionId;
+        return !rootBelongsToSession;
+    });
+    if (keptEntries.length === entries.length && rootState.active !== true)
+        return;
+    if (keptEntries.length === entries.length && !rootBelongsToSession)
+        return;
+    const nextRoot = {
+        ...rootState,
+        active: keptEntries.length > 0,
+        skill: keptEntries[0]?.skill ?? (keptEntries.length > 0 ? cleanPostLaunchString(rootState.skill) : ""),
+        phase: keptEntries[0]?.phase ?? (keptEntries.length > 0 ? cleanPostLaunchString(rootState.phase) : "complete"),
+        updated_at: nowIso,
+        active_skills: keptEntries,
+        post_launch_reconciled_at: nowIso,
+        post_launch_reconciliation_reason: "terminal_session_cleanup",
+    };
+    await writeFileFn(rootPath, JSON.stringify(nextRoot, null, 2));
+}
+function buildRecoveredPostLaunchModeState(mode, completedAt) {
+    return {
+        active: false,
+        mode,
+        current_phase: "cancelled",
+        completed_at: completedAt,
+        last_turn_at: completedAt,
+    };
+}
+function buildRecoveredPostLaunchSkillActiveState(completedAt) {
+    return {
+        version: 1,
+        active: false,
+        skill: "",
+        phase: "complete",
+        updated_at: completedAt,
+        active_skills: [],
+    };
+}
+function markRalphCompletionAuditBlockedForPostLaunch(state, cwd, nowIso) {
+    if (!isRalphCompletePhase(state.current_phase ?? state.currentPhase))
+        return false;
+    const audit = evaluateRalphCompletionAuditEvidence(state, cwd);
+    if (audit.complete)
+        return false;
+    state.active = false;
+    state.current_phase = "cancelled";
+    state.completed_at = nowIso;
+    state.last_turn_at = nowIso;
+    state.interrupted_at = nowIso;
+    state.stop_reason = `missing_completion_audit:${audit.reason}`;
+    state.completion_audit_gate = "blocked";
+    state.completion_audit_missing_reason = audit.reason;
+    state.completion_audit_blocked_at = nowIso;
+    return true;
+}
+export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependencies = {}) {
+    const readdir = dependencies.readdir ?? (await import("fs/promises")).readdir;
+    const writeFile = dependencies.writeFile ?? (await import("fs/promises")).writeFile;
+    const writeWarn = dependencies.writeWarn ?? console.warn;
+    const now = dependencies.now ?? (() => new Date());
+    const scopedDirs = sessionId
+        ? [getStateDir(cwd, sessionId)]
+        : [getBaseStateDir(cwd)];
+    const rootStateDir = getBaseStateDir(cwd);
+    const rootSkillActiveStateBeforeCleanup = sessionId
+        ? await readSkillActiveState(getSkillActiveStatePathsForStateDir(rootStateDir).rootPath)
+        : null;
+    let preserveSkillActiveForReviewPendingAutopilot = false;
+    for (const stateDir of scopedDirs) {
+        const files = await readdir(stateDir).catch(() => []);
+        const autopilotPath = join(stateDir, "autopilot-state.json");
+        const autopilotPrecheck = files.includes("autopilot-state.json")
+            ? await readPostLaunchModeStateFile(autopilotPath, dependencies)
+            : null;
+        const preserveReviewPendingAutopilot = autopilotPrecheck?.kind === "ok"
+            && isAutopilotReviewPendingPostLaunchState(autopilotPrecheck.state);
+        preserveSkillActiveForReviewPendingAutopilot ||= preserveReviewPendingAutopilot;
+        for (const file of files) {
+            if (!file.endsWith("-state.json") || file === "session.json")
+                continue;
+            const path = join(stateDir, file);
+            const mode = file.slice(0, -"-state.json".length);
+            const result = await readPostLaunchModeStateFile(path, dependencies);
+            if (result.kind !== "ok") {
+                if (result.kind === "recoverable") {
+                    try {
+                        const completedAt = now().toISOString();
+                        await writeFile(path, JSON.stringify(mode === SKILL_ACTIVE_STATE_MODE
+                            ? buildRecoveredPostLaunchSkillActiveState(completedAt)
+                            : buildRecoveredPostLaunchModeState(mode, completedAt), null, 2));
+                        if (isTrackedWorkflowMode(mode)) {
+                            await syncCanonicalSkillStateForMode({
+                                cwd,
+                                baseStateDir: rootStateDir,
+                                mode,
+                                active: false,
+                                currentPhase: "cancelled",
+                                sessionId: stateDir === getStateDir(cwd, sessionId) ? sessionId : undefined,
+                                nowIso: completedAt,
+                                source: "postLaunchCleanup",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        writeWarn(`[omx] postLaunch: failed to recover mode state ${path}: ${err instanceof Error ? err.message : err}`);
+                    }
+                }
+                else if (result.kind === "malformed") {
+                    writeWarn(`[omx] postLaunch: skipped malformed mode state ${path}: ${result.message}`);
+                }
+                continue;
+            }
+            const skillStateStillVisible = mode === SKILL_ACTIVE_STATE_MODE
+                && Array.isArray(result.state.active_skills)
+                && result.state.active_skills.length > 0;
+            if (result.state.active !== true && !skillStateStillVisible) {
+                if (mode === "ralph") {
+                    const completedAt = now().toISOString();
+                    if (markRalphCompletionAuditBlockedForPostLaunch(result.state, cwd, completedAt)) {
+                        await writeFile(path, JSON.stringify(result.state, null, 2));
+                        await syncCanonicalSkillStateForMode({
+                            cwd,
+                            baseStateDir: rootStateDir,
+                            mode,
+                            active: false,
+                            currentPhase: "cancelled",
+                            sessionId: stateDir === getStateDir(cwd, sessionId) ? sessionId : undefined,
+                            nowIso: completedAt,
+                            source: "postLaunchCleanup",
+                        });
+                    }
+                }
+                continue;
+            }
+            if (preserveReviewPendingAutopilot
+                && (mode === "autopilot" || mode === SKILL_ACTIVE_STATE_MODE)) {
+                continue;
+            }
+            try {
+                const completedAt = now().toISOString();
+                if (mode === SKILL_ACTIVE_STATE_MODE) {
+                    result.state.active = false;
+                    result.state.phase = "complete";
+                    result.state.updated_at = completedAt;
+                    result.state.active_skills = [];
+                    await writeFile(path, JSON.stringify(result.state, null, 2));
+                    continue;
+                }
+                result.state.active = false;
+                result.state.current_phase = "cancelled";
+                result.state.completed_at = completedAt;
+                if (mode === "ralph") {
+                    result.state.interrupted_at = completedAt;
+                    result.state.stop_reason = cleanPostLaunchString(result.state.stop_reason) || "session_exit";
+                }
+                await writeFile(path, JSON.stringify(result.state, null, 2));
+                if (isTrackedWorkflowMode(mode)) {
+                    await syncCanonicalSkillStateForMode({
+                        cwd,
+                        baseStateDir: rootStateDir,
+                        mode,
+                        active: false,
+                        currentPhase: "cancelled",
+                        sessionId: stateDir === getStateDir(cwd, sessionId) ? sessionId : undefined,
+                        nowIso: completedAt,
+                        source: "postLaunchCleanup",
+                    });
+                }
+            }
+            catch (err) {
+                writeWarn(`[omx] postLaunch: failed to update mode state ${path}: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    }
+    if (sessionId) {
+        try {
+            if (!preserveSkillActiveForReviewPendingAutopilot) {
+                await scrubPostLaunchRootSkillActiveForSession(rootStateDir, sessionId, now().toISOString(), writeFile, rootSkillActiveStateBeforeCleanup);
+            }
+        }
+        catch (err) {
+            writeWarn(`[omx] postLaunch: failed to reconcile root skill-active state: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+}
+export async function reapPostLaunchOrphanedMcpProcesses(dependencies = {}) {
+    const cleanup = dependencies.cleanup ?? cleanupLaunchOrphanedMcpProcesses;
+    const writeInfo = dependencies.writeInfo ?? console.log;
+    const writeWarn = dependencies.writeWarn ?? console.warn;
+    const writeError = dependencies.writeError ?? ((line) => process.stderr.write(line));
+    try {
+        const result = await cleanup();
+        if (result.terminatedCount > 0) {
+            writeInfo(`[omx] postLaunch: reaped ${result.terminatedCount} orphaned OMX MCP process(es).`);
+        }
+        if (result.failedPids.length > 0) {
+            writeWarn(`[omx] postLaunch: failed to reap ${result.failedPids.length} orphaned OMX MCP process(es); continuing cleanup.`);
+        }
+    }
+    catch (err) {
+        writeError(`[cli/index] postLaunch MCP cleanup failed: ${err}\n`);
+    }
+}
+/**
+ * preLaunch: Prepare environment before Codex starts.
+ * 1. Best-effort launch-safe orphan cleanup for detached OMX MCP processes
+ * 2. Generate runtime overlay + write session-scoped model instructions file
+ * 3. Write session.json
+ *
+ * Automatic broad stale-session cleanup remains disabled here. Only detached
+ * OMX MCP processes without a live Codex ancestor are reaped so new launches
+ * do not accumulate stale processes from prior crashed/closed sessions.
+ */
+export async function preLaunch(cwd, sessionId, notifyTempContract, codexHomeOverride, enableNotifyFallbackAuthority = false, worktreeDirty = false) {
+    // 1. Best-effort launch-safe orphan cleanup
+    try {
+        const cleanup = await cleanupLaunchOrphanedMcpProcesses();
+        if (cleanup.terminatedCount > 0) {
+            console.log(`[omx] Reaped ${cleanup.terminatedCount} orphaned OMX MCP process(es) before launch.`);
+        }
+        if (cleanup.failedPids.length > 0) {
+            console.warn(`[omx] Failed to reap ${cleanup.failedPids.length} orphaned OMX MCP process(es); continuing launch.`);
+        }
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 2. Generate runtime overlay + write session-scoped model instructions file
+    const orchestrationMode = await resolveSessionOrchestrationMode(cwd, sessionId);
+    const overlay = await generateOverlay(cwd, sessionId, { orchestrationMode });
+    const launchAppendix = await readLaunchAppendInstructions();
+    const dirtyWorktreeGuidance = worktreeDirty
+        ? `\n\n## Session start: dirty worktree detected\n\nThis worktree has uncommitted changes that were present when the session launched.\nBefore executing the requested task, resolve the dirty state first:\n1. Review uncommitted changes with \`git status\` and \`git diff\`.\n2. Commit, stash, or discard changes as appropriate.\n3. Then proceed with the original task.`
+        : "";
+    const sessionInstructions = launchAppendix.trim().length > 0
+        ? `${overlay}
+
+${launchAppendix}${dirtyWorktreeGuidance}`
+        : `${overlay}${dirtyWorktreeGuidance}`;
+    await writeSessionModelInstructionsFile(cwd, sessionId, sessionInstructions);
+    // 3. Write session state
+    await resetSessionMetrics(cwd, sessionId);
+    await writeSessionStart(cwd, sessionId);
+    tagCurrentTmuxSessionWithInstance(sessionId);
+    // 4. Start notify fallback watcher (best effort)
+    try {
+        await startNotifyFallbackWatcher(cwd, { codexHomeOverride, enableAuthority: enableNotifyFallbackAuthority, sessionId });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 5. Start derived watcher (best effort, opt-in)
+    try {
+        await startHookDerivedWatcher(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 6. Emit temp notification startup summary + warnings, then send session-start lifecycle notification (best effort)
+    try {
+        if (notifyTempContract?.active) {
+            process.env[OMX_NOTIFY_TEMP_CONTRACT_ENV] =
+                serializeNotifyTempContract(notifyTempContract);
+            const { getNotificationConfig } = await import("../notifications/config.js");
+            const resolved = getNotificationConfig();
+            const startup = buildNotifyTempStartupMessages(notifyTempContract, Boolean(resolved?.enabled));
+            for (const info of startup.infoLines) {
+                console.log(`[omx] ${info}`);
+            }
+            for (const warning of startup.warningLines) {
+                console.warn(`[omx] ${warning}`);
+            }
+        }
+        else {
+            delete process.env[OMX_NOTIFY_TEMP_CONTRACT_ENV];
+        }
+        const { notifyLifecycle } = await import("../notifications/index.js");
+        await notifyLifecycle("session-start", {
+            sessionId,
+            projectPath: cwd,
+            projectName: basename(cwd),
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: notification failures must never block launch
+    }
+    // 7. Dispatch native hook event (best effort)
+    try {
+        await emitNativeHookEvent(cwd, "session-start", {
+            session_id: sessionId,
+            context: buildNativeHookBaseContext(cwd, sessionId, "started", {
+                project_path: cwd,
+                project_name: basename(cwd),
+                status: "started",
+            }),
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+}
+/**
+ * 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) {
+    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 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 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 = prependOmxRuntimeCommandShimToEnv(cwd, {
+        ...stripHermesMcpBridgeEnv(process.env),
+        ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
+        ...(sqliteHomeOverride ? { [CODEX_SQLITE_HOME_ENV]: sqliteHomeOverride } : {}),
+        ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+    }, omxBin);
+    const codexEnvWithSession = {
+        ...codexBaseEnv,
+        ...buildHudRuntimeEnv({ sessionId }).env,
+    };
+    const codexEnv = workerLaunchArgs
+        ? { ...codexEnvWithSession, [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs }
+        : codexEnvWithSession;
+    const codexEnvWithNotify = notifyTempContractRaw
+        ? { ...codexEnv, [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw }
+        : codexEnv;
+    const { launchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows);
+    if (isCodexVersionRequest(launchArgs)) {
+        runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+        return { postLaunchHandledExternally: false };
+    }
+    if (launchPolicy === "inside-tmux") {
+        // Already in tmux: launch codex in current pane, HUD in bottom split
+        const currentWindowPanes = currentPaneId ? listCurrentWindowPanes(undefined, currentPaneId) : [];
+        reapDeadHudPanes(currentWindowPanes, {
+            killPane: (paneId) => {
+                try {
+                    return killSharedTmuxPane(paneId);
+                }
+                catch (err) {
+                    logCliOperationFailure(err);
+                    return false;
+                }
+            },
+        });
+        const staleHudPaneIds = currentPaneId
+            ? listHudWatchPaneIdsInCurrentWindow(currentPaneId, { sessionId, leaderPaneId: currentPaneId })
+            : [];
+        let hudPaneId = null;
+        const [keeperHudPaneId, ...duplicateHudPaneIds] = staleHudPaneIds;
+        for (const paneId of duplicateHudPaneIds) {
+            killTmuxPane(paneId);
+        }
+        if (keeperHudPaneId) {
+            hudPaneId = keeperHudPaneId;
+            try {
+                resizeTmuxPane(hudPaneId, HUD_TMUX_HEIGHT_LINES);
+                registerInsideTmuxHudResizeHook({
+                    hudPaneId,
+                    currentPaneId,
+                    cwd,
+                    sessionId,
+                    omxRootOverride,
+                });
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+            }
+        }
+        else if (isExistingTmuxWindowTooCrampedForLaunchHud(readCurrentWindowSize(undefined, currentPaneId).height)) {
+            // Existing tmux window is height-constrained: forcing a launch-time HUD
+            // split here would steal rows from the Codex TUI and make the
+            // transcript/input area unreadable. Skip the split at launch; the
+            // prompt-submit reconcile path can add the HUD later when there is room.
+            // (closes #2754)
+            hudPaneId = null;
+        }
+        else {
+            try {
+                hudPaneId = createHudWatchPane(cwd, hudCmd, {
+                    heightLines: HUD_TMUX_HEIGHT_LINES,
+                    targetPaneId: currentPaneId,
+                });
+                registerInsideTmuxHudResizeHook({
+                    hudPaneId,
+                    currentPaneId,
+                    cwd,
+                    sessionId,
+                    omxRootOverride,
+                });
+            }
+            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().
+        // Opt-out: set OMX_MOUSE=0. (closes #128)
+        if (process.env.OMX_MOUSE !== "0") {
+            try {
+                const tmuxPaneTarget = process.env.TMUX_PANE;
+                const displayArgs = tmuxPaneTarget
+                    ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+                    : ["display-message", "-p", "#S"];
+                const tmuxSession = execTmuxFileSync(displayArgs, {
+                    encoding: "utf-8",
+                }).trim();
+                if (tmuxSession)
+                    enableMouseScrolling(tmuxSession);
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+                // Non-fatal: mouse scrolling is a convenience feature
+            }
+        }
+        const activePaneId = process.env.TMUX_PANE?.trim();
+        if (activePaneId) {
+            try {
+                execTmuxFileSync(["display-message", "-p", "-t", activePaneId, "#S"], {
+                    encoding: "utf-8",
+                });
+            }
+            catch { }
+        }
+        try {
+            withTmuxExtendedKeys(cwd, () => {
+                runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+            });
+        }
+        finally {
+            if (currentPaneId) {
+                unregisterHudResizeHook(currentPaneId);
+            }
+            const cleanupPaneIds = buildHudPaneCleanupTargets(listHudWatchPaneIdsInCurrentWindow(currentPaneId, { sessionId, leaderPaneId: currentPaneId }), hudPaneId, currentPaneId);
+            for (const paneId of cleanupPaneIds) {
+                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
+        const codexCmd = buildTmuxPaneCommand("codex", launchArgs);
+        const detachedWindowsCodexCmd = nativeWindows
+            ? buildWindowsPromptCommand("codex", launchArgs)
+            : null;
+        const sessionName = buildDetachedTmuxSessionName(cwd, sessionId);
+        const launchDetachedSession = () => {
+            const contextKey = process.env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+            const runsRoot = resolveMadmaxRunsRoot(process.env);
+            const activeRecordPath = contextKey
+                ? madmaxDetachedActiveRecordPath(runsRoot, contextKey)
+                : null;
+            const activeRecord = activeRecordPath
+                ? readMadmaxDetachedActiveRecord(activeRecordPath)
+                : null;
+            if (activeRecord &&
+                activeRecord.context_key === contextKey &&
+                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], {
+                        stdio: "inherit",
+                    });
+                }
+                catch (err) {
+                    logCliOperationFailure(err);
+                    throw new MadmaxDetachedReuseError(`refusing duplicate madmax detached launch: existing session ${activeRecord.tmux_session_name} is active but attach failed`);
+                }
+                return { postLaunchHandledExternally: true };
+            }
+            if (activeRecordPath && activeRecord) {
+                rmSync(activeRecordPath, { force: true });
+            }
+            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
+                // server already exists, `new-session -e` only forwards explicit values,
+                // so provider-specific parent-shell keys would disappear. Source a
+                // private env file inside the leader shell instead of putting every
+                // parent env value on the tmux command line or in logs.
+                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);
+                for (const step of bootstrapSteps) {
+                    const output = execTmuxFileSync(step.args, {
+                        stdio: "pipe",
+                        encoding: "utf-8",
+                    });
+                    if (step.name === "new-session") {
+                        createdDetachedSession = true;
+                        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);
+                        }
+                    }
+                    if (step.name === "split-and-capture-hud-pane") {
+                        const hudPaneId = parsePaneIdFromTmuxOutput(output || "");
+                        const hookWindowIndex = hudPaneId
+                            ? detectDetachedSessionWindowIndex(sessionName)
+                            : null;
+                        const hookTarget = hudPaneId && hookWindowIndex
+                            ? buildResizeHookTarget(sessionName, hookWindowIndex)
+                            : null;
+                        const hookName = hudPaneId && hookWindowIndex
+                            ? buildResizeHookName("launch", sessionName, hookWindowIndex, hudPaneId)
+                            : null;
+                        const clientAttachedHookName = hudPaneId && hookWindowIndex
+                            ? buildClientAttachedReconcileHookName("launch", sessionName, hookWindowIndex, hudPaneId)
+                            : null;
+                        const finalizeSteps = buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, process.env.OMX_MOUSE !== "0", nativeWindows, shouldAttachDetachedTmuxSession(process.env), detachedLeaderPaneId);
+                        if (nativeWindows && detachedWindowsCodexCmd) {
+                            scheduleDetachedWindowsCodexLaunch(sessionName, detachedWindowsCodexCmd);
+                        }
+                        for (const finalizeStep of finalizeSteps) {
+                            if (finalizeStep.name === "sanitize-copy-mode-style") {
+                                try {
+                                    mitigateCopyModeUnderlineArtifacts(sessionName);
+                                }
+                                catch (err) {
+                                    logCliOperationFailure(err);
+                                }
+                                continue;
+                            }
+                            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);
+                                if (finalizeStep.name === "attach-session")
+                                    throw new Error("failed to attach detached tmux session");
+                                continue;
+                            }
+                            if (finalizeStep.name === "register-resize-hook" &&
+                                hookTarget &&
+                                hookName) {
+                                registeredHookTarget = hookTarget;
+                                registeredHookName = hookName;
+                            }
+                            if (finalizeStep.name === "register-client-attached-reconcile" &&
+                                clientAttachedHookName) {
+                                registeredClientAttachedHookName = clientAttachedHookName;
+                            }
+                            if (finalizeStep.name === "reconcile-hud-resize") {
+                                registerDetachedHudLayoutReconcileHook({
+                                    hudPaneId,
+                                    detachedLeaderPaneId,
+                                    cwd,
+                                    sessionId,
+                                    omxBin,
+                                    omxRootOverride,
+                                });
+                            }
+                        }
+                    }
+                }
+                return { postLaunchHandledExternally: !nativeWindows };
+            }
+            catch (err) {
+                if (detachedParentEnvFilePath) {
+                    rmSync(detachedParentEnvFilePath, { force: true });
+                }
+                if (activeRecordPath) {
+                    rmSync(activeRecordPath, { force: true });
+                }
+                if (createdDetachedSession) {
+                    const rollbackSteps = buildDetachedSessionRollbackSteps(sessionName, registeredHookTarget, registeredHookName, registeredClientAttachedHookName);
+                    for (const rollbackStep of rollbackSteps) {
+                        try {
+                            execTmuxFileSync(rollbackStep.args, { stdio: "ignore" });
+                        }
+                        catch (rollbackErr) {
+                            logCliOperationFailure(rollbackErr);
+                            // best-effort rollback only
+                        }
+                    }
+                }
+                throw err;
+            }
+        };
+        const contextKey = process.env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+        const runsRoot = resolveMadmaxRunsRoot(process.env);
+        try {
+            if (isMadmaxDetachedGuardEnabled(process.env) && contextKey) {
+                return withMadmaxDetachedContextLock(runsRoot, contextKey, launchDetachedSession);
+            }
+            return launchDetachedSession();
+        }
+        catch (err) {
+            if (err instanceof MadmaxDetachedReuseError || err instanceof MadmaxDetachedGuardError) {
+                throw err;
+            }
+            logCliOperationFailure(err);
+            // tmux not available or failed, just run codex directly
+            runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+            return { postLaunchHandledExternally: false };
+        }
+    }
+}
+function listHudWatchPaneIdsInCurrentWindow(currentPaneId, owner = {}) {
+    try {
+        return listCurrentWindowHudPaneIds(currentPaneId, undefined, owner);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        return [];
+    }
+}
+/**
+ * Decide whether an existing tmux window is too short to spend rows on a
+ * launch-time HUD split. When the window height is unknown (null), we keep the
+ * default behavior and create the HUD. (closes #2754)
+ */
+export function isExistingTmuxWindowTooCrampedForLaunchHud(windowHeight, minWindowHeight = HUD_TMUX_MIN_LAUNCH_WINDOW_HEIGHT_LINES) {
+    return isTmuxWindowTooCrampedForHudSplit(windowHeight, minWindowHeight);
+}
+function createHudWatchPane(cwd, hudCmd, options = {}) {
+    return createSharedHudWatchPane(cwd, hudCmd, {
+        heightLines: options.heightLines ?? HUD_TMUX_HEIGHT_LINES,
+        targetPaneId: options.targetPaneId,
+    });
+}
+function killTmuxPane(paneId) {
+    if (!paneId.startsWith("%"))
+        return;
+    try {
+        killSharedTmuxPane(paneId);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Pane may already be gone; ignore.
+    }
+}
+export function buildTmuxShellCommand(command, args) {
+    return [quoteShellArg(command), ...args.map(quoteShellArg)].join(" ");
+}
+function encodePowerShellCommand(commandText) {
+    return Buffer.from(commandText, "utf16le").toString("base64");
+}
+function isCodexVersionRequest(args) {
+    return args.some((arg) => CODEX_VERSION_FLAGS.has(arg));
+}
+export function buildWindowsPromptCommand(command, args) {
+    const invocation = [
+        "&",
+        quotePowerShellArg(command),
+        ...args.map(quotePowerShellArg),
+    ].join(" ");
+    const wrappedCommand = [
+        "$ErrorActionPreference = 'Stop'",
+        `& { ${invocation} }`,
+    ].join("; ");
+    return `powershell.exe -NoLogo -NoExit -EncodedCommand ${encodePowerShellCommand(wrappedCommand)}`;
+}
+/**
+ * Wrap a command for tmux pane execution while preserving the tmux pane cwd.
+ * tmux already starts the pane at `-c <cwd>`; using a login shell here can
+ * reset that cwd back to the shell's startup directory on some setups.
+ *
+ * Do not source user shell rc files by default. In issue #2282 the surviving
+ * OOM signature was thousands of bash processes, not MCP node children;
+ * non-interactive tmux panes sourcing ~/.bashrc can recursively trigger user
+ * automation and fan out before Codex starts. Users who need legacy PATH setup
+ * can opt in with OMX_TMUX_SOURCE_SHELL_RC=1.
+ */
+export function shouldSourceTmuxPaneShellRc(env = process.env) {
+    return String(env.OMX_TMUX_SOURCE_SHELL_RC ?? "").trim() === "1";
+}
+export function buildTmuxPaneCommand(command, args, shellPath = process.env.SHELL, env = process.env) {
+    const bareCmd = buildTmuxShellCommand(command, args);
+    let rcSource = "";
+    if (shouldSourceTmuxPaneShellRc(env)) {
+        if (shellPath && /\/zsh$/i.test(shellPath)) {
+            rcSource = "if [ -f ~/.zshrc ]; then source ~/.zshrc; fi; ";
+        }
+        else if (shellPath && /\/bash$/i.test(shellPath)) {
+            rcSource = "if [ -f ~/.bashrc ]; then source ~/.bashrc; fi; ";
+        }
+    }
+    const rawShell = shellPath && shellPath.trim() !== "" ? shellPath.trim() : "/bin/sh";
+    const shellBin = ALLOWED_SHELLS.has(rawShell) ? rawShell : "/bin/sh";
+    const inner = `${rcSource}exec ${bareCmd}`;
+    return `${quoteShellArg(shellBin)} -c ${quoteShellArg(inner)}`;
+}
+function quoteShellArg(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function quotePowerShellArg(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export function buildDetachedWindowsBootstrapScript(sessionName, commandText, delayMs = WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS, tmuxCommand = resolveTmuxExecutableForLaunch()) {
+    const delay = Number.isFinite(delayMs) && delayMs > 0
+        ? Math.floor(delayMs)
+        : WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS;
+    const targetLiteral = JSON.stringify(`${sessionName}:0.0`);
+    const commandLiteral = JSON.stringify(commandText);
+    const tmuxCommandLiteral = JSON.stringify(tmuxCommand);
+    return [
+        "const { execFileSync } = require('child_process');",
+        `const tmuxCommand = ${tmuxCommandLiteral};`,
+        `setTimeout(() => {`,
+        `try { execFileSync(tmuxCommand, ['send-keys', '-t', ${targetLiteral}, '-l', '--', ${commandLiteral}], { stdio: 'ignore' }); } catch {}`,
+        `try { execFileSync(tmuxCommand, ['send-keys', '-t', ${targetLiteral}, 'C-m'], { stdio: 'ignore' }); } catch {}`,
+        `}, ${delay});`,
+    ].join("");
+}
+function scheduleDetachedWindowsCodexLaunch(sessionName, commandText) {
+    const child = spawn(process.execPath, ["-e", buildDetachedWindowsBootstrapScript(sessionName, commandText)], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+}
+/**
+ * postLaunch: Clean up after Codex exits.
+ * Each step is independently fault-tolerant (try/catch per step).
+ */
+export async function postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority = false, projectLocalCodexHomeForCleanup) {
+    // Capture session start time before cleanup (writeSessionEnd deletes session.json)
+    let sessionStartedAt;
+    try {
+        const sessionState = await readSessionState(cwd);
+        sessionStartedAt = sessionState?.started_at;
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0. Reap MCP orphans left behind by the session that just exited.
+    await reapPostLaunchOrphanedMcpProcesses();
+    // 0. Flush fallback watcher once to reduce race with fast codex exit.
+    try {
+        await flushNotifyFallbackOnce(cwd, { codexHomeOverride, enableAuthority: enableNotifyFallbackAuthority, sessionId });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0. Stop notify fallback watcher first.
+    try {
+        await stopNotifyFallbackWatcher(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0. Flush derived watcher once on shutdown (opt-in, best effort).
+    try {
+        await flushHookDerivedWatcherOnce(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0.1 Stop derived watcher first (opt-in, best effort).
+    try {
+        await stopHookDerivedWatcher(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0.5. Remove Codex transient TUI NUX counters from project-local config only.
+    try {
+        if (projectLocalCodexHomeForCleanup) {
+            await cleanCodexModelAvailabilityNuxIfNeeded(join(projectLocalCodexHomeForCleanup, "config.toml"));
+        }
+    }
+    catch (err) {
+        console.error(`[omx] postLaunch: project config transient NUX cleanup failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 1. Remove session-scoped model instructions file
+    try {
+        await removeSessionModelInstructionsFile(cwd, sessionId);
+    }
+    catch (err) {
+        console.error(`[omx] postLaunch: model instructions cleanup failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 2. Archive session (write history, delete session.json)
+    try {
+        await writeSessionEnd(cwd, sessionId);
+    }
+    catch (err) {
+        console.error(`[omx] postLaunch: session archive failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 2.5. Best-effort wiki session capture
+    try {
+        const { onSessionEnd } = await import("../wiki/lifecycle.js");
+        onSessionEnd({ cwd, session_id: sessionId });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: wiki capture must never block session cleanup
+    }
+    // 3. Cancel any still-active modes
+    try {
+        await cleanupPostLaunchModeStateFiles(cwd, sessionId);
+    }
+    catch (err) {
+        console.error(`[omx] postLaunch: mode cleanup failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 4. Send session-end lifecycle notification (best effort)
+    try {
+        const { notifyLifecycle } = await import("../notifications/index.js");
+        const durationMs = sessionStartedAt
+            ? Date.now() - new Date(sessionStartedAt).getTime()
+            : undefined;
+        await notifyLifecycle("session-end", {
+            sessionId,
+            projectPath: cwd,
+            projectName: basename(cwd),
+            durationMs,
+            reason: "session_exit",
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: notification failures must never block session cleanup
+    }
+    // 4.5. Persist team leader attention when an active leader session exits.
+    try {
+        const { markOwnedTeamsLeaderSessionStopped } = await import("../team/state.js");
+        await markOwnedTeamsLeaderSessionStopped(cwd, sessionId);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 5. Dispatch native hook event (best effort)
+    try {
+        const durationMs = sessionStartedAt
+            ? Date.now() - new Date(sessionStartedAt).getTime()
+            : undefined;
+        const normalizedEvent = process.exitCode && process.exitCode !== 0 ? "failed" : "finished";
+        const errorSummary = normalizedEvent === "failed"
+            ? `codex exited with code ${process.exitCode}`
+            : undefined;
+        await emitNativeHookEvent(cwd, "session-end", {
+            session_id: sessionId,
+            context: buildNativeHookBaseContext(cwd, sessionId, normalizedEvent, {
+                project_path: cwd,
+                project_name: basename(cwd),
+                duration_ms: durationMs,
+                reason: "session_exit",
+                status: normalizedEvent === "failed" ? "failed" : "finished",
+                ...(process.exitCode !== undefined
+                    ? { exit_code: process.exitCode }
+                    : {}),
+                ...(errorSummary ? { error_summary: errorSummary } : {}),
+            }),
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+}
+export async function runDetachedSessionPostLaunch(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    await postLaunch(cwd, sessionId, codexHomeOverride, false, projectLocalCodexHomeForCleanup);
+    await cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch(logCliOperationFailure);
+}
+async function emitNativeHookEvent(cwd, event, opts = {}) {
+    const payload = buildHookEvent(event, {
+        source: "native",
+        context: opts.context || {},
+        session_id: opts.session_id,
+        thread_id: opts.thread_id,
+        turn_id: opts.turn_id,
+        mode: opts.mode,
+    });
+    await dispatchHookEvent(payload, {
+        cwd,
+        enabled: true,
+    });
+}
+function notifyFallbackPidPath(cwd) {
+    return join(omxRoot(cwd), "state", "notify-fallback.pid");
+}
+function hookDerivedWatcherPidPath(cwd) {
+    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
+    // survive parent loss. Windows Git Bash/MSYS uses a short hidden bootstrap
+    // process so the detached helper is created without stealing focus.
+    void env;
+    void platform;
+    return true;
+}
+export function resolveBackgroundHelperLaunchMode(env = process.env, platform = process.platform) {
+    return platform === "win32" && isMsysOrGitBash(env, platform)
+        ? "windows-msys-bootstrap"
+        : "direct-detached";
+}
+export function buildWindowsMsysBackgroundHelperBootstrapScript(helperArgs, cwd) {
+    const helperArgsLiteral = JSON.stringify(helperArgs);
+    const cwdLiteral = JSON.stringify(cwd);
+    return [
+        "const { spawn } = require('child_process');",
+        `const child = spawn(process.execPath, ${helperArgsLiteral}, { cwd: ${cwdLiteral}, detached: true, stdio: 'ignore', windowsHide: true, env: process.env });`,
+        "if (!child.pid) process.exit(1);",
+        "process.stdout.write(String(child.pid));",
+        "child.unref();",
+    ].join("");
+}
+async function launchBackgroundHelper(helperArgs, options) {
+    const launchMode = resolveBackgroundHelperLaunchMode(options.env, process.platform);
+    if (launchMode === "windows-msys-bootstrap") {
+        const { spawnSync } = await import("child_process");
+        const bootstrap = spawnSync(process.execPath, [
+            "-e",
+            buildWindowsMsysBackgroundHelperBootstrapScript(helperArgs, options.cwd),
+        ], {
+            cwd: options.cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            env: options.env,
+        });
+        if (bootstrap.error) {
+            throw bootstrap.error;
+        }
+        if (bootstrap.status !== 0) {
+            const detail = (bootstrap.stderr || bootstrap.stdout || "").trim();
+            throw new Error(detail || `background helper bootstrap exited ${bootstrap.status}`);
+        }
+        const helperPid = Number.parseInt((bootstrap.stdout || "").trim(), 10);
+        return Number.isFinite(helperPid) && helperPid > 0
+            ? helperPid
+            : undefined;
+    }
+    const child = spawn(process.execPath, helperArgs, {
+        cwd: options.cwd,
+        detached: shouldDetachBackgroundHelper(options.env, process.platform),
+        stdio: "ignore",
+        windowsHide: true,
+        env: options.env,
+    });
+    child.unref();
+    return child.pid;
+}
+function parseWatcherPidFile(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "number") {
+            return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+        }
+        const pid = typeof parsed === "object" && parsed !== null
+            ? parsed.pid
+            : undefined;
+        return typeof pid === "number" && Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        const pid = Number.parseInt(trimmed, 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+}
+const DEFAULT_NOTIFY_FALLBACK_REAP_GRACE_MS = 5000;
+function resolveNotifyFallbackReapGraceMs(env = process.env) {
+    const parsed = Number.parseInt(env.OMX_NOTIFY_FALLBACK_REAP_GRACE_MS || "", 10);
+    if (Number.isFinite(parsed) && parsed >= 0)
+        return parsed;
+    return DEFAULT_NOTIFY_FALLBACK_REAP_GRACE_MS;
+}
+function isWatcherRecordWithinReapGrace(record, nowMs = Date.now(), graceMs = resolveNotifyFallbackReapGraceMs()) {
+    if (graceMs <= 0 || !record.startedAt)
+        return false;
+    const startedMs = Date.parse(record.startedAt);
+    if (!Number.isFinite(startedMs))
+        return false;
+    const ageMs = nowMs - startedMs;
+    return ageMs >= 0 && ageMs < graceMs;
+}
+function parseWatcherPidRecord(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "object" && parsed !== null) {
+            const { pid, started_at: startedAtRaw } = parsed;
+            if (typeof pid === "number" && Number.isFinite(pid) && pid > 0) {
+                return {
+                    pid,
+                    startedAt: typeof startedAtRaw === "string" ? startedAtRaw : null,
+                };
+            }
+        }
+    }
+    catch {
+    }
+    const pid = parseWatcherPidFile(trimmed);
+    return pid ? { pid, startedAt: null } : null;
+}
+function isLikelyOmxWatcherProcess(pid, execFileSyncFn = execFileSync, platform = process.platform) {
+    if (platform === "win32") {
+        // ps is unavailable on native Windows; fall back to unconditional reap
+        // to preserve the pre-identity-check behavior on opted-in Windows hosts.
+        return true;
+    }
+    try {
+        const cmd = execFileSyncFn("ps", ["-p", String(pid), "-o", "command="], {
+            encoding: "utf-8",
+            timeout: 2000,
+            windowsHide: true,
+        });
+        return cmd.includes("notify-fallback-watcher") || cmd.includes("hook-derived-watcher");
+    }
+    catch {
+        return false;
+    }
+}
+export async function reapStaleNotifyFallbackWatcher(pidPath, deps = {}) {
+    const exists = deps.exists ?? existsSync;
+    if (!exists(pidPath))
+        return "missing";
+    const { readFile } = await import("fs/promises");
+    const readFileImpl = deps.readFile ?? readFile;
+    const tryKillPidImpl = deps.tryKillPid ?? tryKillPid;
+    const hasErrnoCodeImpl = deps.hasErrnoCode ?? hasErrnoCode;
+    const warn = deps.warn ?? console.warn;
+    const isWatcherProcessImpl = deps.isWatcherProcess ?? isLikelyOmxWatcherProcess;
+    try {
+        const record = parseWatcherPidRecord(await readFileImpl(pidPath, "utf-8"));
+        if (!record)
+            return "invalid";
+        if (!isWatcherProcessImpl(record.pid))
+            return "identity_mismatch";
+        if (isWatcherRecordWithinReapGrace(record, deps.nowMs?.() ?? Date.now(), deps.reapGraceMs ?? resolveNotifyFallbackReapGraceMs())) {
+            return "recent_active";
+        }
+        tryKillPidImpl(record.pid, "SIGTERM");
+        return "reaped";
+    }
+    catch (error) {
+        if (!hasErrnoCodeImpl(error, "ESRCH")) {
+            warn("[omx] warning: failed to stop stale notify fallback watcher", {
+                path: pidPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return "failed";
+    }
+}
+function tryKillPid(pid, signal = "SIGTERM") {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+async function startNotifyFallbackWatcher(cwd, options = {}) {
+    const { mkdir, writeFile } = await import("fs/promises");
+    const pidPath = notifyFallbackPidPath(cwd);
+    const reapResult = await reapStaleNotifyFallbackWatcher(pidPath);
+    if (reapResult === "recent_active")
+        return;
+    if (!shouldEnableNotifyFallbackWatcher(process.env, process.platform))
+        return;
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveNotifyFallbackWatcherScript(pkgRoot);
+    const notifyScript = resolveNotifyHookScript(pkgRoot);
+    if (!existsSync(watcherScript) || !existsSync(notifyScript))
+        return;
+    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),
+        });
+    });
+    const watcherEnv = buildNotifyFallbackWatcherEnv(process.env, {
+        codexHomeOverride: options.codexHomeOverride,
+        omxRootOverride: resolveOmxRootForLaunch(cwd, process.env),
+        enableAuthority: options.enableAuthority === true,
+        sessionId: options.sessionId,
+    });
+    let watcherPid;
+    try {
+        watcherPid = await launchBackgroundHelper([
+            watcherScript,
+            "--cwd",
+            cwd,
+            "--notify-script",
+            notifyScript,
+            "--pid-file",
+            pidPath,
+            "--parent-pid",
+            String(process.pid),
+            ...(process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS
+                ? [
+                    "--max-lifetime-ms",
+                    process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS,
+                ]
+                : []),
+        ], {
+            cwd,
+            env: watcherEnv,
+        });
+    }
+    catch (error) {
+        console.warn("[omx] warning: failed to launch notify fallback watcher", {
+            cwd,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    if (!watcherPid)
+        return;
+    await writeFile(pidPath, JSON.stringify({ pid: watcherPid, started_at: new Date().toISOString() }, null, 2)).catch((error) => {
+        console.warn("[omx] warning: failed to write notify fallback watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function startHookDerivedWatcher(cwd) {
+    if (process.env.OMX_HOOK_DERIVED_SIGNALS !== "1")
+        return;
+    const { mkdir, writeFile, readFile } = await import("fs/promises");
+    const pidPath = hookDerivedWatcherPidPath(cwd);
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveHookDerivedWatcherScript(pkgRoot);
+    if (!existsSync(watcherScript))
+        return;
+    if (existsSync(pidPath)) {
+        try {
+            const prev = JSON.parse(await readFile(pidPath, "utf-8"));
+            if (prev && typeof prev.pid === "number") {
+                process.kill(prev.pid, "SIGTERM");
+            }
+        }
+        catch (error) {
+            console.warn("[omx] warning: failed to stop stale hook-derived watcher", {
+                path: pidPath,
+                error: error instanceof Error ? error.message : String(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),
+        });
+    });
+    let watcherPid;
+    try {
+        watcherPid = await launchBackgroundHelper([watcherScript, "--cwd", cwd], {
+            cwd,
+            env: process.env,
+        });
+    }
+    catch (error) {
+        console.warn("[omx] warning: failed to launch hook-derived watcher", {
+            cwd,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    if (!watcherPid)
+        return;
+    await writeFile(pidPath, JSON.stringify({ pid: watcherPid, started_at: new Date().toISOString() }, null, 2)).catch((error) => {
+        console.warn("[omx] warning: failed to write hook-derived watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function stopNotifyFallbackWatcher(cwd) {
+    const { readFile, unlink } = await import("fs/promises");
+    const pidPath = notifyFallbackPidPath(cwd);
+    if (!existsSync(pidPath))
+        return;
+    try {
+        const pid = parseWatcherPidFile(await readFile(pidPath, "utf-8"));
+        if (pid) {
+            tryKillPid(pid, "SIGTERM");
+        }
+    }
+    catch (error) {
+        if (!hasErrnoCode(error, "ESRCH")) {
+            console.warn("[omx] warning: failed to stop notify fallback watcher process", {
+                path: pidPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    await unlink(pidPath).catch((error) => {
+        console.warn("[omx] warning: failed to remove notify fallback watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function stopHookDerivedWatcher(cwd) {
+    const { readFile, unlink } = await import("fs/promises");
+    const pidPath = hookDerivedWatcherPidPath(cwd);
+    if (!existsSync(pidPath))
+        return;
+    try {
+        const parsed = JSON.parse(await readFile(pidPath, "utf-8"));
+        if (parsed && typeof parsed.pid === "number") {
+            process.kill(parsed.pid, "SIGTERM");
+        }
+    }
+    catch (error) {
+        console.warn("[omx] warning: failed to stop hook-derived watcher process", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    await unlink(pidPath).catch((error) => {
+        console.warn("[omx] warning: failed to remove hook-derived watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function flushNotifyFallbackOnce(cwd, options = {}) {
+    if (!shouldEnableNotifyFallbackWatcher(process.env, process.platform))
+        return;
+    const { spawnSync } = await import("child_process");
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveNotifyFallbackWatcherScript(pkgRoot);
+    const notifyScript = resolveNotifyHookScript(pkgRoot);
+    if (!existsSync(watcherScript) || !existsSync(notifyScript))
+        return;
+    spawnSync(process.execPath, [watcherScript, "--once", "--cwd", cwd, "--notify-script", notifyScript], {
+        cwd,
+        stdio: "ignore",
+        timeout: 3000,
+        windowsHide: true,
+        env: buildNotifyFallbackWatcherEnv(process.env, {
+            codexHomeOverride: options.codexHomeOverride,
+            enableAuthority: options.enableAuthority === true,
+            sessionId: options.sessionId,
+        }),
+    });
+}
+async function flushHookDerivedWatcherOnce(cwd) {
+    if (process.env.OMX_HOOK_DERIVED_SIGNALS !== "1")
+        return;
+    const { spawnSync } = await import("child_process");
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveHookDerivedWatcherScript(pkgRoot);
+    if (!existsSync(watcherScript))
+        return;
+    spawnSync(process.execPath, [watcherScript, "--once", "--cwd", cwd], {
+        cwd,
+        stdio: "ignore",
+        timeout: 3000,
+        windowsHide: true,
+        env: {
+            ...process.env,
+            OMX_HOOK_DERIVED_SIGNALS: "1",
+        },
+    });
+}
+// Canonicalize a path for comparing a registry `source_cwd` against the current
+// working directory. `process.cwd()` resolves symlinks (e.g. macOS `/var` ->
+// `/private/var`), so registry values must be canonicalized the same way or the
+// run-dir fallback never matches. Falls back to `resolve` when the path is
+// missing (realpathSync requires an existing target).
+function canonicalizePathForRunDirMatch(p) {
+    try {
+        return realpathSync(resolve(p));
+    }
+    catch {
+        return resolve(p);
+    }
+}
+async function listHookVisibleRunDirStateRefs(cwd) {
+    const runsRoot = resolveMadmaxRunsRoot(process.env);
+    const registryPath = join(runsRoot, "registry.jsonl");
+    const runDirs = new Set();
+    const canonicalCwd = canonicalizePathForRunDirMatch(cwd);
+    const canonicalRunsRoot = resolve(runsRoot);
+    const addRecord = (raw) => {
+        if (!raw || typeof raw !== "object")
+            return;
+        const record = raw;
+        const sourceCwd = typeof record.source_cwd === "string" ? record.source_cwd.trim() : "";
+        const runDir = typeof record.run_dir === "string"
+            ? record.run_dir.trim()
+            : typeof record.cwd === "string"
+                ? record.cwd.trim()
+                : "";
+        if (!sourceCwd || !runDir)
+            return;
+        try {
+            if (canonicalizePathForRunDirMatch(sourceCwd) !== canonicalCwd)
+                return;
+            const resolvedRunDir = resolve(runDir);
+            if (resolvedRunDir !== canonicalRunsRoot
+                && !resolvedRunDir.startsWith(`${canonicalRunsRoot}/`)) {
+                return;
+            }
+            runDirs.add(resolvedRunDir);
+        }
+        catch {
+            return;
+        }
+    };
+    try {
+        const rawRegistry = await readFile(registryPath, "utf-8");
+        for (const line of rawRegistry.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                addRecord(JSON.parse(trimmed));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { }
+    try {
+        const activeDir = join(runsRoot, MADMAX_DETACHED_ACTIVE_DIR);
+        const files = await readdir(activeDir).catch(() => []);
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                addRecord(JSON.parse(await readFile(join(activeDir, file), "utf-8")));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { }
+    const refs = [];
+    const seenPaths = new Set();
+    for (const runDir of runDirs) {
+        const stateDir = join(runDir, ".omx", "state");
+        let sessionId;
+        try {
+            const session = JSON.parse(await readFile(join(stateDir, "session.json"), "utf-8"));
+            if (typeof session.session_id === "string" && session.session_id.trim()) {
+                sessionId = session.session_id.trim();
+            }
+        }
+        catch { }
+        const candidateDirs = sessionId ? [join(stateDir, "sessions", sessionId), stateDir] : [stateDir];
+        for (const dir of candidateDirs) {
+            const files = await readdir(dir).catch(() => []);
+            for (const file of files) {
+                if (!file.endsWith("-state.json") || file === "session.json")
+                    continue;
+                const path = join(dir, file);
+                if (seenPaths.has(path))
+                    continue;
+                seenPaths.add(path);
+                refs.push({
+                    mode: file.slice(0, -"-state.json".length),
+                    path,
+                    scope: dir === stateDir ? "root" : "session",
+                });
+            }
+        }
+    }
+    return refs.sort((a, b) => a.mode.localeCompare(b.mode));
+}
+async function cancelModes() {
+    const { writeFile, readFile } = await import("fs/promises");
+    const cwd = process.cwd();
+    const nowIso = new Date().toISOString();
+    try {
+        const loadStates = async (refs) => {
+            const loaded = new Map();
+            for (const ref of refs) {
+                const content = await readFile(ref.path, "utf-8");
+                let parsedState;
+                try {
+                    parsedState = JSON.parse(content);
+                }
+                catch (err) {
+                    logCliOperationFailure(err);
+                    continue;
+                }
+                loaded.set(ref.mode, {
+                    path: ref.path,
+                    scope: ref.scope,
+                    state: parsedState,
+                });
+            }
+            return loaded;
+        };
+        let states = await loadStates(await listModeStateFilesWithScopePreference(cwd));
+        const hasActiveWorkflowMode = (entries) => [...entries.entries()].some(([mode, entry]) => mode !== SKILL_ACTIVE_STATE_MODE && entry.state.active === true);
+        if (!hasActiveWorkflowMode(states)) {
+            const runDirStates = await loadStates(await listHookVisibleRunDirStateRefs(cwd));
+            if (hasActiveWorkflowMode(runDirStates))
+                states = runDirStates;
+        }
+        const changed = new Set();
+        const reported = new Set();
+        const cancelMode = (mode, phase = "cancelled", reportIfWasActive = true) => {
+            const entry = states.get(mode);
+            if (!entry)
+                return;
+            const wasActive = entry.state.active === true;
+            const needsChange = entry.state.active !== false ||
+                entry.state.current_phase !== phase ||
+                typeof entry.state.completed_at !== "string" ||
+                String(entry.state.completed_at).trim() === "";
+            if (!needsChange)
+                return;
+            entry.state.active = false;
+            entry.state.current_phase = phase;
+            entry.state.completed_at = nowIso;
+            entry.state.last_turn_at = nowIso;
+            if (mode === SKILL_ACTIVE_STATE_MODE) {
+                entry.state.phase = phase;
+                const activeSkills = Array.isArray(entry.state.active_skills)
+                    ? entry.state.active_skills
+                    : [];
+                entry.state.active_skills = activeSkills.map((skill) => (skill && typeof skill === "object"
+                    ? { ...skill, active: false, phase }
+                    : skill));
+            }
+            changed.add(mode);
+            if (reportIfWasActive && wasActive && mode !== SKILL_ACTIVE_STATE_MODE)
+                reported.add(mode);
+        };
+        const ralphLinksUltrawork = (state) => state.linked_ultrawork === true || state.linked_mode === "ultrawork";
+        const ralph = states.get("ralph");
+        const hadActiveRalph = !!(ralph && ralph.state.active === true);
+        if (ralph && ralph.state.active === true) {
+            cancelMode("ralph", "cancelled", true);
+            if (ralphLinksUltrawork(ralph.state))
+                cancelMode("ultrawork", "cancelled", true);
+        }
+        if (!hadActiveRalph) {
+            for (const [mode, entry] of states.entries()) {
+                if (entry.state.active === true)
+                    cancelMode(mode, "cancelled", true);
+            }
+        }
+        for (const [mode, entry] of states.entries()) {
+            if (!changed.has(mode))
+                continue;
+            await writeFile(entry.path, JSON.stringify(entry.state, null, 2));
+        }
+        for (const mode of reported) {
+            console.log(`Cancelled: ${mode}`);
+        }
+        if (reported.size === 0) {
+            console.log("No active modes to cancel.");
+        }
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        console.log("No active modes to cancel.");
+    }
+}
+//# sourceMappingURL=index.js.map