oh-my-codex 0.20.3 → 0.20.5

package/dist/cli/index.js

@@ -3,9 +3,9 @@
  * 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, stat, symlink, utimes, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, win32 } from "path";
+import { appendFileSync, chmodSync, closeSync, constants as fsConstants, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { copyFile, cp, lstat, mkdir, open, readFile, readdir, rm, stat, symlink, utimes, writeFile } from "fs/promises";
 import { constants as osConstants, homedir } from "os";
 import { createHash, randomUUID } from "crypto";
 import { setup, SETUP_MCP_MODES, SETUP_SCOPES, SETUP_TEAM_MODES, } from "./setup.js";
@@ -41,7 +41,7 @@ import { authCommand } from "./auth.js";
 import { missionCommand } from "./mission.js";
 import { resolveCodexGlobalOptionValue, 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, getBaseStateDirWithSource, getStateDir, listModeStateFilesWithScopePreference, resolveWritableStateScope, } from "../mcp/state-paths.js";
+import { getBaseStateDir, getBaseStateDirWithSource, getStateDir, isModeStateFilename, listModeStateFilesWithScopePreference, resolveWritableStateScope, } from "../mcp/state-paths.js";
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { normalizeTerminalWorkflowState } from "../state/terminal-normalization.js";
 import { readPersistedSetupPreferences, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
@@ -50,14 +50,14 @@ import { discoverOmxPluginCacheDirs, hasLocalOmxPluginEnablement, materializePac
 import { escapeTomlString, readTopLevelTomlString, upsertTopLevelTomlString } from "../utils/toml.js";
 import { ROOT_REASONING_EFFORTS, isUnsupportedRootReasoningEffort, normalizeUnsupportedRootReasoningEffort, } from "../config/models.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 { SKILL_ACTIVE_STATE_MODE, extractSessionIdFromInitializedStatePath, listActiveSkills, syncCanonicalSkillStateForMode, updateRootSkillActiveStateForStateDir, } 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 { isSessionPointerLaunchAbort, normalizeSessionId, readSessionState, writeSessionStart, writeSessionEnd, resetSessionMetrics, } from "../hooks/session.js";
+import { closeLaunchSessionBindingOnce, establishLaunchSessionBinding, readNativeSessionOwnerEvidence, readSessionPointer, readSessionState, resolveSessionPointerContext, finalizeBoundOnce, isSessionPointerLaunchAbort, normalizeSessionId, resetSessionMetrics, } from "../hooks/session.js";
 import { probeActualTmuxInstanceEvidence, tmuxEvidenceBindsCandidate } from "../scripts/notify-hook/managed-tmux.js";
-import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isMsysOrGitBash, isNativeWindows, isTmuxAvailable, mitigateCopyModeUnderlineArtifacts, } from "../team/tmux-session.js";
+import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isMsysOrGitBash, isNativeWindows, isTmuxAvailable, } 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";
@@ -73,6 +73,7 @@ import { buildHookEvent } from "../hooks/extensibility/events.js";
 import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
 import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, parseTeamWorkerLaunchArgs, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, serializeTeamWorkerLaunchArgs, TEAM_WORKER_INHERITED_MODEL_ENV, } from "../team/model-contract.js";
 import { parseWorktreeMode, planWorktreeTarget, ensureWorktree, } from "../team/worktree.js";
+import { resolveVerifiedDetachedTeamContext } from "../team/state-root.js";
 import { ensureReusableNodeModules } from "../utils/repo-deps.js";
 import { resolveWorktreeToolContext, worktreeToolContextEnv } from "../utils/worktree-tool-context.js";
 import { OMX_NOTIFY_TEMP_CONTRACT_ENV, parseNotifyTempContractFromArgs, serializeNotifyTempContract, } from "../notifications/temp-contract.js";
@@ -134,7 +135,8 @@ Usage:
                 Alias for agents-init (lightweight AGENTS bootstrap only)
   omx team      Spawn parallel worker panes in tmux and bootstrap inbox/task state
   omx ralph     Launch Codex with ralph persistence mode active
-  omx ralplan   Record validated role intents for adapted native subagent spawns
+  omx ralplan   Adapted Ralplan authority support; preflight applies only when native role routing is unavailable
+                and adapted Ralplan authority is requested; ordinary work remains under its own workflow gates
   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
@@ -262,7 +264,6 @@ const ALLOWED_SHELLS = new Set([
     "/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";
@@ -270,6 +271,7 @@ 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;
+export const DETACHED_LEADER_READY_TIMEOUT_MS = 120_000;
 const RESUME_HELP = `Usage: omx resume [--project] [--codex-home <path>] [codex resume options]
 
 Read-only help does not prepare or launch a Codex session.`;
@@ -520,6 +522,9 @@ export function resolveCliInvocation(args) {
     if (firstArg === "resume") {
         return { command: "resume", launchArgs: args.slice(1) };
     }
+    if (firstArg === "__detached-session-leader") {
+        return { command: firstArg, launchArgs: args.slice(1) };
+    }
     return { command: firstArg, launchArgs: [] };
 }
 export function resolveUpdateChannelArg(args) {
@@ -1042,6 +1047,228 @@ function execTmuxFileSync(args, options) {
         ...(process.platform === "win32" ? { windowsHide: true } : {}),
     });
 }
+function captureDetachedLeaderAuthority(leaderPaneId, expectedSessionName, ownerId) {
+    if (!/^%[0-9]+$/.test(leaderPaneId) || !ownerId)
+        throw new Error("invalid detached leader authority target");
+    const output = execTmuxFileSync([
+        "display-message", "-p", "-t", leaderPaneId,
+        "#{session_name}\t#{session_id}\t#{session_created}\t#{window_index}\t#{window_id}\t#{pane_id}\t#{pane_pid}",
+    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const fields = output.split("\t");
+    if (fields.length !== 7)
+        throw new Error("malformed detached leader authority");
+    const [sessionName, sessionId, sessionCreated, windowIndex, windowId, paneId, panePid] = fields;
+    if (sessionName !== expectedSessionName || paneId !== leaderPaneId || !/^\$[0-9]+$/.test(sessionId)
+        || !/^[0-9]+$/.test(sessionCreated) || !/^[0-9]+$/.test(windowIndex)
+        || !/^@[0-9]+$/.test(windowId) || !/^[1-9][0-9]*$/.test(panePid)) {
+        throw new Error("malformed detached leader authority");
+    }
+    const parsedPid = Number(panePid);
+    if (!Number.isSafeInteger(parsedPid) || parsedPid <= 0)
+        throw new Error("malformed detached leader authority");
+    return { paneId, panePid: parsedPid, sessionName, sessionId, sessionCreated, windowId, windowIndex, ownerId };
+}
+/** Internal detached-launch seam. Exported solely for deterministic CLI tests. */
+export function parseDetachedLeaderPaneIdByPid(snapshot, leaderPid) {
+    if (!Number.isSafeInteger(leaderPid) || leaderPid <= 0)
+        throw new Error("invalid detached leader pid");
+    const matches = snapshot
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.split("\t"))
+        .filter(([paneId, paneDead, panePid]) => /^%[0-9]+$/.test(paneId ?? "") && paneDead === "0" && Number(panePid) === leaderPid)
+        .map(([paneId]) => paneId);
+    if (matches.length !== 1)
+        throw new Error("detached leader pane identity is unavailable");
+    return matches[0];
+}
+function detachedLeaderAuthorityCondition(authority, requireOwner = true) {
+    const conditions = [
+        "#{==:#{pane_dead},0}",
+        `#{==:#{pane_id},${authority.paneId}}`,
+        `#{==:#{pane_pid},${authority.panePid}}`,
+        `#{==:#{session_id},${authority.sessionId}}`,
+        `#{==:#{session_created},${authority.sessionCreated}}`,
+        `#{==:#{window_id},${authority.windowId}}`,
+        ...(requireOwner ? [`#{==:#{@omx_instance_id},${authority.ownerId}}`] : []),
+    ];
+    return conditions.reduce((combined, condition) => `#{&&:${combined},${condition}}`);
+}
+function detachedHudAuthorityCondition(authority, requireMarker = true) {
+    const conditions = [
+        "#{==:#{pane_dead},0}",
+        `#{==:#{pane_id},${authority.paneId}}`,
+        `#{==:#{pane_pid},${authority.panePid}}`,
+        `#{==:#{session_id},${authority.sessionId}}`,
+        `#{==:#{window_id},${authority.windowId}}`,
+        ...(requireMarker ? [`#{m:*OMX_DETACHED_HUD_OPERATION=${authority.operationMarker}*,#{pane_start_command}}`] : []),
+    ];
+    return conditions.reduce((combined, condition) => `#{&&:${combined},${condition}}`);
+}
+function detachedAuthorityReceipt() {
+    return `omx_detached_${randomUUID()}`;
+}
+function runDetachedLeaderMutation(authority, args, requireOwner = true) {
+    const receipt = detachedAuthorityReceipt();
+    const success = `${args.map(quoteShellArg).join(" ")} ; display-message -p ${quoteShellArg(receipt)}`;
+    const output = execTmuxFileSync([
+        "if-shell", "-F", "-t", authority.paneId, detachedLeaderAuthorityCondition(authority, requireOwner),
+        success, "display-message -p ''",
+    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (output !== receipt)
+        throw new Error("detached leader authority changed before tmux mutation");
+}
+function detachedPreReportCleanupCondition(authority) {
+    const conditions = [
+        "#{==:#{pane_dead},1}",
+        `#{==:#{pane_id},${authority.paneId}}`,
+        `#{==:#{session_name},${authority.sessionName}}`,
+        `#{==:#{session_id},${authority.sessionId}}`,
+        `#{==:#{session_created},${authority.sessionCreated}}`,
+        `#{==:#{window_id},${authority.windowId}}`,
+    ];
+    return conditions.reduce((combined, condition) => `#{&&:${combined},${condition}}`);
+}
+export function cleanupDetachedPreReportSession(authority) {
+    const receipt = detachedAuthorityReceipt();
+    const success = `kill-session -t ${quoteShellArg(authority.sessionName)} ; display-message -p ${quoteShellArg(receipt)}`;
+    const output = execTmuxFileSync([
+        "if-shell", "-F", "-t", authority.paneId, detachedPreReportCleanupCondition(authority),
+        success, "display-message -p ''",
+    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (output !== receipt)
+        throw new Error("detached pre-report topology changed before cleanup");
+}
+function runDetachedHudMutation(leaderAuthority, hudAuthority, args, requireMarker = true) {
+    const receipt = detachedAuthorityReceipt();
+    const success = `${args.map(quoteShellArg).join(" ")} ; display-message -p ${quoteShellArg(receipt)}`;
+    const hudGuard = `if-shell -F -t ${quoteShellArg(hudAuthority.paneId)} ${quoteShellArg(detachedHudAuthorityCondition(hudAuthority, requireMarker))} ${quoteShellArg(success)} ${quoteShellArg("display-message -p ''")}`;
+    const output = execTmuxFileSync([
+        "if-shell", "-F", "-t", leaderAuthority.paneId, detachedLeaderAuthorityCondition(leaderAuthority),
+        hudGuard, "display-message -p ''",
+    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (output !== receipt)
+        throw new Error("detached leader or HUD authority changed before tmux mutation");
+}
+export function cleanupDetachedHudPane(authority, ownerId) {
+    if (ownerId) {
+        execTmuxFileSync(["kill-pane", "-t", authority.paneId], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    else {
+        execTmuxFileSync([
+            "if-shell", "-F", "-t", authority.paneId, detachedHudAuthorityCondition(authority, false),
+            `kill-pane -t ${quoteShellArg(authority.paneId)}`, "",
+        ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        const panes = execTmuxFileSync(["list-panes", "-a", "-F", "#{pane_id}"], {
+            encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"],
+        }).split("\n").map((value) => value.trim()).filter(Boolean);
+        if (!panes.includes(authority.paneId))
+            return;
+        blockMs(20);
+    }
+    throw new Error("detached HUD topology changed before teardown");
+}
+function tagDetachedHudPane(leaderAuthority, authority, ownerId) {
+    runDetachedHudMutation(leaderAuthority, authority, [
+        "set-option", "-pq", "-t", authority.paneId, "@omx_hud_owner", ownerId,
+    ], false);
+}
+export function discoverDetachedHudAuthority(sessionName, ownerId) {
+    const rows = execTmuxFileSync([
+        "list-panes", "-a", "-F",
+        "#{pane_id}\t#{pane_dead}\t#{pane_pid}\t#{session_name}\t#{session_id}\t#{session_created}\t#{window_id}\t#{@omx_hud_owner}",
+    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    const matches = rows.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+        const [paneId, paneDead, panePidRaw, discoveredSessionName, sessionId, sessionCreated, windowId, owner] = line.split("\t");
+        const panePid = Number(panePidRaw);
+        if (paneDead !== "0" || discoveredSessionName !== sessionName || owner !== ownerId || !/^%\d+$/.test(paneId ?? "") || !/^\$\d+$/.test(sessionId ?? "") || !/^\d+$/.test(sessionCreated ?? "") || !/^@\d+$/.test(windowId ?? "") || !Number.isSafeInteger(panePid) || panePid <= 0)
+            return [];
+        return [{ paneId: paneId, panePid, sessionId: sessionId, sessionCreated: sessionCreated, windowId: windowId, operationMarker: randomUUID() }];
+    });
+    if (matches.length > 1)
+        throw new Error("multiple detached HUD ownership tags found");
+    return matches[0];
+}
+function buildDeferredDetachedHudGuard(leaderAuthority, hudAuthority, command) {
+    const deferredReceipt = detachedAuthorityReceipt();
+    let guardedSinkCount = 0;
+    const guardedResize = (_match, sink) => {
+        guardedSinkCount += 1;
+        // The stored hook payload is consumed by one outer tmux format pass when
+        // run-shell executes it. The injected authority conditions must survive that
+        // pass so they are evaluated at execution time against the guarded panes;
+        // unescaped, tmux pre-expands them against the hook's own pane and collapses
+        // them to constants, denying the resize before the sink is parsed (#3292).
+        const outerFormatEscaped = (condition) => condition.replaceAll("#{", "##{");
+        const success = `${sink} ; display-message -p ${quoteShellArg(deferredReceipt)}`;
+        const hudGuard = `if-shell -F -t ${quoteShellArg(hudAuthority.paneId)} ${quoteShellArg(outerFormatEscaped(detachedHudAuthorityCondition(hudAuthority)))} ${quoteShellArg(success)} ${quoteShellArg("")}`;
+        return `tmux if-shell -F -t ${quoteShellArg(leaderAuthority.paneId)} ${quoteShellArg(outerFormatEscaped(detachedLeaderAuthorityCondition(leaderAuthority)))} ${quoteShellArg(hudGuard)} ${quoteShellArg("")}`;
+    };
+    const outerFormatEscapedCommand = command
+        .replaceAll('#{pane_id}', '##{pane_id}')
+        .replaceAll('#{pane_dead}', '##{pane_dead}')
+        .replaceAll('#{pane_pid}', '##{pane_pid}');
+    const guardedCommand = outerFormatEscapedCommand.replace(/tmux (resize-pane -t %[0-9]+ -y [1-9][0-9]*)/g, guardedResize);
+    if (guardedSinkCount === 0) {
+        throw new Error("detached deferred HUD mutation lacks a recognized resize sink");
+    }
+    return guardedCommand;
+}
+export function guardDetachedHudDeferredMutation(leaderAuthority, hudAuthority, args) {
+    if (args[0] === "set-hook" && typeof args.at(-1) === "string") {
+        const hookCommand = args.at(-1);
+        const runShellPrefix = "run-shell -b ";
+        if (!hookCommand.startsWith(runShellPrefix)) {
+            throw new Error("detached deferred HUD hook lacks a run-shell command");
+        }
+        const quotedPayload = hookCommand.slice(runShellPrefix.length);
+        if (!quotedPayload.startsWith("'") || !quotedPayload.endsWith("'")) {
+            throw new Error("detached deferred HUD hook has an invalid run-shell payload");
+        }
+        const payload = quotedPayload
+            .slice(1, -1)
+            .replaceAll(`'"'"'`, "'")
+            .replaceAll("'\\''", "'");
+        const guardedPayload = buildDeferredDetachedHudGuard(leaderAuthority, hudAuthority, payload);
+        return [...args.slice(0, -1), `${runShellPrefix}${quoteShellArg(guardedPayload)}`];
+    }
+    if (args[0] === "run-shell") {
+        const commandIndex = args.length - 1;
+        return [...args.slice(0, commandIndex), buildDeferredDetachedHudGuard(leaderAuthority, hudAuthority, args[commandIndex])];
+    }
+    return args;
+}
+function runDetachedLeaderSplit(authority, args) {
+    const receipt = detachedAuthorityReceipt();
+    const operationMarker = randomUUID();
+    const splitArgs = [...args];
+    const targetIndex = splitArgs.indexOf("-t");
+    if (targetIndex < 0 || splitArgs[targetIndex + 1] !== authority.sessionName)
+        throw new Error("invalid detached HUD split target");
+    splitArgs[targetIndex + 1] = authority.paneId;
+    const formatIndex = splitArgs.indexOf("-F");
+    if (formatIndex < 0 || splitArgs[formatIndex + 1] !== "#{pane_id}")
+        throw new Error("invalid detached HUD split receipt format");
+    const commandIndex = splitArgs.length - 1;
+    splitArgs[commandIndex] = `env OMX_DETACHED_HUD_OPERATION=${operationMarker} ${splitArgs[commandIndex]}`;
+    splitArgs[formatIndex + 1] = `#{pane_id}\t#{pane_pid}\t#{session_id}\t#{window_id}\t${receipt}`;
+    const output = execTmuxFileSync([
+        "if-shell", "-F", "-t", authority.paneId, detachedLeaderAuthorityCondition(authority),
+        splitArgs.map(quoteShellArg).join(" "), "display-message -p ''",
+    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const [paneId, panePid, sessionId, windowId, observedReceipt, ...extra] = output.split("\t");
+    if (!/^%[0-9]+$/.test(paneId) || !/^[1-9][0-9]*$/.test(panePid) || !/^\$[0-9]+$/.test(sessionId)
+        || !/^@[0-9]+$/.test(windowId) || observedReceipt !== receipt || extra.length !== 0) {
+        throw new Error("detached leader authority changed before HUD split");
+    }
+    const parsedPid = Number(panePid);
+    if (!Number.isSafeInteger(parsedPid) || parsedPid <= 0)
+        throw new Error("malformed detached HUD authority");
+    return { paneId, panePid: parsedPid, sessionId, windowId, operationMarker };
+}
 function readTmuxEnvValueForTarget(targetPaneId) {
     if (!targetPaneId.startsWith("%"))
         return undefined;
@@ -1129,29 +1356,6 @@ function clearDetachedTmuxSessionHistoryIfUnattached(sessionName, leaderPaneId)
         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
@@ -1193,6 +1397,12 @@ function logCliOperationFailure(error) {
     process.stderr.write(`[cli/index] operation failed: ${error}
 `);
 }
+function logEstablishmentCleanupEvidence(error) {
+    const cleanup = error?.establishmentCleanup;
+    if (!cleanup)
+        return;
+    process.stderr.write(`[omx] establishment cleanup evidence: ${JSON.stringify(cleanup)}\n`);
+}
 function tmuxFailureMessage(error) {
     if (!error || typeof error !== "object")
         return String(error);
@@ -1207,77 +1417,18 @@ function isUnsupportedTmuxExtendedKeysFailure(error) {
     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 probeDetachedTmuxTransport() {
+    const { result } = spawnPlatformCommandSync("tmux", ["-V"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error || result.status !== 0) {
+        throw new DetachedTransportUnavailable();
     }
 }
-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" };
+    const launchPolicy = resolveCodexLaunchPolicy(process.env, process.platform, Boolean(resolveTmuxBinaryForPlatform()), nativeWindows, undefined, undefined, explicitLaunchPolicy);
+    return { launchPolicy, effectiveExplicitLaunchPolicy: explicitLaunchPolicy };
 }
 export function resolveSignalExitCode(signal) {
     if (!signal)
@@ -1507,15 +1658,6 @@ export function resolveOmxRootForLaunch(cwd, env = process.env) {
 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) {
@@ -1574,6 +1716,8 @@ export function captureMadmaxWorktreeRuntimeContext(options) {
     const inheritedRoot = resolveInheritedMadmaxRoot(env);
     if (!inheritedRoot)
         return undefined;
+    if (!madmaxInheritedContextMatchesLaunch(options.sourceCwd, options.originalLaunchArgs, env))
+        return undefined;
     const sourceCwd = env.OMX_SOURCE_CWD?.trim() || options.sourceCwd;
     const worktreeCwd = options.worktreeCwd?.trim();
     const omxStateRoot = env.OMX_STATE_ROOT?.trim();
@@ -1761,31 +1905,77 @@ function readMadmaxDetachedActiveRecord(recordPath) {
             tmux_session_name: parsed.tmux_session_name,
             ...(typeof parsed.session_id === "string" ? { session_id: parsed.session_id } : {}),
             ...(typeof parsed.tmux_pane_id === "string" ? { tmux_pane_id: parsed.tmux_pane_id } : {}),
+            ...(typeof parsed.tmux_internal_session_id === "string" ? { tmux_internal_session_id: parsed.tmux_internal_session_id } : {}),
+            ...(typeof parsed.tmux_session_created === "string" ? { tmux_session_created: parsed.tmux_session_created } : {}),
+            ...(typeof parsed.tmux_pane_pid === "number" ? { tmux_pane_pid: parsed.tmux_pane_pid } : {}),
             ...(typeof parsed.worktree_cwd === "string" ? { worktree_cwd: parsed.worktree_cwd } : {}),
+            ...(typeof parsed.launch_nonce === "string" ? { launch_nonce: parsed.launch_nonce } : {}),
+            ...(typeof parsed.leader_pid === "number" && Number.isSafeInteger(parsed.leader_pid) && parsed.leader_pid > 0 ? { leader_pid: parsed.leader_pid } : {}),
+            ...(typeof parsed.base_state_root === "string" ? { base_state_root: parsed.base_state_root } : {}),
+            ...(parsed.lifecycle_phase === "ready" || parsed.lifecycle_phase === "terminal" ? { lifecycle_phase: parsed.lifecycle_phase } : {}),
         };
     }
     catch {
         return null;
     }
 }
+function queryMadmaxDetachedRuntimeBinding(record) {
+    if (!record.tmux_pane_id || !record.session_id)
+        return null;
+    try {
+        const output = execTmuxFileSync([
+            "list-panes", "-a", "-F",
+            "#{pane_id}\t#{pane_dead}\t#{pane_pid}\t#{session_name}\t#{session_id}\t#{session_created}\t#{@omx_instance_id}",
+        ], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+        let binding = null;
+        const seen = new Set();
+        for (const line of output.split("\n").filter(Boolean)) {
+            const fields = line.split("\t");
+            if (fields.length !== 7)
+                return null;
+            const [paneId, dead, panePidRaw, sessionName, internalSessionId, sessionCreated, omxInstanceId] = fields;
+            const panePid = Number(panePidRaw);
+            if (!/^%[0-9]+$/.test(paneId) || seen.has(paneId) || (dead !== "0" && dead !== "1")
+                || !Number.isSafeInteger(panePid) || panePid <= 0 || !sessionName
+                || !/^\$[0-9]+$/.test(internalSessionId) || !/^[0-9]+$/.test(sessionCreated))
+                return null;
+            seen.add(paneId);
+            if (paneId !== record.tmux_pane_id)
+                continue;
+            if (dead !== "0" || sessionName !== record.tmux_session_name || omxInstanceId !== record.session_id)
+                return null;
+            binding = { paneId, panePid, sessionName, internalSessionId, sessionCreated, omxInstanceId };
+        }
+        return binding;
+    }
+    catch {
+        return null;
+    }
+}
+function hasMatchingMadmaxDetachedRuntimeBinding(record) {
+    const binding = queryMadmaxDetachedRuntimeBinding(record);
+    return Boolean(binding
+        && binding.panePid === record.tmux_pane_pid
+        && binding.internalSessionId === record.tmux_internal_session_id
+        && binding.sessionCreated === record.tmux_session_created);
+}
 function isReusableMadmaxDetachedActiveRecord(record) {
-    if (!detachedTmuxSessionExists(record.tmux_session_name))
-        return false;
-    if (!record.session_id || !record.tmux_pane_id)
+    if (record.lifecycle_phase !== "ready" || !record.leader_pid || !record.base_state_root || !record.launch_nonce)
         return false;
-    if (readTmuxSessionInstanceId(record.tmux_session_name) !== record.session_id) {
+    try {
+        process.kill(record.leader_pid, 0);
+    }
+    catch {
         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;
+        if (realpathSync(record.base_state_root) !== record.base_state_root)
+            return false;
     }
     catch {
         return false;
     }
+    return hasMatchingMadmaxDetachedRuntimeBinding(record);
 }
 function readMadmaxDetachedLockOwner(lockPath) {
     try {
@@ -1854,7 +2044,7 @@ function inspectMadmaxDetachedContextLock(lockPath) {
         diagnostic: `lock has no readable owner pid yet; lock age ${Math.round(ageMs)}ms`,
     };
 }
-export function withMadmaxDetachedContextLock(runsRoot, contextKey, run, options = {}) {
+export async 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;
@@ -1872,7 +2062,7 @@ export function withMadmaxDetachedContextLock(runsRoot, contextKey, run, options
                 };
                 writeFileSync(join(lockPath, "owner.json"), `${JSON.stringify(owner, null, 2)}\n`, { mode: 0o600 });
                 writeFileSync(join(lockPath, "pid"), String(process.pid));
-                return run();
+                return await run();
             }
             finally {
                 rmSync(lockPath, { recursive: true, force: true });
@@ -1900,6 +2090,7 @@ function readMadmaxRunMetadata(runRoot) {
         const parsed = JSON.parse(readFileSync(join(runRoot, ".omxbox-run.json"), "utf-8"));
         return {
             ...(typeof parsed.cwd === "string" ? { cwd: parsed.cwd } : {}),
+            ...(typeof parsed.source_cwd === "string" ? { source_cwd: parsed.source_cwd } : {}),
             ...(typeof parsed.detached_launch_context === "string"
                 ? { detached_launch_context: parsed.detached_launch_context }
                 : {}),
@@ -1927,13 +2118,27 @@ function madmaxInheritedContextMatchesLaunch(cwd, launchArgs, env) {
         return false;
     if (metadata.cwd && metadata.cwd !== inheritedRoot)
         return false;
+    const sourceCwd = env.OMX_SOURCE_CWD?.trim();
+    if (!sourceCwd || !metadata.source_cwd || metadata.source_cwd !== sourceCwd)
+        return false;
     if (metadata.detached_launch_context !== context)
         return false;
     const expectedContext = buildMadmaxDetachedLaunchContextKey(cwd, [...launchArgs], inheritedRoot);
     return expectedContext === context;
 }
-function isMadmaxDetachedGuardEnabled(env) {
-    return env.OMXBOX_ACTIVE === "1" && typeof env[OMX_MADMAX_DETACHED_CONTEXT_ENV] === "string";
+function resolveVerifiedMadmaxDetachedContext(cwd, launchArgs, env) {
+    if (!madmaxInheritedContextMatchesLaunch(cwd, launchArgs, env))
+        return undefined;
+    const inheritedRoot = resolveInheritedMadmaxRoot(env);
+    const context = env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+    if (!inheritedRoot || !context)
+        return undefined;
+    return {
+        root: resolveLaunchPath(cwd, inheritedRoot),
+        sourceCwd: env.OMX_SOURCE_CWD?.trim() || cwd,
+        context,
+        runsRoot: resolveMadmaxRunsRoot(env),
+    };
 }
 function cleanupCurrentMadmaxReuseRunRoot(env, runsRoot) {
     const runRoot = env.OMX_ROOT;
@@ -1945,15 +2150,236 @@ function cleanupCurrentMadmaxReuseRunRoot(env, runsRoot) {
     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 });
+    const bytes = `${JSON.stringify(record, null, 2)}\n`;
+    const tempPath = `${recordPath}.${process.pid}.${randomUUID()}.tmp`;
+    let fd;
+    mkdirSync(dirname(recordPath), { recursive: true, mode: 0o700 });
+    try {
+        fd = openSync(tempPath, "wx", 0o600);
+        writeFileSync(fd, bytes, "utf-8");
+        try {
+            fsyncSync(fd);
+        }
+        catch (error) {
+            if (!(process.platform === "win32" && error.code === "EPERM"))
+                throw error;
+        }
+        closeSync(fd);
+        fd = undefined;
+        renameSync(tempPath, recordPath);
+        const directoryFd = openSync(dirname(recordPath), "r");
+        try {
+            try {
+                fsyncSync(directoryFd);
+            }
+            catch (error) {
+                if (!(process.platform === "win32" && error.code === "EPERM"))
+                    throw error;
+            }
+        }
+        finally {
+            closeSync(directoryFd);
+        }
+        return {
+            bytes,
+            digest: createHash("sha256").update(bytes).digest("hex"),
+            nonce: record.launch_nonce ?? "",
+        };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        try {
+            unlinkSync(tempPath);
+        }
+        catch { }
+    }
 }
-class MadmaxDetachedReuseError extends Error {
-    failClosed = true;
+function detachedFailureCode(error) {
+    const code = error && typeof error === "object" && "code" in error
+        ? error.code
+        : undefined;
+    return typeof code === "string" && /^(?:EACCES|EAGAIN|EBUSY|ECANCELED|ECONNREFUSED|EEXIST|EINTR|EINVAL|EIO|EISDIR|EMFILE|ENFILE|ENOENT|ENOSPC|ENOTDIR|EPERM|EPIPE|EROFS|ESRCH|ETIMEDOUT)$/.test(code) ? code : "unknown";
+}
+export function describeDetachedLeaderFailure(error) {
+    const describe = (value, depth) => {
+        if (depth > 4)
+            return "nested failure";
+        if (value instanceof AggregateError) {
+            return [value.message, ...[...value.errors].map((child) => describe(child, depth + 1))]
+                .filter(Boolean)
+                .join(": ");
+        }
+        if (value instanceof Error)
+            return value.message;
+        return String(value);
+    };
+    return describe(error, 0).replace(/[\r\n\t]+/g, " ").slice(0, 1_024);
+}
+export class DetachedLaunchSafetyError extends Error {
+    phase;
+    cause;
+    report;
+    name = "DetachedLaunchSafetyError";
+    constructor(phase, cause, report) {
+        super(`detached launch safety failure during ${phase}${phase === "completion" && cause instanceof Error ? `: ${cause.message}` : ""}`);
+        this.phase = phase;
+        this.cause = cause;
+        this.report = report;
+    }
+}
+export class DetachedTransportUnavailable extends Error {
+    reason;
+    name = "DetachedTransportUnavailable";
+    noSideEffects = true;
+    constructor(reason) {
+        super("detached transport is unavailable before launch side effects");
+        this.reason = reason;
+    }
+}
+/** Internal detached-launch seam. Exported solely for deterministic CLI tests. */
+export async function executeDetachedLaunchStateMachine(input, deps) {
+    const report = input.preflight.report;
+    const transition = (name) => { report.transitions.push(name); };
+    let binding;
+    let ownedRecord;
+    let released = false;
+    let retainedAuthority = false;
+    let rollbackAuthorized = false;
+    try {
+        transition("D1");
+        binding = await deps.establish();
+        retainedAuthority = true;
+        transition("D2");
+        const completion = await deps.complete(binding);
+        if (completion.kind === "failure") {
+            const failures = [completion.error];
+            try {
+                report.rollback.attempted.push("setup-finalization");
+                await deps.finalizeSetupFailure(binding);
+            }
+            catch (finalizationError) {
+                report.rollback.failures.push({ step: "setup-finalization", status: "failed", code: detachedFailureCode(finalizationError) });
+                failures.push(finalizationError);
+            }
+            throw new DetachedLaunchSafetyError("completion", new AggregateError(failures, `preLaunch ${completion.operation} failed: ${describeDetachedLeaderFailure(completion.error)}`), report);
+        }
+        transition("D3");
+        const inertSession = await deps.createInertSession();
+        transition("D4");
+        const pane = await deps.capturePane(inertSession);
+        transition("D5");
+        if (await deps.updateNameMetadata(binding, inertSession) !== "committed-released") {
+            throw new DetachedLaunchSafetyError("name-metadata", new Error("detached name metadata did not release"), report);
+        }
+        transition("D6");
+        if (await deps.updatePaneMetadata(binding, pane) !== "committed-released") {
+            throw new DetachedLaunchSafetyError("pane-metadata", new Error("detached pane metadata did not release"), report);
+        }
+        transition("D7");
+        ownedRecord = await deps.publishActiveRecord(inertSession, pane);
+        transition("D9");
+        try {
+            await deps.releaseBarrier();
+            released = true;
+        }
+        catch (releaseError) {
+            // A failed publication must not let the outer launcher destroy the
+            // leader's finalization capability. Request a nonce-bound abort and
+            // preserve all artifacts on timeout, malformed, or foreign reports.
+            let resolution;
+            try {
+                resolution = await deps.abortAndAwaitFinalization?.(releaseError);
+            }
+            catch (abortError) {
+                released = true;
+                throw new AggregateError([releaseError, abortError], "detached release and abort publication both failed");
+            }
+            rollbackAuthorized = resolution?.acknowledged === true && Boolean(resolution.nonce && resolution.sessionId && resolution.sessionName &&
+                Number.isSafeInteger(resolution.leaderPid) && resolution.kind);
+            if (!rollbackAuthorized)
+                released = true;
+            throw releaseError;
+        }
+        transition("D10");
+        await deps.attachOrReturn(inertSession, input.preflight.shouldAttach);
+        return { kind: input.preflight.shouldAttach ? "attached" : "returned", released: true, report };
+    }
+    catch (error) {
+        deps.diagnostic?.(error);
+        if (retainedAuthority && !rollbackAuthorized && !released) {
+            try {
+                const resolution = await deps.abortAndAwaitFinalization?.(error);
+                rollbackAuthorized = resolution?.rollbackAuthorized === true || (resolution?.acknowledged === true && Boolean(resolution.nonce && resolution.sessionId && resolution.sessionName &&
+                    Number.isSafeInteger(resolution.leaderPid) && resolution.kind));
+                if (!rollbackAuthorized)
+                    released = true;
+            }
+            catch (abortError) {
+                released = true;
+                deps.diagnostic?.(abortError);
+            }
+        }
+        if (!released) {
+            try {
+                report.rollback.attempted.push("rollback");
+                await deps.rollback(ownedRecord, report);
+            }
+            catch (rollbackError) {
+                report.rollback.failures.push({ step: "rollback", status: "failed", code: detachedFailureCode(rollbackError) });
+                deps.diagnostic?.(rollbackError);
+            }
+        }
+        if (error instanceof DetachedLaunchSafetyError) {
+            throw new DetachedLaunchSafetyError(error.phase, error.cause, report);
+        }
+        const phase = report.transitions.at(-1);
+        const phaseName = phase === "D1" ? "establishment"
+            : phase === "D2" ? "completion"
+                : phase === "D3" ? "inert-session"
+                    : phase === "D4" ? "pane-id"
+                        : phase === "D5" ? "name-metadata"
+                            : phase === "D6" ? "pane-metadata"
+                                : phase === "D7" ? "active-record"
+                                    : phase === "D9" ? "barrier-release"
+                                        : "post-release-attach";
+        throw new DetachedLaunchSafetyError(phaseName, error, report);
+    }
 }
 class MadmaxDetachedGuardError extends Error {
     failClosed = true;
 }
+function preflightDetachedLaunch() {
+    // D0 must remain transport-only: `tmux -V` neither connects to nor creates a server.
+    probeDetachedTmuxTransport();
+    const report = { transitions: ["D0"], rollback: { attempted: [], failures: [] } };
+    return Object.freeze({
+        kind: "available",
+        shouldAttach: shouldAttachDetachedTmuxSession(process.env),
+        report,
+    });
+}
+function handleMadmaxDetachedReuse(runtimeContext, preflight) {
+    const contextKey = runtimeContext?.madmaxDetachedContext ?? process.env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+    const activeRecordPath = contextKey ? madmaxDetachedActiveRecordPath(resolveMadmaxRunsRoot(process.env), contextKey) : null;
+    const activeRecord = activeRecordPath ? readMadmaxDetachedActiveRecord(activeRecordPath) : null;
+    if (!activeRecord || activeRecord.context_key !== contextKey || !isReusableMadmaxDetachedActiveRecord(activeRecord))
+        return false;
+    cleanupCurrentMadmaxReuseRunRoot(process.env, resolveMadmaxRunsRoot(process.env));
+    setDetachedTmuxSessionHistoryLimit(activeRecord.tmux_session_name, activeRecord.tmux_pane_id);
+    if (!preflight.shouldAttach) {
+        clearDetachedTmuxSessionHistoryIfUnattached(activeRecord.tmux_session_name, activeRecord.tmux_pane_id);
+        return 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 (error) {
+        throw new DetachedLaunchSafetyError("post-release-attach", error, preflight.report);
+    }
+    return true;
+}
 export function createMadmaxIsolatedRoot(sourceCwd, argv, env = process.env) {
     const runsRoot = resolveMadmaxRunsRoot(env);
     mkdirSync(runsRoot, { recursive: true });
@@ -1984,6 +2410,23 @@ function activateMadmaxIsolationIfNeeded(command, launchArgs, cwd, env = process
     env.OMX_SOURCE_CWD = cwd;
     process.stderr.write(`[omx] madmax isolated state: ${runDir} (source: ${cwd})\n`);
 }
+function renderDetachedLaunchSafetyReport(error) {
+    const establishmentCleanup = error.report.establishmentCleanup?.capability.map((entry) => ({
+        role: entry.role,
+        phase: entry.phase,
+        status: entry.status,
+        ...(entry.error ? { failureCode: detachedFailureCode(entry.error) } : {}),
+    }));
+    return JSON.stringify({
+        phase: error.phase,
+        transitions: error.report.transitions,
+        ...(establishmentCleanup ? { establishmentCleanup } : {}),
+        rollback: {
+            attempted: error.report.rollback.attempted,
+            failures: error.report.rollback.failures.map(({ step, status, code }) => ({ step, status, code })),
+        },
+    });
+}
 export async function main(args) {
     const knownCommands = new Set([
         "launch",
@@ -1992,6 +2435,7 @@ export async function main(args) {
         "imagegen",
         "capabilities",
         "setup",
+        "__detached-session-leader",
         "update",
         "list",
         "agents",
@@ -2043,6 +2487,9 @@ export async function main(args) {
         console.log(HELP);
         return;
     }
+    if (command !== "launch" && command !== "resume") {
+        activateMadmaxIsolationIfNeeded(command, launchArgs, process.cwd(), process.env);
+    }
     try {
         if (command === "session") {
             await sessionCommand(args.slice(1));
@@ -2052,8 +2499,13 @@ export async function main(args) {
             console.log(RESUME_HELP);
             return;
         }
-        activateMadmaxIsolationIfNeeded(command, launchArgs, process.cwd(), process.env);
         switch (command) {
+            case "__detached-session-leader": {
+                const payload = decodeDetachedLeaderPayload(launchArgs[0]);
+                await runDetachedSessionLeader(payload);
+                process.exit(typeof process.exitCode === "number" ? process.exitCode : 0);
+                break;
+            }
             case "launch":
                 if (launchArgsRequestAuthHotswap(launchArgs)) {
                     await launchWithAuthHotswap(launchArgs);
@@ -2249,7 +2701,13 @@ export async function main(args) {
         }
     }
     catch (err) {
-        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        if (err instanceof DetachedLaunchSafetyError) {
+            console.error(`Error: ${err.message}`);
+            console.error(`[omx] detached launch safety report: ${renderDetachedLaunchSafetyReport(err)}`);
+        }
+        else {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        }
         process.exit(1);
     }
 }
@@ -2480,38 +2938,29 @@ export async function launchWithAuthHotswap(args) {
     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 { omxArgs, suffix } = splitOmxArgsAtEndOfOptions(args);
     const parsedWorktree = parseWorktreeMode(omxArgs);
     const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
     const passthroughArgs = [...notifyTempResult.passthroughArgs, ...suffix];
     const explicitLaunchPolicy = resolveEffectiveLeaderLaunchPolicyOverride(passthroughArgs, process.env);
-    const persistentCodexHomeForLaunch = resolveCodexHomeForLaunch(launchCwd, process.env);
-    const { launchPolicy, effectiveExplicitLaunchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
+    let { launchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
+    let detachedPreflight;
+    if (launchPolicy === "detached-tmux") {
+        try {
+            detachedPreflight = preflightDetachedLaunch();
+        }
+        catch (error) {
+            if (!(error instanceof DetachedTransportUnavailable))
+                throw error;
+            console.warn("[omx] warning: detached tmux transport is unavailable. Falling back to direct Codex launch.");
+            launchPolicy = "direct";
+        }
+    }
     const enableNotifyFallbackAuthority = launchPolicy === "direct";
+    activateMadmaxIsolationIfNeeded("launch", args, launchCwd, process.env);
+    const verifiedMadmaxLaunchContext = resolveVerifiedMadmaxDetachedContext(launchCwd, args, process.env);
+    const persistentCodexHomeForLaunch = resolveCodexHomeForLaunch(launchCwd, process.env);
     const workerSparkModel = resolveWorkerSparkModel(passthroughArgs, persistentCodexHomeForLaunch);
     let normalizedArgs = normalizeCodexLaunchArgs(passthroughArgs);
     let cwd = launchCwd;
@@ -2551,6 +3000,8 @@ export async function launchWithHud(args) {
     clearInheritedMadmaxRootForDisposableWorktreeLaunch(parsedWorktree.remainingArgs);
     applyDisposableWorktreeOmxRootForLaunch(ensuredLaunchWorktree);
     applyWorktreeToolContextForLaunch(cwd, ensuredLaunchWorktree);
+    if (launchPolicy === "detached-tmux" && detachedPreflight && handleMadmaxDetachedReuse(madmaxWorktreeRuntimeContext, detachedPreflight))
+        return;
     const sessionId = `omx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     try {
         await maybeCheckAndPromptUpdate(cwd);
@@ -2592,37 +3043,77 @@ export async function launchWithHud(args) {
     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);
+    let insideTmuxControlPlane;
+    if (launchPolicy === "inside-tmux") {
+        let verifiedTeamContext;
+        try {
+            verifiedTeamContext = await resolveVerifiedDetachedTeamContext(cwd, process.env);
+        }
+        catch {
+            verifiedTeamContext = undefined;
+        }
+        insideTmuxControlPlane = buildDetachedLaunchControlPlane({
+            cwd,
+            sessionId,
+            env: process.env,
+            omxRootOverride: resolveOmxRootForLaunch(cwd, process.env),
+            runtimeContext: madmaxWorktreeRuntimeContext,
+            verifiedMadmaxContext: verifiedMadmaxLaunchContext,
+            leaderPaneId: process.env.TMUX_PANE,
+            verifiedTeamContext,
+        });
     }
-    catch (err) {
-        if (isSessionPointerLaunchAbort(err)) {
-            console.error(`[omx] session pointer launch aborted: ${err.code}`);
-            reportOrdinaryLaunchRootConflict(err, cwd, cwd === launchCwd && !parsedWorktree.mode.enabled && !isResumeCodexLaunch(normalizedArgs));
+    const restoreInsideTmuxControlPlane = insideTmuxControlPlane
+        ? applyLaunchOwnedControlPlane(insideTmuxControlPlane)
+        : undefined;
+    let launch;
+    if (launchPolicy !== "detached-tmux") {
+        try {
+            launch = await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, enableNotifyFallbackAuthority, worktreeDirty);
+        }
+        catch (err) {
+            logEstablishmentCleanupEvidence(err);
+            if (isSessionPointerLaunchAbort(err)) {
+                console.error(`[omx] session pointer launch aborted: ${err.code}`);
+                reportOrdinaryLaunchRootConflict(err, cwd, cwd === launchCwd && !parsedWorktree.mode.enabled && !isResumeCodexLaunch(normalizedArgs));
+            }
+            restoreInsideTmuxControlPlane?.();
             await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch((cleanupErr) => {
                 console.error(`[omx] preLaunch abort cleanup warning: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`);
             });
             throw err;
         }
-        // preLaunch errors after pointer commit 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, madmaxWorktreeRuntimeContext);
+        const launchResult = await runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, sqliteHomeOverride, notifyTempContractRaw, {
+            notifyTempContract: notifyTempResult.contract,
+            enableNotifyFallbackAuthority,
+            worktreeDirty,
+        }, launchPolicy, detachedPreflight, projectLocalCodexHomeForCleanup, preparedCodexHome.runtimeCodexHomeForCleanup, madmaxWorktreeRuntimeContext, verifiedMadmaxLaunchContext, insideTmuxControlPlane);
         postLaunchHandledExternally = launchResult.postLaunchHandledExternally;
     }
+    catch (error) {
+        if (error instanceof DetachedLaunchSafetyError)
+            postLaunchHandledExternally = true;
+        throw error;
+    }
     finally {
-        // ── Phase 3: postLaunch ─────────────────────────────────────────────
-        if (!postLaunchHandledExternally) {
-            await postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority, projectLocalCodexHomeForCleanup);
+        if (!postLaunchHandledExternally && launch) {
+            try {
+                await postLaunch(cwd, sessionId, launch.binding, codexHomeOverride, enableNotifyFallbackAuthority, projectLocalCodexHomeForCleanup);
+            }
+            finally {
+                restoreInsideTmuxControlPlane?.();
+            }
             await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch(logCliOperationFailure);
         }
+        else {
+            restoreInsideTmuxControlPlane?.();
+        }
     }
 }
 export async function execWithOverlay(args) {
@@ -2689,18 +3180,19 @@ export async function execWithOverlay(args) {
     const codexHomeOverride = preparedCodexHome.codexHomeOverride;
     const sqliteHomeOverride = preparedCodexHome.sqliteHomeOverride;
     const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
+    let launch;
     try {
-        await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, true, worktreeDirty);
+        launch = await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, true, worktreeDirty);
     }
     catch (err) {
+        logEstablishmentCleanupEvidence(err);
         if (isSessionPointerLaunchAbort(err)) {
             console.error(`[omx] session pointer launch aborted: ${err.code}`);
-            await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch((cleanupErr) => {
-                console.error(`[omx] preLaunch abort cleanup warning: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`);
-            });
-            throw err;
         }
-        console.error(`[omx] preLaunch warning: ${err instanceof Error ? err.message : err}`);
+        await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch((cleanupErr) => {
+            console.error(`[omx] preLaunch abort cleanup warning: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`);
+        });
+        throw err;
     }
     try {
         const notifyTempContractRaw = notifyTempResult.contract.active
@@ -2708,22 +3200,28 @@ export async function execWithOverlay(args) {
             : null;
         const codexArgs = injectModelInstructionsBypassArgs(cwd, ["exec", ...normalizedArgs], process.env, sessionModelInstructionsPath(cwd, sessionId));
         const omxRootOverride = resolveOmxRootForLaunch(cwd, process.env);
-        const codexEnvBase = {
-            ...process.env,
+        const omxBin = resolveOmxCliEntryPath({ argv1: process.argv[1], cwd, env: process.env });
+        if (!omxBin)
+            throw new Error("Unable to resolve OMX launcher path for exec");
+        const hudRuntimeRoot = resolveHudRuntimeRootForLaunch(cwd, process.env);
+        const codexEnvBase = prependOmxRuntimeCommandShimToEnv(cwd, {
+            ...stripHermesMcpBridgeEnv(process.env),
             ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
             ...(sqliteHomeOverride ? { [CODEX_SQLITE_HOME_ENV]: sqliteHomeOverride } : {}),
             ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+        }, omxBin);
+        // Correlates plugin hook routing only; it is not an authority token.
+        const pluginHookRoutingLaunchId = randomUUID();
+        const codexEnv = {
+            ...codexEnvBase,
+            OMX_CODEX_LAUNCH_ID: pluginHookRoutingLaunchId,
+            ...buildHudRuntimeEnv({ sessionId, ...hudRuntimeRoot }).env,
+            ...(notifyTempContractRaw ? { [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw } : {}),
         };
-        const codexEnv = notifyTempContractRaw
-            ? {
-                ...codexEnvBase,
-                [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw,
-            }
-            : codexEnvBase;
         runCodexBlocking(cwd, codexArgs, codexEnv);
     }
     finally {
-        await postLaunch(cwd, sessionId, codexHomeOverride, true, projectLocalCodexHomeForCleanup);
+        await postLaunch(cwd, sessionId, launch.binding, codexHomeOverride, true, projectLocalCodexHomeForCleanup);
         await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch(logCliOperationFailure);
     }
 }
@@ -3005,9 +3503,6 @@ export function detectDetachedSessionWindowIndex(sessionName) {
         return null;
     }
 }
-function escapeShellDoubleQuotedValue(value) {
-    return value.replace(/["\\$`]/g, "\\$&");
-}
 function sanitizeTmuxLeaseKey(value) {
     const cleaned = value
         .toLowerCase()
@@ -3193,121 +3688,188 @@ function withTmuxExtendedKeysLeaseLock(cwd, socketPath, run) {
     }
     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();
+function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnvFilePath, readyPath, preLaunchOptions, omxBin = process.argv[1]) {
+    const payload = Buffer.from(JSON.stringify({
+        cwd, sessionName, sessionId, codexCmd, codexHomeOverride,
+        projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnvFilePath,
+        readyPath, preLaunchOptions,
+    })).toString("base64url");
+    return `/bin/sh -c ${quoteShellArg(`${parentEnvFilePath ? `if [ -r ${quoteShellArg(parentEnvFilePath)} ]; then . ${quoteShellArg(parentEnvFilePath)}; rm -f ${quoteShellArg(parentEnvFilePath)}; fi; ` : ""}exec ${quoteShellArg(process.execPath)} ${quoteShellArg(omxBin)} __detached-session-leader ${quoteShellArg(payload)}`)}`;
+}
+function buildDetachedWindowsLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnv, readyPath, preLaunchOptions, omxBin = process.argv[1]) {
+    const payload = Buffer.from(JSON.stringify({
+        cwd, sessionName, sessionId, codexCmd, codexHomeOverride,
+        projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup,
+        ...(parentEnv ? { parentEnv: detachedSessionParentEnvironment(parentEnv, true) } : {}),
+        readyPath, preLaunchOptions,
+    })).toString("base64url");
+    const invocation = `& ${quotePowerShellArg(process.execPath)} ${quotePowerShellArg(omxBin)} __detached-session-leader ${quotePowerShellArg(payload)}`;
+    return `powershell.exe -NoLogo -NoProfile -NonInteractive -Command ${quotePowerShellArg(invocation)}`;
+}
+export function isDetachedReadyReportAuthorized(report, expected) {
+    if (report?.kind !== "ready" || report.nonce !== expected.nonce
+        || report.sessionId !== expected.sessionId || report.sessionName !== expected.sessionName
+        || typeof report.leaderPid !== "number" || report.leaderPid <= 0)
+        return false;
+    if (expected.shouldAttach && expected.leaderPanePid !== null) {
+        return report.leaderPid === expected.leaderPanePid;
+    }
+    return report.paneId === expected.leaderPaneId;
 }
-export function acquireTmuxExtendedKeysLease(cwd, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
-    encoding: "utf-8",
-    ...(process.platform === "win32" ? { windowsHide: true } : {}),
-}), ownerPid = process.pid) {
+function writeDetachedLeaderReport(path, report) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    let fd;
     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 });
+        fd = openSync(tempPath, "wx", 0o600);
+        writeFileSync(fd, `${JSON.stringify(report)}\n`, "utf-8");
+        try {
+            fsyncSync(fd);
+        }
+        catch (error) {
+            if (!(process.platform === "win32" && error.code === "EPERM"))
+                throw error;
+        }
+        closeSync(fd);
+        fd = undefined;
+        renameSync(tempPath, path);
+        const directoryFd = openSync(dirname(path), "r");
+        try {
+            try {
+                fsyncSync(directoryFd);
             }
-            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;
+            catch (error) {
+                if (!(process.platform === "win32" && error.code === "EPERM"))
+                    throw error;
             }
-            state.holders.push(createTmuxExtendedKeysLeaseHolder(leaseId, holderPid));
-            writeTmuxExtendedKeysLeaseState(leasePath, state);
-        });
-        return `${socketPath}\t${leaseId}`;
-    }
-    catch (err) {
-        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
-            logCliOperationFailure(err);
+        }
+        finally {
+            closeSync(directoryFd);
+        }
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        try {
+            unlinkSync(tempPath);
+        }
+        catch { }
+    }
+}
+function readDetachedLeaderReport(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (!value || typeof value !== "object")
+            return undefined;
+        const report = value;
+        if (report.version !== 1 || !["ready", "failed", "terminal", "release", "abort"].includes(String(report.kind)) ||
+            typeof report.nonce !== "string" || typeof report.sessionId !== "string" || typeof report.sessionName !== "string")
+            return undefined;
+        if (report.paneId !== undefined && typeof report.paneId !== "string")
+            return undefined;
+        if (report.leaderPid !== undefined && (!Number.isSafeInteger(report.leaderPid) || Number(report.leaderPid) <= 0))
+            return undefined;
+        if (report.exitStatus !== undefined && (!Number.isSafeInteger(report.exitStatus) || Number(report.exitStatus) < 0 || Number(report.exitStatus) > 255))
+            return undefined;
+        return report;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Internal detached-launch seam. Exported solely for deterministic CLI tests. */
+export function publishDetachedReleaseMarker(releaseMarkerPath, nonce, sessionId, sessionName, leaderPid, hud) {
+    writeDetachedLeaderReport(`${releaseMarkerPath}.release`, {
+        version: 1, kind: "release", nonce, sessionId, sessionName, leaderPid, ...(hud ? { hud } : {}),
+    });
+}
+/** Internal detached-launch seam. Exported solely for deterministic CLI tests. */
+export function applyDetachedTerminalExitStatus(releaseMarkerPath, expected) {
+    const report = readDetachedLeaderReport(releaseMarkerPath);
+    if (!report || report.kind !== "terminal" || report.finalized !== true)
+        return false;
+    if (report.nonce !== expected.nonce || report.sessionId !== expected.sessionId ||
+        report.sessionName !== expected.sessionName || report.leaderPid !== expected.leaderPid)
+        return false;
+    if (typeof report.exitStatus !== "number")
+        return false;
+    process.exitCode = report.exitStatus;
+    return true;
+}
+/** Internal detached-launch seam. Exported solely for deterministic CLI tests. */
+export function probeExactDetachedSessionExists(authority) {
+    if (!authority)
+        return undefined;
+    try {
+        // A retained dead pane (remain-on-exit) keeps its pid/topology, so prove
+        // liveness first: a dead leader with no valid terminal report is a failure,
+        // never a manual detach.
+        const paneDead = execTmuxFileSync(["display-message", "-p", "-t", authority.paneId, "#{pane_dead}"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        if (paneDead === "1")
+            return false;
+        if (paneDead !== "0")
+            return undefined;
+        // Re-capture the exact leader-pane topology the bootstrap authority recorded.
+        // A matching recapture proves the owned session and its leader survive (manual
+        // detach); a destroyed session, recycled pane id, or tmux error fails closed.
+        const current = captureDetachedLeaderAuthority(authority.paneId, authority.sessionName, authority.ownerId);
+        return current.panePid === authority.panePid && current.sessionId === authority.sessionId
+            && current.sessionCreated === authority.sessionCreated && current.windowId === authority.windowId
+            && current.windowIndex === authority.windowIndex;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Internal detached-launch seam. Exported solely for deterministic CLI tests. */
+export function resolveDetachedAttachExitStatus(releaseMarkerPath, expected, probe) {
+    if (applyDetachedTerminalExitStatus(releaseMarkerPath, expected))
+        return "applied";
+    return probe.exactSessionExists() === true ? "manual-detach" : "protocol-failure";
+}
+function publishDetachedAbortMarker(releaseMarkerPath, nonce, sessionId, sessionName, leaderPid) {
+    writeDetachedLeaderReport(`${releaseMarkerPath}.abort`, { version: 1, kind: "abort", nonce, sessionId, sessionName, leaderPid });
+}
+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;
     }
@@ -3352,19 +3914,123 @@ export function releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl
         }
     }
 }
-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);`;
+export const DETACHED_LAUNCH_CONTROL_PLANE_KEYS = [
+    "OMX_SESSION_ID",
+    "CODEX_SESSION_ID",
+    "SESSION_ID",
+    "OMX_TMUX_HUD_OWNER",
+    "OMX_TMUX_HUD_LEADER_PANE",
+    "OMX_ROOT",
+    "OMX_STATE_ROOT",
+    "OMX_TEAM_STATE_ROOT",
+    "OMXBOX_ACTIVE",
+    "OMX_SOURCE_CWD",
+    "OMX_MADMAX_DETACHED_CONTEXT",
+    "OMX_RUNS_DIR",
+    "OMX_TEAM_LEADER_CWD",
+    "OMX_TEAM_WORKER",
+    "OMX_TEAM_INTERNAL_WORKER",
+];
+const DETACHED_LAUNCH_CONTROL_PLANE_KEY_SET = new Set(DETACHED_LAUNCH_CONTROL_PLANE_KEYS);
+function isDetachedLaunchControlPlaneKey(key, caseInsensitive = false) {
+    return caseInsensitive
+        ? DETACHED_LAUNCH_CONTROL_PLANE_KEY_SET.has(key.toUpperCase())
+        : DETACHED_LAUNCH_CONTROL_PLANE_KEY_SET.has(key);
+}
+function emptyDetachedLaunchControlPlaneValues() {
+    return Object.fromEntries(DETACHED_LAUNCH_CONTROL_PLANE_KEYS.map((key) => [key, ""]));
+}
+function resolveDetachedRootValue(cwd, raw) {
+    return isCrossPlatformAbsolutePath(raw) ? raw : resolve(cwd, raw);
+}
+export function buildDetachedLaunchControlPlane(options) {
+    const env = options.env ?? process.env;
+    const values = emptyDetachedLaunchControlPlaneValues();
+    values.OMX_SESSION_ID = options.sessionId;
+    values.OMX_TMUX_HUD_OWNER = "1";
+    values.OMX_TMUX_HUD_LEADER_PANE = options.leaderPaneId ?? "";
+    const runtimeContext = options.runtimeContext;
+    const verifiedMadmaxContext = options.verifiedMadmaxContext;
+    if (runtimeContext && verifiedMadmaxContext) {
+        values.OMX_ROOT = verifiedMadmaxContext.root;
+        values.OMXBOX_ACTIVE = "1";
+        values.OMX_SOURCE_CWD = verifiedMadmaxContext.sourceCwd;
+        values.OMX_MADMAX_DETACHED_CONTEXT = verifiedMadmaxContext.context;
+        values.OMX_RUNS_DIR = verifiedMadmaxContext.runsRoot;
+    }
+    else {
+        const madmaxGuardPresent = env.OMXBOX_ACTIVE === "1";
+        const teamRoot = env.OMX_TEAM_STATE_ROOT?.trim();
+        const root = env.OMX_ROOT?.trim();
+        const stateRoot = env.OMX_STATE_ROOT?.trim();
+        const resolvedStateRoot = stateRoot ? resolveDetachedRootValue(options.cwd, stateRoot) : undefined;
+        const explicitOverrideWins = Boolean(options.omxRootOverride?.trim()
+            && !teamRoot
+            && !root
+            && (!resolvedStateRoot || resolveDetachedRootValue(options.cwd, options.omxRootOverride.trim()) !== resolvedStateRoot));
+        if (teamRoot)
+            values.OMX_TEAM_STATE_ROOT = resolveDetachedRootValue(options.cwd, teamRoot);
+        if (!madmaxGuardPresent) {
+            if (explicitOverrideWins)
+                values.OMX_ROOT = resolveDetachedRootValue(options.cwd, options.omxRootOverride.trim());
+            else if (!teamRoot && root)
+                values.OMX_ROOT = resolveDetachedRootValue(options.cwd, root);
+            else if (!teamRoot && stateRoot)
+                values.OMX_STATE_ROOT = resolvedStateRoot;
+            else if (!teamRoot && options.omxRootOverride?.trim())
+                values.OMX_ROOT = resolveDetachedRootValue(options.cwd, options.omxRootOverride.trim());
+        }
+        if (verifiedMadmaxContext) {
+            values.OMX_ROOT = verifiedMadmaxContext.root;
+            values.OMX_STATE_ROOT = "";
+            values.OMX_TEAM_STATE_ROOT = "";
+            values.OMXBOX_ACTIVE = "1";
+            values.OMX_SOURCE_CWD = verifiedMadmaxContext.sourceCwd;
+            values.OMX_MADMAX_DETACHED_CONTEXT = verifiedMadmaxContext.context;
+            values.OMX_RUNS_DIR = verifiedMadmaxContext.runsRoot;
+        }
+    }
+    const verifiedTeam = options.verifiedTeamContext;
+    if (verifiedTeam && !verifiedMadmaxContext) {
+        values.OMX_ROOT = "";
+        values.OMX_STATE_ROOT = "";
+        values.OMXBOX_ACTIVE = "";
+        values.OMX_SOURCE_CWD = "";
+        values.OMX_MADMAX_DETACHED_CONTEXT = "";
+        values.OMX_RUNS_DIR = "";
+        values.OMX_TEAM_STATE_ROOT = verifiedTeam.stateRoot;
+        values.OMX_TEAM_LEADER_CWD = verifiedTeam.leaderCwd;
+        values.OMX_TEAM_WORKER = verifiedTeam.worker;
+        values.OMX_TEAM_INTERNAL_WORKER = verifiedTeam.internalWorker;
+    }
+    return Object.freeze({
+        values: Object.freeze(values),
+        keys: DETACHED_LAUNCH_CONTROL_PLANE_KEYS,
+    });
 }
-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;`;
+export const resolveDetachedLaunchControlPlane = buildDetachedLaunchControlPlane;
+function detachedLaunchControlPlaneEnv(controlPlane) {
+    return Object.fromEntries(DETACHED_LAUNCH_CONTROL_PLANE_KEYS.map((key) => [key, controlPlane.values[key]]));
+}
+function applyLaunchOwnedControlPlane(controlPlane) {
+    const previous = new Map();
+    for (const key of DETACHED_LAUNCH_CONTROL_PLANE_KEYS) {
+        previous.set(key, process.env[key]);
+        const value = controlPlane.values[key];
+        if (value === "")
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    return () => {
+        for (const key of DETACHED_LAUNCH_CONTROL_PLANE_KEYS) {
+            const value = previous.get(key);
+            if (typeof value === "string")
+                process.env[key] = value;
+            else
+                delete process.env[key];
+        }
+    };
 }
 const SHELL_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DETACHED_SESSION_PANE_ENV_KEYS = new Set([
@@ -3376,21 +4042,23 @@ const DETACHED_SESSION_PANE_ENV_KEYS = new Set([
     "COLUMNS",
     "LINES",
 ]);
-export function serializeDetachedSessionParentEnv(env) {
-    const lines = [];
+function detachedSessionParentEnvironment(env, caseInsensitive = false) {
+    const values = {};
     for (const key of Object.keys(env).sort()) {
-        if (!SHELL_ENV_NAME_PATTERN.test(key))
-            continue;
-        if (DETACHED_SESSION_PANE_ENV_KEYS.has(key))
+        if (!SHELL_ENV_NAME_PATTERN.test(key)
+            || DETACHED_SESSION_PANE_ENV_KEYS.has(key)
+            || isDetachedLaunchControlPlaneKey(key, caseInsensitive))
             continue;
         const value = env[key];
-        if (typeof value !== "string")
-            continue;
-        if (value.includes("\0"))
-            continue;
-        lines.push(`export ${key}=${quoteShellArg(value)}`);
+        if (typeof value === "string" && !value.includes("\0"))
+            values[key] = value;
     }
-    return `${lines.join("\n")}\n`;
+    return values;
+}
+export function serializeDetachedSessionParentEnv(env) {
+    return `${Object.entries(detachedSessionParentEnvironment(env))
+        .map(([key, value]) => `export ${key}=${quoteShellArg(value)}`)
+        .join("\n")}\n`;
 }
 export function detachedSessionParentEnvFilePath(cwd, sessionId) {
     const safeSessionId = sessionId.replace(/[^A-Za-z0-9_.-]/g, "_");
@@ -3418,27 +4086,21 @@ export function withTmuxExtendedKeys(cwd, run, execFileSyncImpl = (file, tmuxArg
             releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl);
     }
 }
-export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, env = process.env, sqliteHomeOverride, parentEnvFilePath, inheritedWorkerModel) {
+export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, env = process.env, sqliteHomeOverride, parentEnvFilePath, inheritedWorkerModel, releaseMarkerPath, omxBin = process.argv[1], preLaunchOptions = {
+    enableNotifyFallbackAuthority: false,
+    worktreeDirty: false,
+    shouldAttach: true,
+}, controlPlane) {
     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;
+        ? buildDetachedWindowsLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, env, releaseMarkerPath, preLaunchOptions, omxBin)
+        : buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, parentEnvFilePath, releaseMarkerPath, preLaunchOptions, omxBin);
+    const launchControlPlane = controlPlane ?? buildDetachedLaunchControlPlane({
+        cwd,
+        sessionId: sessionId ?? "",
+        env,
+        omxRootOverride,
+    });
+    const controlPlaneEnv = detachedLaunchControlPlaneEnv(launchControlPlane);
     const newSessionArgs = [
         "new-session",
         "-d",
@@ -3449,15 +4111,10 @@ export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, h
         sessionName,
         "-c",
         cwd,
+        ...DETACHED_LAUNCH_CONTROL_PLANE_KEYS.flatMap((key) => ["-e", `${key}=${controlPlaneEnv[key]}`]),
         ...(workerLaunchArgs ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`] : []),
-        ...Object.entries(hudRuntimeEnv).map(([key, value]) => ["-e", `${key}=${value}`]).flat(),
         ...(codexHomeOverride ? ["-e", `CODEX_HOME=${codexHomeOverride}`] : []),
         ...(sqliteHomeOverride ? ["-e", `${CODEX_SQLITE_HOME_ENV}=${sqliteHomeOverride}`] : []),
-        ...(env.OMXBOX_ACTIVE ? ["-e", `OMXBOX_ACTIVE=${env.OMXBOX_ACTIVE}`] : []),
-        ...(env.OMX_SOURCE_CWD ? ["-e", `OMX_SOURCE_CWD=${env.OMX_SOURCE_CWD}`] : []),
-        ...(env[OMX_MADMAX_DETACHED_CONTEXT_ENV]
-            ? ["-e", `${OMX_MADMAX_DETACHED_CONTEXT_ENV}=${env[OMX_MADMAX_DETACHED_CONTEXT_ENV]}`]
-            : []),
         ...(notifyTempContractRaw
             ? ["-e", `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`]
             : []),
@@ -3717,41 +4374,40 @@ function isAutopilotReviewPendingPostLaunchState(state) {
 function postLaunchUniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
-async function scrubPostLaunchRootSkillActiveForSession(stateDir, sessionId, nowIso, writeFileFn, rootStateBeforeCleanup) {
+async function scrubPostLaunchRootSkillActiveForSession(stateDir, sessionId, nowIso, writeRootStateFn) {
     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;
+    await writeRootStateFn(stateDir, (rootState) => {
+        if (!rootState)
+            return null;
+        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 null;
+        if (keptEntries.length === entries.length && !rootBelongsToSession)
+            return null;
+        return {
+            ...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",
+        };
     });
-    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 {
@@ -3798,9 +4454,14 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
         ? [getStateDir(cwd, sessionId)]
         : [getBaseStateDir(cwd)];
     const rootStateDir = getBaseStateDir(cwd);
-    const rootSkillActiveStateBeforeCleanup = sessionId
-        ? await readSkillActiveState(getSkillActiveStatePathsForStateDir(rootStateDir).rootPath)
-        : null;
+    const writeRootState = dependencies.writeRootState ?? ((stateDir, update) => (updateRootSkillActiveStateForStateDir(stateDir, update)));
+    const writeModeState = async (stateDir, mode, path, state) => {
+        if (stateDir === rootStateDir && mode === SKILL_ACTIVE_STATE_MODE) {
+            await writeRootState(stateDir, () => state);
+            return;
+        }
+        await writeFile(path, JSON.stringify(state, null, 2));
+    };
     let preserveSkillActiveForReviewPendingAutopilot = false;
     for (const stateDir of scopedDirs) {
         const files = await readdir(stateDir).catch(() => []);
@@ -3812,7 +4473,7 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
             && isAutopilotReviewPendingPostLaunchState(autopilotPrecheck.state);
         preserveSkillActiveForReviewPendingAutopilot ||= preserveReviewPendingAutopilot;
         for (const file of files) {
-            if (!file.endsWith("-state.json") || file === "session.json")
+            if (!isModeStateFilename(file))
                 continue;
             const path = join(stateDir, file);
             const mode = file.slice(0, -"-state.json".length);
@@ -3821,9 +4482,10 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
                 if (result.kind === "recoverable") {
                     try {
                         const completedAt = now().toISOString();
-                        await writeFile(path, JSON.stringify(mode === SKILL_ACTIVE_STATE_MODE
+                        const recoveredState = mode === SKILL_ACTIVE_STATE_MODE
                             ? buildRecoveredPostLaunchSkillActiveState(completedAt)
-                            : buildRecoveredPostLaunchModeState(mode, completedAt), null, 2));
+                            : buildRecoveredPostLaunchModeState(mode, completedAt);
+                        await writeModeState(stateDir, mode, path, recoveredState);
                         if (isTrackedWorkflowMode(mode)) {
                             await syncCanonicalSkillStateForMode({
                                 cwd,
@@ -3856,12 +4518,12 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
                     : normalizeTerminalWorkflowState(result.state, { mode, nowIso: completedAt });
                 if (normalized.changed) {
                     result.state = normalized.state;
-                    await writeFile(path, JSON.stringify(result.state, null, 2));
+                    await writeModeState(stateDir, mode, path, result.state);
                 }
                 if (mode === "ralph") {
                     const completedAt = now().toISOString();
                     if (markRalphCompletionAuditBlockedForPostLaunch(result.state, cwd, completedAt)) {
-                        await writeFile(path, JSON.stringify(result.state, null, 2));
+                        await writeModeState(stateDir, mode, path, result.state);
                         await syncCanonicalSkillStateForMode({
                             cwd,
                             baseStateDir: rootStateDir,
@@ -3887,7 +4549,7 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
                     result.state.phase = "complete";
                     result.state.updated_at = completedAt;
                     result.state.active_skills = [];
-                    await writeFile(path, JSON.stringify(result.state, null, 2));
+                    await writeModeState(stateDir, mode, path, result.state);
                     continue;
                 }
                 result.state.active = false;
@@ -3898,7 +4560,7 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
                     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));
+                await writeModeState(stateDir, mode, path, result.state);
                 if (isTrackedWorkflowMode(mode)) {
                     await syncCanonicalSkillStateForMode({
                         cwd,
@@ -3920,7 +4582,7 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
     if (sessionId) {
         try {
             if (!preserveSkillActiveForReviewPendingAutopilot) {
-                await scrubPostLaunchRootSkillActiveForSession(rootStateDir, sessionId, now().toISOString(), writeFile, rootSkillActiveStateBeforeCleanup);
+                await scrubPostLaunchRootSkillActiveForSession(rootStateDir, sessionId, now().toISOString(), writeRootState);
             }
         }
         catch (err) {
@@ -3946,115 +4608,140 @@ export async function reapPostLaunchOrphanedMcpProcesses(dependencies = {}) {
         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. Establish the canonical session pointer
- * 3. Generate session-scoped launch artifacts and start best-effort helpers
- *
- * 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
+async function establishPreLaunchBinding(cwd, sessionId, metadata = {}) {
+    const pointerOptions = await resolvePreLaunchSessionPointerOptions();
+    const established = await establishLaunchSessionBinding(cwd, sessionId, { ...pointerOptions, ...metadata });
+    if (established.kind === "committed-released")
+        return { binding: established.binding, cleanup: established.cleanup };
+    const error = established.kind === "precommit-aborted" ? established.abort : established.error;
+    Object.assign(error, { establishmentCleanup: established.cleanup });
+    throw error;
+}
+async function failPreLaunchSetup(binding) {
+    const failures = [];
+    try {
+        await finalizeBoundOnce(binding, "setup-failure");
+    }
+    catch (error) {
+        failures.push(error);
+    }
+    finally {
+        try {
+            const close = await closeLaunchSessionBindingOnce(binding);
+            if (close.status === "failed")
+                failures.push(close.error ?? new Error("bound session close failed"));
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length > 0)
+        throw new AggregateError(failures, "preLaunch setup finalization failed");
+}
+async function completePreLaunchSetup(cwd, sessionId, notifyTempContract, codexHomeOverride, enableNotifyFallbackAuthority, worktreeDirty) {
+    const degraded = [];
     try {
         const cleanup = await cleanupLaunchOrphanedMcpProcesses();
-        if (cleanup.terminatedCount > 0) {
+        if (cleanup.terminatedCount > 0)
             console.log(`[omx] Reaped ${cleanup.terminatedCount} orphaned OMX MCP process(es) before launch.`);
-        }
-        if (cleanup.failedPids.length > 0) {
+        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
+    catch (error) {
+        degraded.push("orphan-reaping");
+        logCliOperationFailure(error);
+    }
+    let instructions;
+    try {
+        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.`
+            : "";
+        instructions = launchAppendix.trim().length > 0 ? `${overlay}\n\n${launchAppendix}${dirtyWorktreeGuidance}` : `${overlay}${dirtyWorktreeGuidance}`;
+    }
+    catch (error) {
+        return { kind: "failure", operation: "overlay", error };
+    }
+    try {
+        await writeSessionModelInstructionsFile(cwd, sessionId, instructions);
+    }
+    catch (error) {
+        return { kind: "failure", operation: "session-instructions", error };
+    }
+    try {
+        await resetSessionMetrics(cwd, sessionId);
+        tagCurrentTmuxSessionWithInstance(sessionId);
+    }
+    catch (error) {
+        return { kind: "failure", operation: "session-metrics", error };
     }
-    // 2. Establish the canonical pointer before any session-scoped launch artifact.
-    await writeSessionStart(cwd, sessionId, await resolvePreLaunchSessionPointerOptions());
-    // 3. 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);
-    // 4. Reset session metrics and tag the established session.
-    await resetSessionMetrics(cwd, sessionId);
-    tagCurrentTmuxSessionWithInstance(sessionId);
-    // 5. Start notify fallback watcher (best effort)
     try {
         await startNotifyFallbackWatcher(cwd, { codexHomeOverride, enableAuthority: enableNotifyFallbackAuthority, sessionId });
     }
-    catch (err) {
-        logCliOperationFailure(err);
-        // Non-fatal
+    catch (error) {
+        degraded.push("notify-watcher");
+        logCliOperationFailure(error);
     }
-    // 6. Start derived watcher (best effort, opt-in)
     try {
         await startHookDerivedWatcher(cwd);
     }
-    catch (err) {
-        logCliOperationFailure(err);
-        // Non-fatal
+    catch (error) {
+        degraded.push("derived-watcher");
+        logCliOperationFailure(error);
     }
-    // 7. 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);
+            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) {
+            const startup = buildNotifyTempStartupMessages(notifyTempContract, Boolean(getNotificationConfig()?.enabled));
+            for (const info of startup.infoLines)
                 console.log(`[omx] ${info}`);
-            }
-            for (const warning of startup.warningLines) {
+            for (const warning of startup.warningLines)
                 console.warn(`[omx] ${warning}`);
-            }
         }
-        else {
+        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),
-        });
+        await notifyLifecycle("session-start", { sessionId, projectPath: cwd, projectName: basename(cwd) });
     }
-    catch (err) {
-        logCliOperationFailure(err);
-        // Non-fatal: notification failures must never block launch
+    catch (error) {
+        degraded.push("notification");
+        logCliOperationFailure(error);
     }
-    // 8. 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",
-            }),
-        });
+        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
+    catch (error) {
+        degraded.push("native-lifecycle-event");
+        logCliOperationFailure(error);
+    }
+    return degraded.length === 0 ? { kind: "success" } : { kind: "degraded-success", operations: degraded };
+}
+export async function preLaunch(cwd, sessionId, notifyTempContract, codexHomeOverride, enableNotifyFallbackAuthority = false, worktreeDirty = false) {
+    const established = await establishPreLaunchBinding(cwd, sessionId);
+    const completion = {
+        ...await completePreLaunchSetup(cwd, sessionId, notifyTempContract, codexHomeOverride, enableNotifyFallbackAuthority, worktreeDirty),
+        establishmentCleanup: established.cleanup,
+    };
+    if (completion.kind === "failure") {
+        try {
+            await failPreLaunchSetup(established.binding);
+        }
+        catch (cleanupError) {
+            throw new AggregateError([completion.error, cleanupError], `preLaunch ${completion.operation} failed`);
+        }
+        throw completion.error;
     }
+    return { binding: established.binding, completion };
 }
 /**
  * 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, runtimeContext) {
+async function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, sqliteHomeOverride, notifyTempContractRaw, preLaunchOptions, launchPolicy = "direct", detachedPreflight, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, runtimeContext, verifiedMadmaxContext, launchControlPlane) {
+    void preLaunchOptions;
     const launchArgs = injectModelInstructionsBypassArgs(cwd, args, process.env, sessionModelInstructionsPath(cwd, sessionId));
     const nativeWindows = isNativeWindows();
     const omxBin = resolveOmxCliEntryPath({ argv1: process.argv[1], cwd, env: process.env });
@@ -4062,19 +4749,59 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
         throw new Error("Unable to resolve OMX launcher path for tmux HUD bootstrap");
     }
     const runtimeEnvOverlay = buildMadmaxWorktreeRuntimeEnvOverlay(runtimeContext);
+    let verifiedTeamContext;
+    if (launchPolicy === "detached-tmux") {
+        try {
+            verifiedTeamContext = await resolveVerifiedDetachedTeamContext(cwd, process.env);
+        }
+        catch {
+            verifiedTeamContext = undefined;
+        }
+    }
+    const verifiedMadmaxContextForLaunch = verifiedMadmaxContext ?? (runtimeContext?.madmaxDetachedContext
+        ? {
+            root: runtimeContext.omxRoot,
+            sourceCwd: runtimeContext.sourceCwd,
+            context: runtimeContext.madmaxDetachedContext,
+            runsRoot: resolveMadmaxRunsRoot(process.env),
+        }
+        : resolveVerifiedMadmaxDetachedContext(cwd, launchArgs, process.env));
+    const detachedControlPlane = launchPolicy === "detached-tmux"
+        ? buildDetachedLaunchControlPlane({
+            cwd,
+            sessionId,
+            env: process.env,
+            omxRootOverride: runtimeContext?.omxRoot ?? resolveOmxRootForLaunch(cwd, process.env),
+            runtimeContext,
+            verifiedMadmaxContext: verifiedMadmaxContextForLaunch,
+            verifiedTeamContext,
+        })
+        : undefined;
+    const launchOwnedControlPlane = detachedControlPlane ?? launchControlPlane;
+    const launchOwnedControlPlaneEnv = launchOwnedControlPlane
+        ? detachedLaunchControlPlaneEnv(launchOwnedControlPlane)
+        : {};
+    const detachedSelectedStateEnv = detachedControlPlane
+        ? { ...process.env, ...detachedLaunchControlPlaneEnv(detachedControlPlane) }
+        : undefined;
     const omxRootOverride = runtimeContext?.omxRoot ?? resolveOmxRootForLaunch(cwd, process.env);
+    const selectedOmxRootOverride = launchOwnedControlPlane
+        ? launchOwnedControlPlane.values.OMX_ROOT || undefined
+        : omxRootOverride;
     const currentPaneId = process.env.TMUX_PANE;
     const hudRuntimeRoot = runtimeContext
         ? { omxRoot: runtimeContext.omxRoot, rootSource: 'omx-root-env' }
         : resolveHudRuntimeRootForLaunch(cwd, process.env);
-    const hudRuntimeEnv = {
-        ...buildHudRuntimeEnv({
-            sessionId,
-            leaderPaneId: currentPaneId,
-            ...hudRuntimeRoot,
-        }).env,
-        ...runtimeEnvOverlay,
-    };
+    const hudRuntimeEnv = launchOwnedControlPlane
+        ? Object.fromEntries(Object.entries(launchOwnedControlPlaneEnv))
+        : {
+            ...buildHudRuntimeEnv({
+                sessionId,
+                leaderPaneId: currentPaneId,
+                ...hudRuntimeRoot,
+            }).env,
+            ...runtimeEnvOverlay,
+        };
     const hudEnvArgs = Object.entries(hudRuntimeEnv).map(([key, value]) => `${key}=${value}`);
     const hudCmd = nativeWindows
         ? buildWindowsPromptCommand("node", [omxBin, "hud", "--watch"])
@@ -4089,13 +4816,17 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
         ...stripHermesMcpBridgeEnv(process.env),
         ...(codexHomeOverride ? { CODEX_HOME: codexHomeOverride } : {}),
         ...(sqliteHomeOverride ? { [CODEX_SQLITE_HOME_ENV]: sqliteHomeOverride } : {}),
-        ...(omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
+        ...(!launchOwnedControlPlane && omxRootOverride ? { OMX_ROOT: omxRootOverride } : {}),
         ...runtimeEnvOverlay,
+        ...launchOwnedControlPlaneEnv,
     }, omxBin);
+    // Correlates plugin hook routing only; it is not an authority token.
+    const pluginHookRoutingLaunchId = randomUUID();
     const codexEnvWithSession = {
         ...codexBaseEnv,
-        OMX_CODEX_LAUNCH_ID: randomUUID(),
+        OMX_CODEX_LAUNCH_ID: pluginHookRoutingLaunchId,
         ...buildHudRuntimeEnv({ sessionId }).env,
+        ...launchOwnedControlPlaneEnv,
     };
     const codexEnv = workerLaunchArgs
         ? {
@@ -4107,8 +4838,9 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
     const codexEnvWithNotify = notifyTempContractRaw
         ? { ...codexEnv, [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw }
         : codexEnv;
-    const runtimeHookEnv = { ...process.env, ...runtimeEnvOverlay };
-    const { launchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows);
+    const runtimeHookEnv = launchOwnedControlPlane
+        ? { ...process.env, ...runtimeEnvOverlay, ...launchOwnedControlPlaneEnv }
+        : { ...process.env, ...runtimeEnvOverlay };
     if (isCodexVersionRequest(launchArgs)) {
         runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
         return { postLaunchHandledExternally: false };
@@ -4144,7 +4876,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                     currentPaneId,
                     cwd,
                     sessionId,
-                    omxRootOverride,
+                    omxRootOverride: selectedOmxRootOverride,
                     baseEnv: runtimeHookEnv,
                 });
             }
@@ -4171,7 +4903,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
                     currentPaneId,
                     cwd,
                     sessionId,
-                    omxRootOverride,
+                    omxRootOverride: selectedOmxRootOverride,
                     baseEnv: runtimeHookEnv,
                 });
             }
@@ -4232,214 +4964,247 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, s
         return { postLaunchHandledExternally: false };
     }
     else {
-        // Not in tmux: create a new tmux session with codex + HUD pane
+        if (!detachedPreflight) {
+            throw new DetachedLaunchSafetyError("establishment", new Error("detached launch requires a frozen available preflight"), { transitions: ["D0"], rollback: { attempted: [], failures: [] } });
+        }
         const codexCmd = buildTmuxPaneCommand("codex", launchArgs);
         const detachedWindowsCodexCmd = nativeWindows
-            ? buildWindowsPromptCommand("codex", launchArgs)
+            ? buildWindowsDetachedChildCommand("codex", launchArgs)
             : null;
         const sessionName = buildDetachedTmuxSessionName(cwd, sessionId);
-        const launchDetachedSession = () => {
-            const contextKey = runtimeContext?.madmaxDetachedContext ?? 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) {
+        const contextKey = detachedControlPlane?.values.OMX_MADMAX_DETACHED_CONTEXT.trim() || undefined;
+        const runsRoot = detachedControlPlane?.values.OMX_RUNS_DIR || resolveMadmaxRunsRoot(process.env);
+        const detachedLaunchNonce = randomUUID();
+        const releaseMarkerPath = join(omxRoot(cwd), "runtime", "detached-release", `${sessionId}.${detachedLaunchNonce}.release`);
+        let detachedParentEnvFilePath;
+        let detachedLeaderPaneId = null;
+        let detachedLeaderAuthority = null;
+        let detachedHudAuthority = null;
+        let detachedLeaderPid = null;
+        let rollbackFromPreReportAuthority = false;
+        let attachStep = null;
+        const launchDetachedSession = async () => {
+            let createdSession = false;
+            const bootstrapLeader = async () => {
+                if (!nativeWindows)
                     detachedParentEnvFilePath = writeDetachedSessionParentEnvFile(cwd, sessionId, codexEnvWithNotify);
-                }
-                const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, runtimeHookEnv, sqliteHomeOverride, detachedParentEnvFilePath, inheritedWorkerModel);
+                const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, nativeWindows && detachedWindowsCodexCmd ? detachedWindowsCodexCmd : codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, omxRootOverride, codexEnvWithNotify, sqliteHomeOverride, detachedParentEnvFilePath, inheritedWorkerModel, releaseMarkerPath, omxBin, {
+                    ...(preLaunchOptions.notifyTempContract.active ? { notifyTempContract: preLaunchOptions.notifyTempContract } : {}),
+                    enableNotifyFallbackAuthority: preLaunchOptions.enableNotifyFallbackAuthority,
+                    worktreeDirty: preLaunchOptions.worktreeDirty,
+                    shouldAttach: detachedPreflight.shouldAttach,
+                }, detachedControlPlane);
                 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) {
+                    try {
+                        if (step.name === "new-session") {
+                            const output = execTmuxFileSync(step.args, { stdio: "pipe", encoding: "utf-8" });
+                            createdSession = true;
+                            const leaderPaneId = parsePaneIdFromTmuxOutput(output || "");
+                            if (!leaderPaneId)
+                                throw new Error("detached session did not report a leader pane id");
                             detachedLeaderPaneId = leaderPaneId;
-                            setDetachedTmuxSessionHistoryLimit(sessionName, leaderPaneId);
-                            if (activeRecordPath && contextKey) {
-                                writeMadmaxDetachedActiveRecord(activeRecordPath, {
-                                    version: 1,
-                                    context_key: contextKey,
-                                    created_at: new Date().toISOString(),
-                                    source_cwd: runtimeContext?.sourceCwd ?? process.env.OMX_SOURCE_CWD ?? cwd,
-                                    ...(runtimeContext?.worktreeCwd ? { worktree_cwd: runtimeContext.worktreeCwd } : {}),
-                                    argv: args,
-                                    run_dir: runtimeContext?.omxRoot ?? process.env.OMX_ROOT ?? cwd,
-                                    tmux_session_name: sessionName,
-                                    session_id: sessionId,
-                                    tmux_pane_id: leaderPaneId,
-                                });
-                            }
-                            writeDetachedSessionBinding(leaderPaneId);
+                            detachedLeaderAuthority = captureDetachedLeaderAuthority(leaderPaneId, sessionName, sessionId);
+                            continue;
                         }
-                    }
-                    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);
+                        const authority = detachedLeaderAuthority;
+                        if (!authority)
+                            throw new Error("detached leader authority missing before tmux mutation");
+                        if (step.name === "tag-session") {
+                            runDetachedLeaderMutation(authority, step.args, false);
+                            runDetachedLeaderMutation(authority, ["set-option", "-q", "-t", authority.sessionName, "history-limit", String(DETACHED_TMUX_HISTORY_LIMIT)]);
+                            runDetachedLeaderMutation(authority, ["set-option", "-pq", "-t", authority.paneId, "history-limit", String(DETACHED_TMUX_HISTORY_LIMIT)]);
+                            // #3266: the owned leader pane must close with its process so a normal
+                            // child exit destroys the session naturally even when the user's tmux
+                            // config inherits remain-on-exit=on/failed.
+                            runDetachedLeaderMutation(authority, ["set-option", "-pq", "-t", authority.paneId, "remain-on-exit", "off"]);
+                            continue;
                         }
-                        for (const finalizeStep of finalizeSteps) {
-                            if (finalizeStep.name === "sanitize-copy-mode-style") {
-                                try {
-                                    mitigateCopyModeUnderlineArtifacts(sessionName);
-                                }
-                                catch (err) {
-                                    logCliOperationFailure(err);
-                                }
+                        if (step.name !== "split-and-capture-hud-pane") {
+                            throw new Error(`unexpected detached bootstrap mutation: ${step.name}`);
+                        }
+                        detachedHudAuthority = runDetachedLeaderSplit(authority, step.args);
+                        tagDetachedHudPane(authority, detachedHudAuthority, sessionId);
+                        for (const finalizeStep of buildDetachedSessionFinalizeSteps(authority.sessionName, detachedHudAuthority.paneId, authority.windowIndex, process.env.OMX_MOUSE !== "0", nativeWindows, detachedPreflight.shouldAttach, authority.paneId)) {
+                            if (finalizeStep.name === "attach-session") {
+                                attachStep = finalizeStep;
                                 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");
+                            if (finalizeStep.name === "sanitize-copy-mode-style")
                                 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,
-                                    baseEnv: runtimeHookEnv,
-                                });
-                            }
+                            const targetsHudPane = new Set([
+                                "register-resize-hook",
+                                "register-client-attached-reconcile",
+                                "schedule-delayed-resize",
+                                "reconcile-hud-resize",
+                            ]).has(finalizeStep.name);
+                            if (targetsHudPane)
+                                runDetachedHudMutation(authority, detachedHudAuthority, guardDetachedHudDeferredMutation(authority, detachedHudAuthority, finalizeStep.args));
+                            else
+                                runDetachedLeaderMutation(authority, finalizeStep.args);
                         }
                     }
+                    catch (error) {
+                        throw new DetachedLaunchSafetyError(step.name === "new-session" ? "inert-session" : "pane-id", error, detachedPreflight.report);
+                    }
                 }
-                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) {
+                return undefined;
+            };
+            const launchTerminal = await executeDetachedLaunchStateMachine({ preflight: detachedPreflight }, {
+                establish: bootstrapLeader,
+                complete: async () => {
+                    const readyDeadline = Date.now() + DETACHED_LEADER_READY_TIMEOUT_MS;
+                    while (true) {
+                        const report = readDetachedLeaderReport(releaseMarkerPath);
+                        if (isDetachedReadyReportAuthorized(report, {
+                            nonce: detachedLaunchNonce,
+                            sessionId,
+                            sessionName,
+                            shouldAttach: detachedPreflight.shouldAttach,
+                            leaderPaneId: detachedLeaderPaneId,
+                            leaderPanePid: detachedLeaderAuthority?.panePid ?? null,
+                        })) {
+                            detachedLeaderPid = report.leaderPid;
+                            return { kind: "success" };
+                        }
+                        if (report?.nonce === detachedLaunchNonce && report.sessionId === sessionId && report.sessionName === sessionName && report.leaderPid && report.kind === "failed") {
+                            detachedLeaderPid = report.leaderPid;
+                            return { kind: "failure", operation: "session-instructions", error: new Error(report.error || "detached leader setup failed") };
+                        }
+                        if (Date.now() >= readyDeadline)
+                            return { kind: "failure", operation: "session-instructions", error: new Error("detached leader readiness timed out") };
+                        blockMs(20);
+                    }
+                },
+                createInertSession: async () => {
+                    const report = readDetachedLeaderReport(releaseMarkerPath);
+                    if (report?.kind !== "ready" || report.nonce !== detachedLaunchNonce || report.sessionId !== sessionId || report.sessionName !== sessionName || report.leaderPid !== detachedLeaderPid) {
+                        throw new Error("detached ready report does not bind the inert session");
+                    }
+                    return sessionName;
+                },
+                capturePane: async () => {
+                    const report = readDetachedLeaderReport(releaseMarkerPath);
+                    if (!detachedLeaderPaneId || report?.kind !== "ready" || report.paneId !== detachedLeaderPaneId || report.leaderPid !== detachedLeaderPid) {
+                        throw new Error("detached ready report does not bind the leader pane");
+                    }
+                    return detachedLeaderPaneId;
+                },
+                updateNameMetadata: async () => {
+                    const state = await readSessionState(cwd, detachedSelectedStateEnv);
+                    if (state?.session_id !== sessionId || state.tmux_session_name !== sessionName) {
+                        throw new Error("detached session-name metadata was not committed by the leader");
+                    }
+                    return "committed-released";
+                },
+                updatePaneMetadata: async (_binding, pane) => {
+                    const state = await readSessionState(cwd, detachedSelectedStateEnv);
+                    if (state?.session_id !== sessionId || state.tmux_pane_id !== pane) {
+                        throw new Error("detached pane metadata was not committed by the leader");
+                    }
+                    return "committed-released";
+                },
+                publishActiveRecord: async () => {
+                    const activeRecordPath = contextKey ? madmaxDetachedActiveRecordPath(runsRoot, contextKey) : join(omxRoot(cwd), "state", "detached-active-record.json");
+                    const record = readMadmaxDetachedActiveRecord(activeRecordPath);
+                    if (!record || record.launch_nonce !== detachedLaunchNonce || record.leader_pid !== detachedLeaderPid || record.session_id !== sessionId || record.tmux_session_name !== sessionName || record.tmux_pane_id !== detachedLeaderPaneId)
+                        throw new Error("detached active record does not bind the ready leader");
+                    const bytes = readFileSync(activeRecordPath, "utf-8");
+                    return { bytes, digest: createHash("sha256").update(bytes).digest("hex"), nonce: detachedLaunchNonce };
+                },
+                finalizeSetupFailure: async () => { },
+                releaseBarrier: async () => {
+                    if (!detachedLeaderPid)
+                        throw new Error("detached leader PID missing before release");
+                    publishDetachedReleaseMarker(releaseMarkerPath, detachedLaunchNonce, sessionId, sessionName, detachedLeaderPid, detachedHudAuthority ?? undefined);
+                },
+                abortAndAwaitFinalization: async () => {
+                    // The leader has the retained binding. Publishing abort is the only
+                    // outer action permitted after a D9 write failure; a mismatched or
+                    // missing report leaves every artifact and the tmux session intact.
+                    if (!detachedLeaderPid) {
+                        rollbackFromPreReportAuthority = detachedLeaderAuthority !== null;
+                        return { acknowledged: false, rollbackAuthorized: rollbackFromPreReportAuthority };
+                    }
+                    const current = readDetachedLeaderReport(releaseMarkerPath);
+                    if (current?.nonce === detachedLaunchNonce && current.sessionId === sessionId &&
+                        current.sessionName === sessionName && current.leaderPid === detachedLeaderPid &&
+                        current.finalized === true && (current.kind === "failed" || current.kind === "terminal"))
+                        return {
+                            acknowledged: true,
+                            nonce: current.nonce,
+                            sessionId: current.sessionId,
+                            sessionName: current.sessionName,
+                            leaderPid: current.leaderPid,
+                            kind: current.kind,
+                        };
+                    publishDetachedAbortMarker(releaseMarkerPath, detachedLaunchNonce, sessionId, sessionName, detachedLeaderPid);
+                    const deadline = Date.now() + 30_000;
+                    while (Date.now() < deadline) {
+                        const report = readDetachedLeaderReport(releaseMarkerPath);
+                        if (report?.nonce === detachedLaunchNonce && report.sessionId === sessionId &&
+                            report.sessionName === sessionName && report.leaderPid === detachedLeaderPid &&
+                            report.finalized === true && (report.kind === "failed" || report.kind === "terminal"))
+                            return {
+                                acknowledged: true,
+                                nonce: report.nonce,
+                                sessionId: report.sessionId,
+                                sessionName: report.sessionName,
+                                leaderPid: report.leaderPid,
+                                kind: report.kind,
+                            };
+                        blockMs(20);
+                    }
+                    return { acknowledged: false };
+                },
+                attachOrReturn: async () => { if (attachStep)
+                    execTmuxFileSync(attachStep.args, { stdio: "inherit" }); },
+                rollback: async (_ownedRecord, report) => {
+                    const attempt = async (step, operation) => {
+                        report.rollback.attempted.push(step);
                         try {
-                            execTmuxFileSync(rollbackStep.args, { stdio: "ignore" });
+                            await operation();
                         }
-                        catch (rollbackErr) {
-                            logCliOperationFailure(rollbackErr);
-                            // best-effort rollback only
+                        catch (error) {
+                            report.rollback.failures.push({ step, status: "failed", code: detachedFailureCode(error) });
+                        }
+                    };
+                    await attempt("parent-env", async () => { if (detachedParentEnvFilePath)
+                        await rm(detachedParentEnvFilePath, { force: true }); });
+                    await attempt("runtime-codex-home", () => cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup));
+                    await attempt("rollback", () => { rmSync(releaseMarkerPath, { force: true }); rmSync(`${releaseMarkerPath}.release`, { force: true }); rmSync(`${releaseMarkerPath}.abort`, { force: true }); });
+                    if (createdSession) {
+                        for (const step of buildDetachedSessionRollbackSteps(sessionName, null, null, null)) {
+                            await attempt(`session:${step.name}`, () => {
+                                if (!detachedLeaderAuthority)
+                                    throw new Error("detached leader authority missing before rollback");
+                                if (rollbackFromPreReportAuthority && step.name === "kill-session") {
+                                    cleanupDetachedPreReportSession(detachedLeaderAuthority);
+                                    return;
+                                }
+                                runDetachedLeaderMutation(detachedLeaderAuthority, step.args);
+                            });
                         }
                     }
+                },
+            });
+            if (launchTerminal.kind === "attached" && detachedLeaderPid) {
+                // #3266: propagate the finalized detached child's exit status to the invoking shell.
+                // A rejected status protocol is only benign when the exact owned session
+                // provably survives (manual detach); a destroyed or ambiguous session with
+                // no authenticated finalized status is a protocol failure, never silent success.
+                const attachResolution = resolveDetachedAttachExitStatus(releaseMarkerPath, { nonce: detachedLaunchNonce, sessionId, sessionName, leaderPid: detachedLeaderPid }, { exactSessionExists: () => probeExactDetachedSessionExists(detachedLeaderAuthority) });
+                if (attachResolution === "protocol-failure") {
+                    process.stderr.write("[omx] detached session ended without an authenticated finalized terminal status; treating the launch as failed.\n");
+                    if (!process.exitCode)
+                        process.exitCode = 1;
                 }
-                throw err;
             }
+            return { postLaunchHandledExternally: true };
         };
-        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 };
+        if (contextKey) {
+            return await withMadmaxDetachedContextLock(runsRoot, contextKey, launchDetachedSession);
         }
+        return await launchDetachedSession();
     }
 }
 function listHudWatchPaneIdsInCurrentWindow(currentPaneId, owner = {}) {
@@ -4486,7 +5251,24 @@ export function isCodexVersionRequest(args) {
     const { omxArgs } = splitOmxArgsAtEndOfOptions(args);
     return omxArgs.some((arg) => CODEX_VERSION_FLAGS.has(arg));
 }
-export function buildWindowsPromptCommand(command, args) {
+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)}`;
+}
+/**
+ * Build a Windows child command for detached ownership. Unlike the interactive
+ * prompt wrapper, this process exits as soon as Codex does so the outer barrier
+ * can run its post-launch cleanup.
+ */
+export function buildWindowsDetachedChildCommand(command, args) {
     const invocation = [
         "&",
         quotePowerShellArg(command),
@@ -4494,9 +5276,10 @@ export function buildWindowsPromptCommand(command, args) {
     ].join(" ");
     const wrappedCommand = [
         "$ErrorActionPreference = 'Stop'",
-        `& { ${invocation} }`,
+        invocation,
+        "exit $LASTEXITCODE",
     ].join("; ");
-    return `powershell.exe -NoLogo -NoExit -EncodedCommand ${encodePowerShellCommand(wrappedCommand)}`;
+    return `powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ${encodePowerShellCommand(wrappedCommand)}`;
 }
 /**
  * Wrap a command for tmux pane execution while preserving the tmux pane cwd.
@@ -4534,45 +5317,323 @@ function quoteShellArg(value) {
 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("");
+export function decodeDetachedLeaderPayload(encoded) {
+    if (!encoded || !/^[A-Za-z0-9_-]+$/.test(encoded))
+        throw new Error("invalid detached leader payload");
+    let value;
+    try {
+        value = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("invalid detached leader payload");
+    }
+    if (!value || typeof value !== "object")
+        throw new Error("invalid detached leader payload");
+    const payload = value;
+    const options = payload.preLaunchOptions;
+    if (typeof payload.cwd !== "string" || typeof payload.sessionName !== "string" || typeof payload.sessionId !== "string" ||
+        typeof payload.codexCmd !== "string" || !options || typeof options !== "object" ||
+        typeof options.enableNotifyFallbackAuthority !== "boolean" ||
+        typeof options.worktreeDirty !== "boolean" ||
+        typeof options.shouldAttach !== "boolean")
+        throw new Error("invalid detached leader payload");
+    const notifyTempContract = options.notifyTempContract;
+    if (notifyTempContract !== undefined && (!notifyTempContract || typeof notifyTempContract !== "object"))
+        throw new Error("invalid detached leader payload");
+    const parentEnv = payload.parentEnv;
+    if (parentEnv !== undefined && (!parentEnv || typeof parentEnv !== "object" ||
+        Object.entries(parentEnv).some(([key, value]) => !SHELL_ENV_NAME_PATTERN.test(key) || DETACHED_SESSION_PANE_ENV_KEYS.has(key) || typeof value !== "string" || value.includes("\0")))) {
+        throw new Error("invalid detached leader parent environment");
+    }
+    return {
+        cwd: payload.cwd, sessionName: payload.sessionName, sessionId: payload.sessionId, codexCmd: payload.codexCmd,
+        ...(typeof payload.codexHomeOverride === "string" ? { codexHomeOverride: payload.codexHomeOverride } : {}),
+        ...(typeof payload.projectLocalCodexHomeForCleanup === "string" ? { projectLocalCodexHomeForCleanup: payload.projectLocalCodexHomeForCleanup } : {}),
+        ...(typeof payload.runtimeCodexHomeForCleanup === "string" ? { runtimeCodexHomeForCleanup: payload.runtimeCodexHomeForCleanup } : {}),
+        ...(parentEnv ? { parentEnv: parentEnv } : {}),
+        ...(typeof payload.readyPath === "string" ? { readyPath: payload.readyPath } : {}),
+        preLaunchOptions: {
+            ...(notifyTempContract ? { notifyTempContract: notifyTempContract } : {}),
+            enableNotifyFallbackAuthority: options.enableNotifyFallbackAuthority,
+            worktreeDirty: options.worktreeDirty,
+            shouldAttach: options.shouldAttach,
+        },
+    };
 }
-function scheduleDetachedWindowsCodexLaunch(sessionName, commandText) {
-    const child = spawn(process.execPath, ["-e", buildDetachedWindowsBootstrapScript(sessionName, commandText)], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
+function parseDetachedHudAuthorityProof(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const proof = value;
+    if (typeof proof.paneId !== "string" || !/^%[0-9]+$/.test(proof.paneId))
+        return undefined;
+    if (typeof proof.panePid !== "number" || !Number.isSafeInteger(proof.panePid) || proof.panePid <= 0)
+        return undefined;
+    if (typeof proof.sessionId !== "string" || !/^\$[0-9]+$/.test(proof.sessionId))
+        return undefined;
+    if (typeof proof.windowId !== "string" || !/^@[0-9]+$/.test(proof.windowId))
+        return undefined;
+    if (typeof proof.operationMarker !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(proof.operationMarker))
+        return undefined;
+    return { paneId: proof.paneId, panePid: proof.panePid, sessionId: proof.sessionId, windowId: proof.windowId, operationMarker: proof.operationMarker };
+}
+function teardownDetachedOwnedHudPane(leaderPaneId, payload, hudProof) {
+    // #3266: on a normal child exit, kill exactly the bootstrap-proven OMX HUD pane so
+    // the leader pane becomes the last live pane and the owned session closes naturally,
+    // returning the attached client to its shell. Fail-closed: any doubt means zero mutations.
+    // Contract: only the proven HUD is removed. A pane the user added to the detached
+    // session is deliberately preserved, which intentionally keeps that session (and any
+    // attached client) alive; natural closure and shell return happen only when no other
+    // panes remain.
+    const discovered = discoverDetachedHudAuthority(payload.sessionName, payload.sessionId);
+    const proof = discovered ?? hudProof;
+    if (!proof)
+        return;
+    try {
+        cleanupDetachedHudPane(proof, discovered ? payload.sessionId : undefined);
+        execTmuxFileSync(["kill-pane", "-t", leaderPaneId], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch (error) {
+        traceDetachedLeaderPhase(`hud-teardown-error:${describeDetachedLeaderFailure(error)}`);
+        logCliOperationFailure(error);
+    }
+}
+function traceDetachedLeaderPhase(phase) {
+    if (process.env.OMX_TEST_DETACHED_TRACE !== "1")
+        return;
+    const line = `[omx-test-detached] ${phase}\n`;
+    process.stderr.write(line);
+    const tracePath = process.env.OMX_TEST_DETACHED_TRACE_PATH;
+    if (tracePath)
+        appendFileSync(tracePath, line);
+}
+async function runDetachedSessionLeader(payload) {
+    for (const [key, value] of Object.entries(payload.parentEnv ?? {})) {
+        if (isDetachedLaunchControlPlaneKey(key, process.platform === "win32"))
+            continue;
+        process.env[key] = value;
+    }
+    let pane;
+    const inheritedPane = process.env.TMUX_PANE?.trim();
+    if (payload.preLaunchOptions.shouldAttach === false) {
+        if (!inheritedPane || !/^%[0-9]+$/.test(inheritedPane)) {
+            throw new Error("detached Hermes leader has no tmux pane identity");
+        }
+        pane = inheritedPane;
+    }
+    else {
+        const paneSnapshot = execTmuxFileSync(["list-panes", "-t", payload.sessionName, "-F", "#{pane_id}\t#{pane_dead}\t#{pane_pid}"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+        pane = parseDetachedLeaderPaneIdByPid(paneSnapshot, process.pid);
+    }
+    process.env.TMUX_PANE = pane;
+    const established = await establishPreLaunchBinding(payload.cwd, payload.sessionId, {
+        tmuxSessionName: payload.sessionName,
+        tmuxPaneId: pane,
     });
-    child.unref();
+    const binding = established.binding;
+    let ownedRecord;
+    let detachedHudProof;
+    const nonce = payload.readyPath?.split(".").at(-2) || payload.sessionId;
+    const contextKey = process.env[OMX_MADMAX_DETACHED_CONTEXT_ENV]?.trim();
+    const activeRecordPath = contextKey
+        ? madmaxDetachedActiveRecordPath(resolveMadmaxRunsRoot(process.env), contextKey)
+        : join(omxRoot(payload.cwd), "state", "detached-active-record.json");
+    let externalInterrupt;
+    try {
+        const completion = await completePreLaunchSetup(payload.cwd, payload.sessionId, payload.preLaunchOptions.notifyTempContract, payload.codexHomeOverride, payload.preLaunchOptions.enableNotifyFallbackAuthority, payload.preLaunchOptions.worktreeDirty);
+        if (completion.kind === "failure") {
+            const finalization = await finalizeBoundOnce(binding, "setup-failure", payload.cwd);
+            if (!finalization.finalized)
+                throw new Error(`bound setup finalization denied: ${finalization.cleanup.comparison?.reason ?? "unknown reason"}`);
+            throw completion.error;
+        }
+        const record = {
+            version: 1, context_key: contextKey ?? payload.sessionId, created_at: new Date().toISOString(),
+            source_cwd: payload.cwd, argv: [payload.codexCmd], run_dir: process.env.OMX_ROOT ?? payload.cwd,
+            tmux_session_name: payload.sessionName, session_id: payload.sessionId, tmux_pane_id: pane,
+            launch_nonce: nonce, leader_pid: process.pid, base_state_root: binding.context.baseStateDir,
+            lifecycle_phase: "ready",
+        };
+        const runtimeBinding = queryMadmaxDetachedRuntimeBinding(record);
+        ownedRecord = writeMadmaxDetachedActiveRecord(activeRecordPath, {
+            ...record,
+            ...(runtimeBinding ? {
+                tmux_internal_session_id: runtimeBinding.internalSessionId,
+                tmux_session_created: runtimeBinding.sessionCreated,
+                tmux_pane_pid: runtimeBinding.panePid,
+            } : {}),
+        });
+        if (payload.readyPath) {
+            writeDetachedLeaderReport(payload.readyPath, { version: 1, kind: "ready", nonce, sessionId: payload.sessionId, sessionName: payload.sessionName, paneId: pane, leaderPid: process.pid });
+            const releasePath = `${payload.readyPath}.release`;
+            const abortPath = `${payload.readyPath}.abort`;
+            const releaseDeadline = Date.now() + 30_000;
+            let interrupted;
+            const interrupt = (signal) => { interrupted = signal; };
+            process.once("SIGINT", () => interrupt("SIGINT"));
+            process.once("SIGTERM", () => interrupt("SIGTERM"));
+            process.once("SIGHUP", () => interrupt("SIGHUP"));
+            while (true) {
+                if (interrupted)
+                    throw new Error(`detached leader interrupted before release: ${interrupted}`);
+                const release = readDetachedLeaderReport(releasePath);
+                if (release?.kind === "release" && release.nonce === nonce && release.sessionId === payload.sessionId && release.sessionName === payload.sessionName && release.leaderPid === process.pid) {
+                    detachedHudProof = parseDetachedHudAuthorityProof(release.hud);
+                    break;
+                }
+                const abort = readDetachedLeaderReport(abortPath);
+                if (abort?.kind === "abort" && abort.nonce === nonce && abort.sessionId === payload.sessionId && abort.sessionName === payload.sessionName && abort.leaderPid === process.pid) {
+                    throw new Error("detached launch aborted before release");
+                }
+                if (Date.now() >= releaseDeadline)
+                    throw new Error("detached leader release timed out");
+                blockMs(20);
+            }
+            rmSync(releasePath, { force: true });
+            rmSync(abortPath, { force: true });
+        }
+        const child = spawn(process.platform === "win32" ? "powershell.exe" : "/bin/sh", process.platform === "win32" ? ["-NoProfile", "-Command", payload.codexCmd] : ["-c", payload.codexCmd], {
+            cwd: payload.cwd,
+            stdio: "inherit",
+            ...(process.platform === "win32" ? {} : { detached: true }),
+        });
+        let escalation;
+        const signalChildTree = (signal, force = false) => {
+            if (!child.pid)
+                return;
+            try {
+                if (process.platform === "win32")
+                    execFileSync("taskkill", ["/PID", String(child.pid), "/T", ...(force ? ["/F"] : [])], { stdio: "ignore" });
+                else
+                    process.kill(-child.pid, signal);
+            }
+            catch { }
+        };
+        const forward = (signal) => {
+            externalInterrupt ??= signal;
+            signalChildTree(signal);
+            if (!escalation) {
+                escalation = setTimeout(() => signalChildTree("SIGKILL", true), 5_000);
+                escalation.unref();
+            }
+        };
+        process.once("SIGINT", () => forward("SIGINT"));
+        process.once("SIGTERM", () => forward("SIGTERM"));
+        process.once("SIGHUP", () => forward("SIGHUP"));
+        traceDetachedLeaderPhase("child-wait-start");
+        const outcome = await new Promise((resolveChild, rejectChild) => {
+            child.once("error", rejectChild);
+            child.once("exit", (code, signal) => resolveChild({ code, signal }));
+        });
+        traceDetachedLeaderPhase(`child-exit:${String(outcome.code)}:${String(outcome.signal)}`);
+        if (escalation)
+            clearTimeout(escalation);
+        if (process.platform !== "win32" && child.pid) {
+            const waitForGroupExit = async (deadline) => {
+                while (Date.now() < deadline) {
+                    try {
+                        process.kill(-child.pid, 0);
+                        await new Promise((resolveWait) => setTimeout(resolveWait, 20));
+                    }
+                    catch {
+                        return true;
+                    }
+                }
+                return false;
+            };
+            let groupGone = await waitForGroupExit(Date.now() + 5_000);
+            if (!groupGone) {
+                signalChildTree("SIGKILL", true);
+                groupGone = await waitForGroupExit(Date.now() + 5_000);
+            }
+            if (!groupGone)
+                throw new Error("detached child process group did not disappear after forced termination");
+        }
+        const signalExitCodes = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143, SIGKILL: 137 };
+        process.exitCode = externalInterrupt
+            ? signalExitCodes[externalInterrupt] ?? 1
+            : outcome.code ?? (outcome.signal ? signalExitCodes[outcome.signal] ?? 1 : 1);
+        traceDetachedLeaderPhase("post-launch-start");
+        await postLaunch(payload.cwd, payload.sessionId, binding, payload.codexHomeOverride, payload.preLaunchOptions.enableNotifyFallbackAuthority, payload.projectLocalCodexHomeForCleanup, async () => {
+            if (payload.readyPath)
+                writeDetachedLeaderReport(payload.readyPath, {
+                    version: 1, kind: "terminal", nonce, sessionId: payload.sessionId, sessionName: payload.sessionName,
+                    paneId: pane, leaderPid: process.pid, finalized: true,
+                    ...(typeof process.exitCode === "number" ? { exitStatus: process.exitCode } : {}),
+                });
+            traceDetachedLeaderPhase("terminal-report-written");
+            if (ownedRecord) {
+                const bytes = readFileSync(activeRecordPath, "utf-8");
+                const digest = createHash("sha256").update(bytes).digest("hex");
+                if (bytes === ownedRecord.bytes && digest === ownedRecord.digest)
+                    rmSync(activeRecordPath, { force: true });
+            }
+            if (!externalInterrupt && outcome.code !== null) {
+                traceDetachedLeaderPhase("hud-teardown-start");
+                teardownDetachedOwnedHudPane(pane, payload, detachedHudProof);
+                traceDetachedLeaderPhase("hud-teardown-done");
+            }
+        });
+        traceDetachedLeaderPhase("post-launch-done");
+        await cleanupRuntimeCodexHome(payload.runtimeCodexHomeForCleanup, payload.projectLocalCodexHomeForCleanup);
+        traceDetachedLeaderPhase("leader-return");
+    }
+    catch (error) {
+        let failure = error;
+        let finalized = false;
+        try {
+            await postLaunch(payload.cwd, payload.sessionId, binding, payload.codexHomeOverride, payload.preLaunchOptions.enableNotifyFallbackAuthority, payload.projectLocalCodexHomeForCleanup);
+            finalized = true;
+            await cleanupRuntimeCodexHome(payload.runtimeCodexHomeForCleanup, payload.projectLocalCodexHomeForCleanup);
+        }
+        catch (lifecycleError) {
+            failure = new AggregateError([error, lifecycleError], `detached leader failure finalization did not complete: launch=${describeDetachedLeaderFailure(error)}; lifecycle=${describeDetachedLeaderFailure(lifecycleError)}`);
+        }
+        if (finalized && ownedRecord) {
+            try {
+                const bytes = readFileSync(activeRecordPath, "utf-8");
+                const digest = createHash("sha256").update(bytes).digest("hex");
+                if (bytes === ownedRecord.bytes && digest === ownedRecord.digest)
+                    rmSync(activeRecordPath, { force: true });
+            }
+            catch { }
+        }
+        if (payload.readyPath)
+            writeDetachedLeaderReport(payload.readyPath, {
+                version: 1, kind: "failed", nonce, sessionId: payload.sessionId, sessionName: payload.sessionName,
+                leaderPid: process.pid, finalized, error: failure instanceof Error ? failure.message : String(failure),
+            });
+        throw failure;
+    }
+    finally {
+        await closeLaunchSessionBindingOnce(binding);
+    }
 }
 /**
  * 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;
+export async function postLaunch(cwd, sessionId, binding, codexHomeOverride, enableNotifyFallbackAuthority = false, projectLocalCodexHomeForCleanup, onFinalized) {
+    const sessionStartedAt = binding.startedAt;
+    // Pointer authority is consumed before any terminal cleanup. A denied or
+    // unproven binding must leave every cleanup target untouched.
+    let terminalError;
     try {
-        const sessionState = await readSessionState(cwd);
-        sessionStartedAt = sessionState?.started_at;
+        const finalization = await finalizeBoundOnce(binding, "post-launch", cwd);
+        if (!finalization.finalized)
+            terminalError = new Error(`bound session finalization denied: ${finalization.cleanup.comparison?.reason ?? "unknown reason"}`);
+        const closeFailure = finalization.cleanup.capability.find((evidence) => evidence.status === "failed");
+        if (closeFailure)
+            terminalError = new Error(`bound session retained close failed: ${closeFailure.error?.message ?? "unknown error"}`);
     }
-    catch (err) {
-        logCliOperationFailure(err);
-        // Non-fatal
+    catch (error) {
+        terminalError = error;
     }
+    if (terminalError) {
+        // Denial diagnostics are complete; do not mutate ordinary lifecycle state.
+        await closeLaunchSessionBindingOnce(binding);
+        throw terminalError;
+    }
+    await onFinalized?.();
     // 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.
@@ -4623,13 +5684,6 @@ export async function postLaunch(cwd, sessionId, codexHomeOverride, enableNotify
     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");
@@ -4701,10 +5755,59 @@ export async function postLaunch(cwd, sessionId, codexHomeOverride, enableNotify
         logCliOperationFailure(err);
         // Non-fatal
     }
+    const closeEvidence = await closeLaunchSessionBindingOnce(binding);
+    if (closeEvidence.status === "failed") {
+        throw new Error(`bound session retained close failed: ${closeEvidence.error?.message ?? "unknown error"}`);
+    }
 }
-export async function runDetachedSessionPostLaunch(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
-    await postLaunch(cwd, sessionId, codexHomeOverride, false, projectLocalCodexHomeForCleanup);
-    await cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup).catch(logCliOperationFailure);
+export async function runDetachedSessionPostLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup, releaseMarkerPath) {
+    // The detached child is intentionally unbound: it must never perform parent
+    // pointer finalization or cleanup after the release barrier. It still owns
+    // every non-pointer terminal lifecycle responsibility.
+    const failures = [];
+    const strict = async (operation) => {
+        try {
+            await operation();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    };
+    await strict(() => reapPostLaunchOrphanedMcpProcesses());
+    await strict(() => flushNotifyFallbackOnce(cwd, { sessionId }));
+    await strict(() => stopNotifyFallbackWatcher(cwd));
+    await strict(() => flushHookDerivedWatcherOnce(cwd));
+    await strict(() => stopHookDerivedWatcher(cwd));
+    if (projectLocalCodexHomeForCleanup) {
+        await strict(() => cleanCodexModelAvailabilityNuxIfNeeded(join(projectLocalCodexHomeForCleanup, "config.toml")));
+    }
+    await strict(() => removeSessionModelInstructionsFile(cwd, sessionId));
+    await strict(async () => {
+        const { onSessionEnd } = await import("../wiki/lifecycle.js");
+        onSessionEnd({ cwd, session_id: sessionId });
+    });
+    await strict(() => cleanupPostLaunchModeStateFiles(cwd, sessionId));
+    await strict(async () => {
+        const { notifyLifecycle } = await import("../notifications/index.js");
+        await notifyLifecycle("session-end", {
+            sessionId, projectPath: cwd, projectName: basename(cwd), reason: "session_exit",
+        });
+    });
+    await strict(async () => {
+        const { markOwnedTeamsLeaderSessionStopped } = await import("../team/state.js");
+        await markOwnedTeamsLeaderSessionStopped(cwd, sessionId);
+    });
+    await strict(() => emitNativeHookEvent(cwd, "session-end", {
+        session_id: sessionId,
+        context: buildNativeHookBaseContext(cwd, sessionId, "finished", {
+            project_path: cwd, project_name: basename(cwd), reason: "session_exit", status: "finished",
+        }),
+    }));
+    await strict(() => cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projectLocalCodexHomeForCleanup));
+    if (releaseMarkerPath)
+        await strict(() => rm(releaseMarkerPath, { force: true }));
+    if (failures.length > 0)
+        throw new AggregateError(failures, "detached post-launch lifecycle cleanup failed");
 }
 async function emitNativeHookEvent(cwd, event, opts = {}) {
     const payload = buildHookEvent(event, {
@@ -5143,14 +6246,13 @@ async function listHookVisibleRunDirStateRefs(cwd) {
         if (!sourceCwd || !runDir)
             return;
         try {
-            if (canonicalizePathForRunDirMatch(sourceCwd) !== canonicalCwd &&
-                (!worktreeCwd || canonicalizePathForRunDirMatch(worktreeCwd) !== canonicalCwd))
+            if (canonicalizePathForRunDirMatch(sourceCwd) !== canonicalCwd
+                && (!worktreeCwd || canonicalizePathForRunDirMatch(worktreeCwd) !== canonicalCwd))
                 return;
             const resolvedRunDir = resolve(runDir);
             if (resolvedRunDir !== canonicalRunsRoot
-                && !resolvedRunDir.startsWith(`${canonicalRunsRoot}/`)) {
+                && !resolvedRunDir.startsWith(`${canonicalRunsRoot}/`))
                 return;
-            }
             runDirs.add(resolvedRunDir);
         }
         catch {
@@ -5203,7 +6305,7 @@ async function listHookVisibleRunDirStateRefs(cwd) {
         for (const dir of candidateDirs) {
             const files = await readdir(dir).catch(() => []);
             for (const file of files) {
-                if (!file.endsWith("-state.json") || file === "session.json")
+                if (!isModeStateFilename(file))
                     continue;
                 const path = join(dir, file);
                 if (seenPaths.has(path))
@@ -5219,41 +6321,362 @@ async function listHookVisibleRunDirStateRefs(cwd) {
     }
     return refs.sort((a, b) => a.mode.localeCompare(b.mode));
 }
-async function cancelModes(args = []) {
-    const { writeFile, readFile } = await import("fs/promises");
-    const cwd = process.cwd();
+function isCanonicalPathWithin(parent, child, allowEqual = false) {
+    const rel = relative(parent, child);
+    if (rel === "")
+        return allowEqual;
+    return rel !== ".." && !rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(rel);
+}
+async function selectAuthorizedHookVisibleRunDirState(cwd) {
+    const runsRoot = resolveMadmaxRunsRoot(process.env);
+    const activeDir = join(runsRoot, MADMAX_DETACHED_ACTIVE_DIR);
+    const canonicalCwd = canonicalizePathForRunDirMatch(cwd);
+    let canonicalRunsRoot;
+    try {
+        canonicalRunsRoot = realpathSync(resolve(runsRoot));
+    }
+    catch {
+        return null;
+    }
+    const candidates = [];
+    const files = await readdir(activeDir).catch(() => []);
+    for (const file of files) {
+        if (!file.endsWith(".json"))
+            continue;
+        const record = readMadmaxDetachedActiveRecord(join(activeDir, file));
+        if (!record || file !== `${record.context_key}.json`)
+            continue;
+        if (!record.session_id || normalizeSessionId(record.session_id) !== record.session_id)
+            continue;
+        if (!hasMatchingMadmaxDetachedRuntimeBinding(record))
+            continue;
+        if (canonicalizePathForRunDirMatch(record.source_cwd) !== canonicalCwd
+            && (!record.worktree_cwd || canonicalizePathForRunDirMatch(record.worktree_cwd) !== canonicalCwd))
+            continue;
+        try {
+            const canonicalRunDir = realpathSync(resolve(record.run_dir));
+            if (!isCanonicalPathWithin(canonicalRunsRoot, canonicalRunDir)) {
+                throw new Error("run directory escapes the authorized runs root");
+            }
+            const stateDir = realpathSync(join(canonicalRunDir, ".omx", "state"));
+            if (!isCanonicalPathWithin(canonicalRunDir, stateDir)) {
+                throw new Error("state directory escapes the authorized run directory");
+            }
+            const session = JSON.parse(await readFile(join(stateDir, "session.json"), "utf-8"));
+            if (session.session_id !== record.session_id)
+                throw new Error("run session pointer changed");
+            const sessionDir = realpathSync(join(stateDir, "sessions", record.session_id));
+            if (!isCanonicalPathWithin(stateDir, sessionDir)) {
+                throw new Error("session directory escapes the authorized state directory");
+            }
+            candidates.push({ sessionDir, sessionId: record.session_id, record });
+        }
+        catch (err) {
+            throw new Error(`Refusing cancellation because detached run authority is invalid: ${record.run_dir}.`, { cause: err });
+        }
+    }
+    if (candidates.length > 1)
+        throw new Error("Refusing cancellation because multiple detached run authorities match.");
+    if (candidates.length === 0)
+        return null;
+    const [{ sessionDir, sessionId, record }] = candidates;
+    const refs = [];
+    const stateFiles = await readdir(sessionDir).catch(() => []);
+    for (const file of stateFiles) {
+        if (!isModeStateFilename(file))
+            continue;
+        const path = join(sessionDir, file);
+        try {
+            const fileStat = lstatSync(path);
+            if (!fileStat.isFile() || fileStat.isSymbolicLink()) {
+                throw new Error(`Refusing cancellation through non-regular run state target: ${path}.`);
+            }
+            const canonicalFile = realpathSync(path);
+            if (!isCanonicalPathWithin(sessionDir, canonicalFile)) {
+                throw new Error(`Refusing cancellation outside authorized run session: ${path}.`);
+            }
+            refs.push({
+                mode: file.slice(0, -"-state.json".length),
+                path: canonicalFile,
+                scope: "session",
+            });
+        }
+        catch (err) {
+            throw new Error(`Refusing cancellation because detached run state authority is invalid: ${path}.`, { cause: err });
+        }
+    }
+    return { refs: refs.sort((a, b) => a.mode.localeCompare(b.mode)), sessionId, sessionDir, record };
+}
+function assertCancellationAuthorityPath(baseStateDir, authorityRoot) {
+    const resolvedBase = resolve(baseStateDir);
+    const resolvedAuthority = resolve(authorityRoot);
+    const baseStat = lstatSync(resolvedBase);
+    if (!baseStat.isDirectory() || baseStat.isSymbolicLink() || realpathSync(resolvedBase) !== resolvedBase) {
+        throw new Error(`Refusing cancellation through symlinked state authority root: ${baseStateDir}.`);
+    }
+    if (!isCanonicalPathWithin(resolvedBase, resolvedAuthority, true)) {
+        throw new Error(`Refusing cancellation outside base state authority: ${authorityRoot}.`);
+    }
+    let current = resolvedBase;
+    const rel = relative(resolvedBase, resolvedAuthority);
+    for (const component of rel ? rel.split(/[\\/]+/) : []) {
+        current = join(current, component);
+        const componentStat = lstatSync(current);
+        if (!componentStat.isDirectory() || componentStat.isSymbolicLink() || realpathSync(current) !== current) {
+            throw new Error(`Refusing cancellation through symlinked authority component: ${current}.`);
+        }
+    }
+    return resolvedAuthority;
+}
+function collectCancellationOwnerIds(baseStateDir, sessionId) {
+    const ownerIds = new Set();
+    if (sessionId)
+        ownerIds.add(sessionId);
+    try {
+        const pointer = JSON.parse(readFileSync(join(baseStateDir, "session.json"), "utf-8"));
+        for (const field of [
+            "session_id",
+            "native_session_id",
+            "codex_session_id",
+            "owner_omx_session_id",
+            "owner_codex_session_id",
+        ]) {
+            const normalized = normalizeSessionId(pointer[field]);
+            if (normalized)
+                ownerIds.add(normalized);
+        }
+    }
+    catch { }
+    return ownerIds;
+}
+function assertCancellationOwnerMetadata(value, ownerIds, path) {
+    if (Object.prototype.hasOwnProperty.call(value, "session_id")) {
+        const sessionId = normalizeSessionId(value.session_id);
+        if (!sessionId || !ownerIds.has(sessionId)) {
+            throw new Error(`Refusing contradictory session_id in ${path}.`);
+        }
+    }
+    for (const ownerField of ["owner_omx_session_id", "owner_codex_session_id"]) {
+        if (!Object.prototype.hasOwnProperty.call(value, ownerField))
+            continue;
+        const rawOwner = value[ownerField];
+        const blankOwner = typeof rawOwner === "string" && rawOwner.trim() === "";
+        const owner = normalizeSessionId(rawOwner);
+        if (!blankOwner && (!owner || !ownerIds.has(owner))) {
+            throw new Error(`Refusing contradictory ${ownerField} in ${path}.`);
+        }
+    }
+}
+async function resolveExactSessionCancellationAuthority(cwd, baseStateDir, sessionId) {
+    if (!sessionId)
+        return undefined;
+    let pointer;
+    let authorityCwd = cwd;
+    try {
+        const rawPointer = JSON.parse(await readFile(join(baseStateDir, "session.json"), "utf-8"));
+        if (typeof rawPointer.cwd === "string" && rawPointer.cwd.trim())
+            authorityCwd = rawPointer.cwd.trim();
+        pointer = await readSessionPointer(resolveSessionPointerContext(authorityCwd));
+    }
+    catch {
+        return undefined;
+    }
+    const nativeSessionId = normalizeSessionId(pointer.state?.native_session_id);
+    if (pointer.status !== "usable" || pointer.state?.session_id !== sessionId || !nativeSessionId)
+        return undefined;
+    try {
+        const ownerEvidence = await readNativeSessionOwnerEvidence(authorityCwd, nativeSessionId);
+        if (ownerEvidence.status !== "usable")
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return { sessionId, nativeSessionId, authorityCwd };
+}
+function assertExactSkillOwner(value, authority, path, allowStaleTopCodexOwner = false) {
+    if (Object.prototype.hasOwnProperty.call(value, "session_id")
+        && normalizeSessionId(value.session_id) !== authority.sessionId) {
+        throw new Error(`Refusing contradictory session_id in ${path}.`);
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "owner_omx_session_id")) {
+        const rawOwner = value.owner_omx_session_id;
+        const blankOwner = typeof rawOwner === "string" && rawOwner.trim() === "";
+        const owner = normalizeSessionId(rawOwner);
+        if (!blankOwner && (!owner || owner !== authority.sessionId)) {
+            throw new Error(`Refusing contradictory owner_omx_session_id in ${path}.`);
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "owner_codex_session_id")) {
+        const rawOwner = value.owner_codex_session_id;
+        const blankOwner = typeof rawOwner === "string" && rawOwner.trim() === "";
+        const owner = normalizeSessionId(rawOwner);
+        if (!blankOwner && (!owner || (!allowStaleTopCodexOwner && owner !== authority.nativeSessionId))) {
+            throw new Error(`Refusing contradictory owner_codex_session_id in ${path}.`);
+        }
+    }
+}
+function assertCompatibleNestedSkillOwners(value, authority, path) {
+    if (!Object.prototype.hasOwnProperty.call(value, "active_skills"))
+        return;
+    if (!Array.isArray(value.active_skills)) {
+        throw new Error(`Refusing malformed active_skills in ${path}.`);
+    }
+    for (const [index, skill] of value.active_skills.entries()) {
+        const entryPath = `${path} active_skills[${index}]`;
+        if (!skill || typeof skill !== "object" || Array.isArray(skill)) {
+            throw new Error(`Refusing malformed active_skills entry ${index} in ${path}.`);
+        }
+        const entry = skill;
+        if (typeof entry.skill !== "string" || entry.skill.trim() === "") {
+            throw new Error(`Refusing malformed skill in ${entryPath}.`);
+        }
+        for (const field of ["active"]) {
+            if (Object.prototype.hasOwnProperty.call(entry, field) && typeof entry[field] !== "boolean") {
+                throw new Error(`Refusing malformed ${field} in ${entryPath}.`);
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(entry, "phase") && typeof entry.phase !== "string") {
+            throw new Error(`Refusing malformed phase in ${entryPath}.`);
+        }
+        for (const [field, fieldValue] of Object.entries(entry)) {
+            if (field.endsWith("_at") && typeof fieldValue !== "string") {
+                throw new Error(`Refusing malformed ${field} in ${entryPath}.`);
+            }
+        }
+        assertExactSkillOwner(entry, authority, entryPath);
+    }
+}
+async function cancelModes(args = [], options = {}) {
+    const cwd = options.cwd ?? process.cwd();
     const nowIso = new Date().toISOString();
-    const force = args.includes("--force");
+    if (args.length > 1 || args.some((arg) => arg !== "--force")) {
+        const unsupported = args.find((arg) => arg !== "--force") ?? args[1] ?? "";
+        throw new Error(unsupported === "--all"
+            ? "omx cancel --all is not supported; broad workspace cancellation requires a separate command."
+            : `Unknown cancel argument: ${unsupported}`);
+    }
+    const force = args.length === 1;
     try {
         const writableScope = await resolveWritableStateScope(cwd);
-        const loadStates = async (refs) => {
+        const baseStateDir = getBaseStateDir(cwd);
+        const exactAuthority = writableScope.source === "session"
+            ? await resolveExactSessionCancellationAuthority(cwd, baseStateDir, writableScope.sessionId)
+            : undefined;
+        const expectedOwnerIds = collectCancellationOwnerIds(baseStateDir, writableScope.sessionId);
+        const loadStates = async (refs, authorityRoot, ownerIds = expectedOwnerIds) => {
             const loaded = new Map();
+            if (refs.length === 0)
+                return loaded;
+            const canonicalAuthorityRoot = assertCancellationAuthorityPath(authorityRoot === writableScope.stateDir ? baseStateDir : authorityRoot, authorityRoot);
             for (const ref of refs) {
-                const content = await readFile(ref.path, "utf-8");
+                const fileStat = lstatSync(ref.path);
+                if (!fileStat.isFile() || fileStat.isSymbolicLink()) {
+                    throw new Error(`Refusing cancellation through non-regular state target ${ref.path}.`);
+                }
+                const canonicalPath = realpathSync(ref.path);
+                const canonicalParent = realpathSync(dirname(ref.path));
+                if (!isCanonicalPathWithin(canonicalAuthorityRoot, canonicalParent, true)
+                    || !isCanonicalPathWithin(canonicalAuthorityRoot, canonicalPath)) {
+                    throw new Error(`Refusing cancellation outside authorized state root: ${ref.path}.`);
+                }
+                const content = await readFile(canonicalPath, "utf-8");
                 let parsedState;
                 try {
-                    parsedState = JSON.parse(content);
+                    const parsed = JSON.parse(content);
+                    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                        throw new Error("state must be a JSON object");
+                    }
+                    parsedState = parsed;
                 }
                 catch (err) {
                     logCliOperationFailure(err);
-                    continue;
+                    throw new Error(`Refusing partial cancellation because ${ref.path} is malformed.`, { cause: err });
+                }
+                if (typeof parsedState.mode === "string" && parsedState.mode !== ref.mode) {
+                    throw new Error(`Refusing contradictory mode state in ${ref.path}.`);
+                }
+                if (ref.mode === SKILL_ACTIVE_STATE_MODE && exactAuthority) {
+                    const hasTopCodexOwner = Object.prototype.hasOwnProperty.call(parsedState, "owner_codex_session_id");
+                    const displacedOwnerId = hasTopCodexOwner
+                        ? normalizeSessionId(parsedState.owner_codex_session_id)
+                        : undefined;
+                    const blankTopCodexOwner = typeof parsedState.owner_codex_session_id === "string"
+                        && parsedState.owner_codex_session_id.trim() === "";
+                    if (hasTopCodexOwner && !blankTopCodexOwner && !displacedOwnerId) {
+                        throw new Error(`Refusing contradictory owner_codex_session_id in ${ref.path}.`);
+                    }
+                    assertExactSkillOwner(parsedState, exactAuthority, ref.path, hasTopCodexOwner);
+                    assertCompatibleNestedSkillOwners(parsedState, exactAuthority, ref.path);
+                    if (displacedOwnerId && displacedOwnerId !== exactAuthority.nativeSessionId) {
+                        let displacedEvidence;
+                        try {
+                            displacedEvidence = await readNativeSessionOwnerEvidence(exactAuthority.authorityCwd, displacedOwnerId);
+                        }
+                        catch (error) {
+                            throw new Error(`Refusing ambiguous displaced owner evidence for ${ref.path}.`, { cause: error });
+                        }
+                        if (displacedEvidence.status !== "absent" && displacedEvidence.status !== "stale-dead") {
+                            throw new Error(`Refusing non-stale displaced owner evidence for ${ref.path}.`);
+                        }
+                        parsedState.owner_codex_session_id = exactAuthority.nativeSessionId;
+                    }
+                }
+                else {
+                    assertCancellationOwnerMetadata(parsedState, ownerIds, ref.path);
+                    if (Object.prototype.hasOwnProperty.call(parsedState, "active_skills")) {
+                        if (!Array.isArray(parsedState.active_skills)) {
+                            throw new Error(`Refusing malformed active_skills in ${ref.path}.`);
+                        }
+                        for (const [index, skill] of parsedState.active_skills.entries()) {
+                            if (!skill || typeof skill !== "object" || Array.isArray(skill)) {
+                                throw new Error(`Refusing malformed active_skills entry ${index} in ${ref.path}.`);
+                            }
+                            assertCancellationOwnerMetadata(skill, ownerIds, `${ref.path} active_skills[${index}]`);
+                        }
+                    }
                 }
                 loaded.set(ref.mode, {
-                    path: ref.path,
+                    path: canonicalPath,
                     scope: ref.scope,
                     state: parsedState,
+                    originalContent: content,
+                    dev: fileStat.dev,
+                    ino: fileStat.ino,
                 });
             }
             return loaded;
         };
-        let states = await loadStates(await listModeStateFilesWithScopePreference(cwd));
+        const preferredRefs = writableScope.source === "root"
+            ? (await readdir(writableScope.stateDir).catch(() => []))
+                .filter((file) => isModeStateFilename(file))
+                .map((file) => ({
+                mode: file.slice(0, -"-state.json".length),
+                path: join(writableScope.stateDir, file),
+                scope: "root",
+            }))
+            : await listModeStateFilesWithScopePreference(cwd, writableScope.sessionId);
+        const hasPreferredSessionStateFiles = preferredRefs.some((ref) => ref.scope === "session");
+        const targetRefs = writableScope.source === "session"
+            ? preferredRefs.filter((ref) => ref.scope === "session")
+            : preferredRefs;
+        let runSelection = null;
+        let states = await loadStates(targetRefs, writableScope.stateDir, expectedOwnerIds);
         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;
+        if (writableScope.source === "root"
+            && !hasActiveWorkflowMode(states)
+            && !hasPreferredSessionStateFiles) {
+            runSelection = await selectAuthorizedHookVisibleRunDirState(cwd);
+            if (runSelection) {
+                const runOwnerIds = new Set([runSelection.sessionId]);
+                const runDirStates = await loadStates(runSelection.refs, runSelection.sessionDir, runOwnerIds);
+                if (hasActiveWorkflowMode(runDirStates))
+                    states = runDirStates;
+                else
+                    runSelection = null;
+            }
         }
-        const currentSessionId = writableScope.sessionId ?? "";
+        const currentSessionId = writableScope.sessionId ?? runSelection?.sessionId ?? "";
         const changed = new Set();
         const reported = new Set();
         const cancelMode = (mode, phase = "cancelled", reportIfWasActive = true) => {
@@ -5284,13 +6707,74 @@ async function cancelModes(args = []) {
             if (reportIfWasActive && wasActive && mode !== SKILL_ACTIVE_STATE_MODE)
                 reported.add(mode);
         };
-        const ralphLinksUltrawork = (state) => state.linked_ultrawork === true || state.linked_mode === "ultrawork";
+        const linkedRalphMode = (state) => {
+            if (state.linked_ultrawork === true || state.linked_mode === "ultrawork")
+                return "ultrawork";
+            if (state.linked_ecomode === true || state.linked_mode === "ecomode")
+                return "ecomode";
+            return undefined;
+        };
+        const cancelRalphSkillEntries = (linkedMode) => {
+            const entry = states.get(SKILL_ACTIVE_STATE_MODE);
+            if (!entry)
+                return;
+            const matchingSkills = new Set(["ralph", ...(linkedMode ? [linkedMode] : [])]);
+            const activeSkills = Array.isArray(entry.state.active_skills)
+                ? entry.state.active_skills
+                : [];
+            let changedSkillEntries = false;
+            const nextSkills = activeSkills.map((skill) => {
+                if (!skill || typeof skill !== "object" || Array.isArray(skill))
+                    return skill;
+                const skillEntry = skill;
+                if (skillEntry.active === false || typeof skillEntry.skill !== "string" || !matchingSkills.has(skillEntry.skill)) {
+                    return skill;
+                }
+                changedSkillEntries = true;
+                return { ...skillEntry, active: false, phase: "cancelled" };
+            });
+            const remainingActiveSkills = nextSkills.filter((skill) => (!!skill && typeof skill === "object" && !Array.isArray(skill)
+                && skill.active !== false));
+            if (!changedSkillEntries) {
+                if (entry.state.active !== true)
+                    return;
+                if (typeof entry.state.skill !== "string" || !matchingSkills.has(entry.state.skill))
+                    return;
+            }
+            entry.state.active_skills = nextSkills;
+            entry.state.updated_at = nowIso;
+            entry.state.last_turn_at = nowIso;
+            if (remainingActiveSkills.length > 0) {
+                const primary = remainingActiveSkills[0];
+                entry.state.active = true;
+                entry.state.skill = primary.skill;
+                if (typeof primary.phase === "string") {
+                    entry.state.phase = primary.phase;
+                    entry.state.current_phase = primary.phase;
+                }
+                else {
+                    delete entry.state.phase;
+                    delete entry.state.current_phase;
+                }
+                delete entry.state.completed_at;
+            }
+            else {
+                entry.state.active = false;
+                entry.state.skill = "";
+                entry.state.phase = "cancelled";
+                entry.state.current_phase = "cancelled";
+                entry.state.completed_at = nowIso;
+            }
+            changed.add(SKILL_ACTIVE_STATE_MODE);
+        };
         const ralph = states.get("ralph");
         const hadActiveRalph = !!(ralph && ralph.state.active === true);
         if (ralph && ralph.state.active === true) {
+            const linkedMode = linkedRalphMode(ralph.state);
+            if (linkedMode)
+                cancelMode(linkedMode, "cancelled", true);
             cancelMode("ralph", "cancelled", true);
-            if (ralphLinksUltrawork(ralph.state))
-                cancelMode("ultrawork", "cancelled", true);
+            cancelRalphSkillEntries(linkedMode);
         }
         if (!hadActiveRalph) {
             for (const [mode, entry] of states.entries()) {
@@ -5298,11 +6782,11 @@ async function cancelModes(args = []) {
                     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));
-        }
+        const assertRunAuthority = () => {
+            if (runSelection && !hasMatchingMadmaxDetachedRuntimeBinding(runSelection.record)) {
+                throw new Error("Refusing cancellation because detached run authority changed.");
+            }
+        };
         if (force && currentSessionId) {
             const stopStateEntries = [...states.entries()].filter(([mode]) => mode === "native-stop");
             for (const [, entry] of stopStateEntries) {
@@ -5313,10 +6797,85 @@ async function cancelModes(args = []) {
                     continue;
                 delete sessions[currentSessionId];
                 entry.state.sessions = sessions;
-                await writeFile(entry.path, JSON.stringify(entry.state, null, 2));
                 changed.add("native-stop");
             }
         }
+        const orderedChanges = [...changed]
+            .sort((left, right) => {
+            if (left === "ralph")
+                return 1;
+            if (right === "ralph")
+                return -1;
+            return left.localeCompare(right);
+        })
+            .map((mode) => {
+            const entry = states.get(mode);
+            if (!entry)
+                throw new Error(`Missing frozen cancellation entry for ${mode}.`);
+            return { mode, entry, nextContent: JSON.stringify(entry.state, null, 2) };
+        });
+        const opened = [];
+        try {
+            for (const change of orderedChanges) {
+                assertRunAuthority();
+                const handle = await open(change.entry.path, fsConstants.O_RDWR | fsConstants.O_NOFOLLOW);
+                const currentStat = await handle.stat();
+                const currentContent = await handle.readFile({ encoding: "utf-8" });
+                if (!currentStat.isFile() || currentStat.dev !== change.entry.dev || currentStat.ino !== change.entry.ino) {
+                    await handle.close();
+                    throw new Error(`Refusing cancellation because state identity changed: ${change.entry.path}.`);
+                }
+                if (currentContent !== change.entry.originalContent) {
+                    await handle.close();
+                    throw new Error(`Refusing cancellation because state content changed: ${change.entry.path}.`);
+                }
+                opened.push({ ...change, handle });
+            }
+            const committed = [];
+            const cancellationTestWriteFailureMode = options.testFaults?.writeFailureMode;
+            const cancellationTestRollbackFailureMode = options.testFaults?.rollbackFailureMode;
+            try {
+                for (const openedEntry of opened) {
+                    assertRunAuthority();
+                    committed.push(openedEntry);
+                    if (cancellationTestWriteFailureMode === openedEntry.mode) {
+                        throw new Error(`Injected cancellation write failure for ${openedEntry.mode}.`);
+                    }
+                    await openedEntry.handle.truncate(0);
+                    await openedEntry.handle.write(openedEntry.nextContent, 0, "utf-8");
+                    await openedEntry.handle.sync();
+                }
+            }
+            catch (writeError) {
+                let rollbackFailureCount = 0;
+                const rollbackFailureSample = [];
+                for (const committedEntry of committed.reverse()) {
+                    try {
+                        if (cancellationTestRollbackFailureMode === committedEntry.mode) {
+                            throw new Error(`Injected cancellation rollback failure for ${committedEntry.mode}.`);
+                        }
+                        await committedEntry.handle.truncate(0);
+                        await committedEntry.handle.write(committedEntry.entry.originalContent, 0, "utf-8");
+                        await committedEntry.handle.sync();
+                    }
+                    catch {
+                        rollbackFailureCount += 1;
+                        if (rollbackFailureSample.length < 3) {
+                            rollbackFailureSample.push(committedEntry.mode.replace(/[^A-Za-z0-9_-]/g, "_"));
+                        }
+                    }
+                }
+                if (rollbackFailureCount > 0) {
+                    const primaryMessage = writeError instanceof Error ? writeError.message : String(writeError);
+                    const sample = rollbackFailureSample.length > 0 ? `:${rollbackFailureSample.join(",")}` : "";
+                    throw new Error(`${primaryMessage} (cancellation_rollback_failed:${rollbackFailureCount}${sample}).`, { cause: writeError });
+                }
+                throw writeError;
+            }
+        }
+        finally {
+            await Promise.all(opened.map(({ handle }) => handle.close().catch(() => undefined)));
+        }
         for (const mode of reported) {
             console.log(`Cancelled: ${mode}`);
         }
@@ -5326,7 +6885,11 @@ async function cancelModes(args = []) {
     }
     catch (err) {
         logCliOperationFailure(err);
-        console.log("No active modes to cancel.");
+        process.exitCode = 1;
     }
 }
+/** Test-only entrypoint for deterministic transaction fault injection without runtime environment controls. */
+export async function cancelModesForTest(cwd, args, testFaults) {
+    await cancelModes(args, { cwd, testFaults });
+}
 //# sourceMappingURL=index.js.map