oh-my-codex 0.10.2 → 0.10.3

package/dist/cli/index.js

@@ -2,41 +2,45 @@
  * oh-my-codex CLI
  * Multi-agent orchestration for OpenAI Codex CLI
  */
-import { execFileSync, spawn } from 'child_process';
-import { basename, dirname, join } from 'path';
-import { existsSync, readFileSync } from 'fs';
-import { constants as osConstants } from 'os';
-import { setup, SETUP_SCOPES, SETUP_SKILL_TARGETS } from './setup.js';
-import { uninstall } from './uninstall.js';
-import { version } from './version.js';
-import { tmuxHookCommand } from './tmux-hook.js';
-import { hooksCommand } from './hooks.js';
-import { hudCommand } from '../hud/index.js';
-import { teamCommand } from './team.js';
-import { ralphCommand } from './ralph.js';
-import { askCommand } from './ask.js';
-import { exploreCommand } from './explore.js';
-import { sparkshellCommand } from './sparkshell.js';
-import { agentsInitCommand } from './agents-init.js';
-import { sessionCommand } from './session-search.js';
-import { autoresearchCommand } from './autoresearch.js';
-import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FLAG, SPARK_FLAG, MADMAX_SPARK_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, } from './constants.js';
-import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from '../mcp/state-paths.js';
-import { maybeCheckAndPromptUpdate } from './update.js';
-import { maybePromptGithubStar } from './star-prompt.js';
-import { generateOverlay, removeSessionModelInstructionsFile, resolveSessionOrchestrationMode, sessionModelInstructionsPath, writeSessionModelInstructionsFile, } from '../hooks/agents-overlay.js';
-import { readSessionState, isSessionStale, writeSessionStart, writeSessionEnd, resetSessionMetrics, } from '../hooks/session.js';
-import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isNativeWindows, isTmuxAvailable, } from '../team/tmux-session.js';
-import { getPackageRoot } from '../utils/package.js';
-import { codexConfigPath } from '../utils/paths.js';
-import { repairConfigIfNeeded } from '../config/generator.js';
-import { HUD_TMUX_HEIGHT_LINES } from '../hud/constants.js';
-import { classifySpawnError, spawnPlatformCommandSync } from '../utils/platform-command.js';
-import { buildHookEvent } from '../hooks/extensibility/events.js';
-import { dispatchHookEvent } from '../hooks/extensibility/dispatcher.js';
-import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, } from '../team/model-contract.js';
-import { parseWorktreeMode, planWorktreeTarget, ensureWorktree, } from '../team/worktree.js';
-import { OMX_NOTIFY_TEMP_CONTRACT_ENV, parseNotifyTempContractFromArgs, serializeNotifyTempContract, } from '../notifications/temp-contract.js';
+import { execFileSync, spawn } from "child_process";
+import { basename, dirname, join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { constants as osConstants } from "os";
+import { setup, SETUP_SCOPES } from "./setup.js";
+import { uninstall } from "./uninstall.js";
+import { version } from "./version.js";
+import { tmuxHookCommand } from "./tmux-hook.js";
+import { hooksCommand } from "./hooks.js";
+import { hudCommand } from "../hud/index.js";
+import { teamCommand } from "./team.js";
+import { ralphCommand } from "./ralph.js";
+import { ralphthonCommand } from "./ralphthon.js";
+import { askCommand } from "./ask.js";
+import { cleanupCommand } from "./cleanup.js";
+import { exploreCommand } from "./explore.js";
+import { sparkshellCommand } from "./sparkshell.js";
+import { agentsInitCommand } from "./agents-init.js";
+import { agentsCommand } from "./agents.js";
+import { sessionCommand } from "./session-search.js";
+import { autoresearchCommand } from "./autoresearch.js";
+import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FLAG, SPARK_FLAG, MADMAX_SPARK_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, } from "./constants.js";
+import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from "../mcp/state-paths.js";
+import { maybeCheckAndPromptUpdate } from "./update.js";
+import { maybePromptGithubStar } from "./star-prompt.js";
+import { generateOverlay, removeSessionModelInstructionsFile, resolveSessionOrchestrationMode, sessionModelInstructionsPath, writeSessionModelInstructionsFile, } from "../hooks/agents-overlay.js";
+import { readModeState, updateModeState } from "../modes/base.js";
+import { readSessionState, isSessionStale, writeSessionStart, writeSessionEnd, resetSessionMetrics, } from "../hooks/session.js";
+import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isNativeWindows, isTmuxAvailable, } from "../team/tmux-session.js";
+import { getPackageRoot } from "../utils/package.js";
+import { codexConfigPath } from "../utils/paths.js";
+import { repairConfigIfNeeded } from "../config/generator.js";
+import { HUD_TMUX_HEIGHT_LINES } from "../hud/constants.js";
+import { classifySpawnError, spawnPlatformCommandSync, } from "../utils/platform-command.js";
+import { buildHookEvent } from "../hooks/extensibility/events.js";
+import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
+import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, } from "../team/model-contract.js";
+import { parseWorktreeMode, planWorktreeTarget, ensureWorktree, } from "../team/worktree.js";
+import { OMX_NOTIFY_TEMP_CONTRACT_ENV, parseNotifyTempContractFromArgs, serializeNotifyTempContract, } from "../notifications/temp-contract.js";
 const HELP = `
 oh-my-codex (omx) - Multi-agent orchestration for Codex CLI
 
@@ -46,6 +50,7 @@ Usage:
   omx setup     Install skills, prompts, MCP servers, and scope-specific AGENTS.md
   omx uninstall Remove OMX configuration and clean up installed artifacts
   omx doctor    Check installation health
+  omx cleanup   Kill orphaned OMX MCP server processes and remove stale OMX /tmp directories
   omx doctor --team  Check team/swarm runtime health diagnostics
   omx ask       Ask local provider CLI (claude|gemini) and write artifact output
   omx resume    Resume a previous interactive Codex session
@@ -53,10 +58,12 @@ Usage:
   omx session   Search prior local session transcripts and history artifacts
   omx agents-init [path]
                 Bootstrap lightweight AGENTS.md files for a repo/subtree
+  omx agents    Manage Codex native agent TOML files
   omx deepinit [path]
                 Alias for agents-init (lightweight AGENTS bootstrap only)
   omx team      Spawn parallel worker panes in tmux and bootstrap inbox/task state
   omx ralph     Launch Codex with ralph persistence mode active
+  omx ralphthon Launch Codex with autonomous hackathon lifecycle mode active
   omx autoresearch Launch thin-supervisor autoresearch with keep/discard/reset parity
   omx version   Show version information
   omx tmux-hook Manage tmux prompt injection workaround (init|status|validate|test)
@@ -100,39 +107,55 @@ Options:
                 user | project
   --skill-target
                 User-scope skills target for "omx setup" only:
-                codex-home | agents
+                codex-home
 `;
-const REASONING_KEY = 'model_reasoning_effort';
-const MODEL_INSTRUCTIONS_FILE_KEY = 'model_instructions_file';
-const TEAM_WORKER_LAUNCH_ARGS_ENV = 'OMX_TEAM_WORKER_LAUNCH_ARGS';
-const TEAM_INHERIT_LEADER_FLAGS_ENV = 'OMX_TEAM_INHERIT_LEADER_FLAGS';
-const OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV = 'OMX_BYPASS_DEFAULT_SYSTEM_PROMPT';
-const OMX_MODEL_INSTRUCTIONS_FILE_ENV = 'OMX_MODEL_INSTRUCTIONS_FILE';
-const OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV = 'OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE';
-const REASONING_MODES = ['low', 'medium', 'high', 'xhigh'];
+const REASONING_KEY = "model_reasoning_effort";
+const MODEL_INSTRUCTIONS_FILE_KEY = "model_instructions_file";
+const TEAM_WORKER_LAUNCH_ARGS_ENV = "OMX_TEAM_WORKER_LAUNCH_ARGS";
+const TEAM_INHERIT_LEADER_FLAGS_ENV = "OMX_TEAM_INHERIT_LEADER_FLAGS";
+const OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV = "OMX_BYPASS_DEFAULT_SYSTEM_PROMPT";
+const OMX_MODEL_INSTRUCTIONS_FILE_ENV = "OMX_MODEL_INSTRUCTIONS_FILE";
+const OMX_RALPH_APPEND_INSTRUCTIONS_FILE_ENV = "OMX_RALPH_APPEND_INSTRUCTIONS_FILE";
+const OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV = "OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE";
+const OMX_RALPHTHON_APPEND_INSTRUCTIONS_FILE_ENV = "OMX_RALPHTHON_APPEND_INSTRUCTIONS_FILE";
+const REASONING_MODES = ["low", "medium", "high", "xhigh"];
 const REASONING_MODE_SET = new Set(REASONING_MODES);
-const REASONING_USAGE = 'Usage: omx reasoning <low|medium|high|xhigh>';
+const REASONING_USAGE = "Usage: omx reasoning <low|medium|high|xhigh>";
 const ALLOWED_SHELLS = new Set([
-    '/bin/sh', '/bin/bash', '/bin/zsh', '/bin/dash', '/bin/fish',
-    '/usr/bin/sh', '/usr/bin/bash', '/usr/bin/zsh', '/usr/bin/dash', '/usr/bin/fish',
-    '/usr/local/bin/bash', '/usr/local/bin/zsh', '/usr/local/bin/fish',
+    "/bin/sh",
+    "/bin/bash",
+    "/bin/zsh",
+    "/bin/dash",
+    "/bin/fish",
+    "/usr/bin/sh",
+    "/usr/bin/bash",
+    "/usr/bin/zsh",
+    "/usr/bin/dash",
+    "/usr/bin/fish",
+    "/usr/local/bin/bash",
+    "/usr/local/bin/zsh",
+    "/usr/local/bin/fish",
 ]);
 const WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS = 2500;
-const CODEX_VERSION_FLAGS = new Set(['--version', '-V']);
+const CODEX_VERSION_FLAGS = new Set(["--version", "-V"]);
 const NESTED_HELP_COMMANDS = new Set([
-    'ask',
-    'autoresearch',
-    'agents-init',
-    'deepinit',
-    'exec',
-    'hooks',
-    'hud',
-    'ralph',
-    'resume',
-    'session',
-    'sparkshell',
-    'team',
-    'tmux-hook',
+    "ask",
+    "cleanup",
+    "autoresearch",
+    "agents",
+    "agents-init",
+    "deepinit",
+    "exec",
+    "hooks",
+    "hud",
+    "ralph",
+    "ralphthon",
+    "ralphthon",
+    "resume",
+    "session",
+    "sparkshell",
+    "team",
+    "tmux-hook",
 ]);
 /**
  * Legacy scope values that may appear in persisted setup-scope.json files.
@@ -140,19 +163,19 @@ const NESTED_HELP_COMMANDS = new Set([
  * migrated to the current 'project' scope on read.
  */
 const LEGACY_SCOPE_MIGRATION_SYNC = {
-    'project-local': 'project',
+    "project-local": "project",
 };
 export function readPersistedSetupScope(cwd) {
     return readPersistedSetupPreferences(cwd)?.scope;
 }
 export function readPersistedSetupPreferences(cwd) {
-    const scopePath = join(cwd, '.omx', 'setup-scope.json');
+    const scopePath = join(cwd, ".omx", "setup-scope.json");
     if (!existsSync(scopePath))
         return undefined;
     try {
-        const parsed = JSON.parse(readFileSync(scopePath, 'utf-8'));
+        const parsed = JSON.parse(readFileSync(scopePath, "utf-8"));
         const persisted = {};
-        if (typeof parsed.scope === 'string') {
+        if (typeof parsed.scope === "string") {
             if (SETUP_SCOPES.includes(parsed.scope)) {
                 persisted.scope = parsed.scope;
             }
@@ -160,10 +183,6 @@ export function readPersistedSetupPreferences(cwd) {
             if (migrated)
                 persisted.scope = migrated;
         }
-        if (typeof parsed.skillTarget === 'string' &&
-            SETUP_SKILL_TARGETS.includes(parsed.skillTarget)) {
-            persisted.skillTarget = parsed.skillTarget;
-        }
         return Object.keys(persisted).length > 0 ? persisted : undefined;
     }
     catch (err) {
@@ -173,11 +192,11 @@ export function readPersistedSetupPreferences(cwd) {
     return undefined;
 }
 export function resolveCodexHomeForLaunch(cwd, env = process.env) {
-    if (env.CODEX_HOME && env.CODEX_HOME.trim() !== '')
+    if (env.CODEX_HOME && env.CODEX_HOME.trim() !== "")
         return env.CODEX_HOME;
     const persistedScope = readPersistedSetupScope(cwd);
-    if (persistedScope === 'project') {
-        return join(cwd, '.codex');
+    if (persistedScope === "project") {
+        return join(cwd, ".codex");
     }
     return undefined;
 }
@@ -185,17 +204,17 @@ export function resolveSetupScopeArg(args) {
     let value;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
-        if (arg === '--scope') {
+        if (arg === "--scope") {
             const next = args[index + 1];
-            if (!next || next.startsWith('-')) {
-                throw new Error(`Missing setup scope value after --scope. Expected one of: ${SETUP_SCOPES.join(', ')}`);
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup scope value after --scope. Expected one of: ${SETUP_SCOPES.join(", ")}`);
             }
             value = next;
             index += 1;
             continue;
         }
-        if (arg.startsWith('--scope=')) {
-            value = arg.slice('--scope='.length);
+        if (arg.startsWith("--scope=")) {
+            value = arg.slice("--scope=".length);
         }
     }
     if (!value)
@@ -203,51 +222,27 @@ export function resolveSetupScopeArg(args) {
     if (SETUP_SCOPES.includes(value)) {
         return value;
     }
-    throw new Error(`Invalid setup scope: ${value}. Expected one of: ${SETUP_SCOPES.join(', ')}`);
-}
-export function resolveSetupSkillTargetArg(args) {
-    let value;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '--skill-target') {
-            const next = args[index + 1];
-            if (!next || next.startsWith('-')) {
-                throw new Error(`Missing setup skill target value after --skill-target. Expected one of: ${SETUP_SKILL_TARGETS.join(', ')}`);
-            }
-            value = next;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--skill-target=')) {
-            value = arg.slice('--skill-target='.length);
-        }
-    }
-    if (!value)
-        return undefined;
-    if (SETUP_SKILL_TARGETS.includes(value)) {
-        return value;
-    }
-    throw new Error(`Invalid setup skill target: ${value}. Expected one of: ${SETUP_SKILL_TARGETS.join(', ')}`);
+    throw new Error(`Invalid setup scope: ${value}. Expected one of: ${SETUP_SCOPES.join(", ")}`);
 }
 export function resolveCliInvocation(args) {
     const firstArg = args[0];
-    if (firstArg === '--help' || firstArg === '-h') {
-        return { command: 'help', launchArgs: [] };
+    if (firstArg === "--help" || firstArg === "-h") {
+        return { command: "help", launchArgs: [] };
     }
-    if (firstArg === '--version' || firstArg === '-v') {
-        return { command: 'version', launchArgs: [] };
+    if (firstArg === "--version" || firstArg === "-v") {
+        return { command: "version", launchArgs: [] };
     }
-    if (!firstArg || firstArg.startsWith('--')) {
-        return { command: 'launch', launchArgs: firstArg ? args : [] };
+    if (!firstArg || firstArg.startsWith("--")) {
+        return { command: "launch", launchArgs: firstArg ? args : [] };
     }
-    if (firstArg === 'launch') {
-        return { command: 'launch', launchArgs: args.slice(1) };
+    if (firstArg === "launch") {
+        return { command: "launch", launchArgs: args.slice(1) };
     }
-    if (firstArg === 'exec') {
-        return { command: 'exec', launchArgs: args.slice(1) };
+    if (firstArg === "exec") {
+        return { command: "exec", launchArgs: args.slice(1) };
     }
-    if (firstArg === 'resume') {
-        return { command: 'resume', launchArgs: args.slice(1) };
+    if (firstArg === "resume") {
+        return { command: "resume", launchArgs: args.slice(1) };
     }
     return { command: firstArg, launchArgs: [] };
 }
@@ -259,65 +254,70 @@ export function commandOwnsLocalHelp(command) {
 }
 export function resolveCodexLaunchPolicy(env = process.env, _platform = process.platform, tmuxAvailable = isTmuxAvailable()) {
     if (env.TMUX)
-        return 'inside-tmux';
-    return tmuxAvailable ? 'detached-tmux' : 'direct';
+        return "inside-tmux";
+    return tmuxAvailable ? "detached-tmux" : "direct";
 }
 function hasErrnoCode(error, code) {
-    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === code);
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === code);
 }
 export function resolveSignalExitCode(signal) {
     if (!signal)
         return 1;
     const signalNumber = osConstants.signals[signal];
-    if (typeof signalNumber === 'number' && Number.isFinite(signalNumber)) {
+    if (typeof signalNumber === "number" && Number.isFinite(signalNumber)) {
         return 128 + signalNumber;
     }
     return 1;
 }
 export function classifyCodexExecFailure(error) {
-    if (!error || typeof error !== 'object') {
+    if (!error || typeof error !== "object") {
         return {
-            kind: 'launch-error',
+            kind: "launch-error",
             message: String(error),
         };
     }
     const err = error;
-    const code = typeof err.code === 'string' ? err.code : undefined;
-    const message = typeof err.message === 'string' && err.message.length > 0
+    const code = typeof err.code === "string" ? err.code : undefined;
+    const message = typeof err.message === "string" && err.message.length > 0
         ? err.message
-        : 'unknown codex launch failure';
-    const hasExitStatus = typeof err.status === 'number';
-    const hasSignal = typeof err.signal === 'string' && err.signal.length > 0;
+        : "unknown codex launch failure";
+    const hasExitStatus = typeof err.status === "number";
+    const hasSignal = typeof err.signal === "string" && err.signal.length > 0;
     if (hasExitStatus || hasSignal) {
         return {
-            kind: 'exit',
+            kind: "exit",
             code,
             message,
-            exitCode: hasExitStatus ? err.status : resolveSignalExitCode(err.signal),
+            exitCode: hasExitStatus
+                ? err.status
+                : resolveSignalExitCode(err.signal),
             signal: hasSignal ? err.signal : undefined,
         };
     }
     return {
-        kind: 'launch-error',
+        kind: "launch-error",
         code,
         message,
     };
 }
 function runCodexBlocking(cwd, launchArgs, codexEnv) {
-    const { result } = spawnPlatformCommandSync('codex', launchArgs, {
+    const { result } = spawnPlatformCommandSync("codex", launchArgs, {
         cwd,
-        stdio: 'inherit',
+        stdio: "inherit",
         env: codexEnv,
-        encoding: 'utf-8',
+        encoding: "utf-8",
     });
     if (result.error) {
         const errno = result.error;
         const kind = classifySpawnError(errno);
-        if (kind === 'missing') {
-            console.error('[omx] failed to launch codex: executable not found in PATH');
+        if (kind === "missing") {
+            console.error("[omx] failed to launch codex: executable not found in PATH");
         }
-        else if (kind === 'blocked') {
-            console.error(`[omx] failed to launch codex: executable is present but blocked in the current environment (${errno.code || 'blocked'})`);
+        else if (kind === "blocked") {
+            console.error(`[omx] failed to launch codex: executable is present but blocked in the current environment (${errno.code || "blocked"})`);
         }
         else {
             console.error(`[omx] failed to launch codex: ${errno.message}`);
@@ -325,9 +325,10 @@ function runCodexBlocking(cwd, launchArgs, codexEnv) {
         throw result.error;
     }
     if (result.status !== 0) {
-        process.exitCode = typeof result.status === 'number'
-            ? result.status
-            : resolveSignalExitCode(result.signal);
+        process.exitCode =
+            typeof result.status === "number"
+                ? result.status
+                : resolveSignalExitCode(result.signal);
         if (result.signal) {
             console.error(`[omx] codex exited due to signal ${result.signal}`);
         }
@@ -335,24 +336,24 @@ function runCodexBlocking(cwd, launchArgs, codexEnv) {
 }
 export function parseTmuxPaneSnapshot(output) {
     return output
-        .split('\n')
+        .split("\n")
         .map((line) => line.trim())
         .filter(Boolean)
         .map((line) => {
-        const [paneId = '', currentCommand = '', ...startCommandParts] = line.split('\t');
+        const [paneId = "", currentCommand = "", ...startCommandParts] = line.split("\t");
         return {
             paneId: paneId.trim(),
             currentCommand: currentCommand.trim(),
-            startCommand: startCommandParts.join('\t').trim(),
+            startCommand: startCommandParts.join("\t").trim(),
         };
     })
-        .filter((pane) => pane.paneId.startsWith('%'));
+        .filter((pane) => pane.paneId.startsWith("%"));
 }
 export function isHudWatchPane(pane) {
     const command = `${pane.startCommand} ${pane.currentCommand}`.toLowerCase();
-    return /\bhud\b/.test(command)
-        && /--watch\b/.test(command)
-        && (/\bomx(?:\.js)?\b/.test(command) || /\bnode\b/.test(command));
+    return (/\bhud\b/.test(command) &&
+        /--watch\b/.test(command) &&
+        (/\bomx(?:\.js)?\b/.test(command) || /\bnode\b/.test(command)));
 }
 export function findHudWatchPaneIds(panes, currentPaneId) {
     return panes
@@ -361,122 +362,158 @@ export function findHudWatchPaneIds(panes, currentPaneId) {
         .map((pane) => pane.paneId);
 }
 export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leaderPaneId) {
-    const targets = new Set(existingPaneIds.filter((id) => id.startsWith('%')));
-    if (createdPaneId && createdPaneId.startsWith('%')) {
+    const targets = new Set(existingPaneIds.filter((id) => id.startsWith("%")));
+    if (createdPaneId && createdPaneId.startsWith("%")) {
         targets.add(createdPaneId);
     }
     // Guard: never kill the leader's own pane under any circumstances.
-    if (leaderPaneId && leaderPaneId.startsWith('%')) {
+    if (leaderPaneId && leaderPaneId.startsWith("%")) {
         targets.delete(leaderPaneId);
     }
     return [...targets];
 }
 export async function main(args) {
     const knownCommands = new Set([
-        'launch', 'exec', 'setup', 'agents-init', 'deepinit', 'uninstall', 'doctor', 'ask', 'autoresearch', 'explore', 'sparkshell', 'team', 'ralph', 'session', 'resume', 'version', 'tmux-hook', 'hooks', 'hud', 'status', 'cancel', 'help', '--help', '-h',
+        "launch",
+        "exec",
+        "setup",
+        "agents",
+        "agents-init",
+        "deepinit",
+        "uninstall",
+        "doctor",
+        "cleanup",
+        "ask",
+        "autoresearch",
+        "explore",
+        "sparkshell",
+        "team",
+        "ralph",
+        "ralphthon",
+        "session",
+        "resume",
+        "version",
+        "tmux-hook",
+        "hooks",
+        "hud",
+        "status",
+        "cancel",
+        "help",
+        "--help",
+        "-h",
     ]);
     const firstArg = args[0];
     const { command, launchArgs } = resolveCliInvocation(args);
-    const flags = new Set(args.filter(a => a.startsWith('--')));
+    const flags = new Set(args.filter((a) => a.startsWith("--")));
     const options = {
-        force: flags.has('--force'),
-        dryRun: flags.has('--dry-run'),
-        verbose: flags.has('--verbose'),
-        team: flags.has('--team'),
+        force: flags.has("--force"),
+        dryRun: flags.has("--dry-run"),
+        verbose: flags.has("--verbose"),
+        team: flags.has("--team"),
     };
-    if (flags.has('--help') && !commandOwnsLocalHelp(command)) {
+    if (flags.has("--help") && !commandOwnsLocalHelp(command)) {
         console.log(HELP);
         return;
     }
     try {
         switch (command) {
-            case 'launch':
+            case "launch":
                 await launchWithHud(launchArgs);
                 break;
-            case 'resume':
-                await launchWithHud(['resume', ...launchArgs]);
+            case "resume":
+                await launchWithHud(["resume", ...launchArgs]);
                 break;
-            case 'setup':
+            case "setup":
                 await setup({
                     force: options.force,
                     dryRun: options.dryRun,
                     verbose: options.verbose,
                     scope: resolveSetupScopeArg(args.slice(1)),
-                    skillTarget: resolveSetupSkillTargetArg(args.slice(1)),
                 });
                 break;
-            case 'agents-init':
+            case "agents":
+                await agentsCommand(args.slice(1));
+                break;
+            case "agents-init":
                 await agentsInitCommand(args.slice(1));
                 break;
-            case 'deepinit':
+            case "deepinit":
                 await agentsInitCommand(args.slice(1));
                 break;
-            case 'uninstall':
+            case "uninstall":
                 await uninstall({
                     dryRun: options.dryRun,
-                    keepConfig: flags.has('--keep-config'),
+                    keepConfig: flags.has("--keep-config"),
                     verbose: options.verbose,
-                    purge: flags.has('--purge'),
+                    purge: flags.has("--purge"),
                     scope: resolveSetupScopeArg(args.slice(1)),
                 });
                 break;
-            case 'doctor': {
-                const { doctor } = await import('./doctor.js');
+            case "doctor": {
+                const { doctor } = await import("./doctor.js");
                 await doctor(options);
                 break;
             }
-            case 'ask':
+            case "ask":
                 await askCommand(args.slice(1));
                 break;
-            case 'autoresearch':
+            case "cleanup":
+                await cleanupCommand(args.slice(1));
+                break;
+            case "autoresearch":
                 await autoresearchCommand(args.slice(1));
                 break;
-            case 'explore':
+            case "explore":
                 await exploreCommand(args.slice(1));
                 break;
-            case 'exec':
+            case "exec":
                 await execWithOverlay(launchArgs);
                 break;
-            case 'sparkshell':
+            case "sparkshell":
                 await sparkshellCommand(args.slice(1));
                 break;
-            case 'team':
+            case "team":
                 await teamCommand(args.slice(1), options);
                 break;
-            case 'session':
+            case "session":
                 await sessionCommand(args.slice(1));
                 break;
-            case 'ralph':
+            case "ralph":
                 await ralphCommand(args.slice(1));
                 break;
-            case 'version':
+            case "ralphthon":
+                await ralphthonCommand(args.slice(1));
+                break;
+            case "version":
                 version();
                 break;
-            case 'hud':
+            case "hud":
                 await hudCommand(args.slice(1));
                 break;
-            case 'tmux-hook':
+            case "tmux-hook":
                 await tmuxHookCommand(args.slice(1));
                 break;
-            case 'hooks':
+            case "hooks":
                 await hooksCommand(args.slice(1));
                 break;
-            case 'status':
+            case "status":
                 await showStatus();
                 break;
-            case 'cancel':
+            case "cancel":
                 await cancelModes();
                 break;
-            case 'reasoning':
+            case "reasoning":
                 await reasoningCommand(args.slice(1));
                 break;
-            case 'help':
-            case '--help':
-            case '-h':
+            case "help":
+            case "--help":
+            case "-h":
                 console.log(HELP);
                 break;
             default:
-                if (firstArg && firstArg.startsWith('-') && !knownCommands.has(firstArg)) {
+                if (firstArg &&
+                    firstArg.startsWith("-") &&
+                    !knownCommands.has(firstArg)) {
                     await launchWithHud(args);
                     break;
                 }
@@ -491,17 +528,17 @@ export async function main(args) {
     }
 }
 async function showStatus() {
-    const { readFile } = await import('fs/promises');
+    const { readFile } = await import("fs/promises");
     const cwd = process.cwd();
     try {
         const refs = await listModeStateFilesWithScopePreference(cwd);
         const states = refs.map((ref) => ref.path);
         if (states.length === 0) {
-            console.log('No active modes.');
+            console.log("No active modes.");
             return;
         }
         for (const path of states) {
-            const content = await readFile(path, 'utf-8');
+            const content = await readFile(path, "utf-8");
             let state;
             try {
                 state = JSON.parse(content);
@@ -511,13 +548,13 @@ async function showStatus() {
                 continue;
             }
             const file = basename(path);
-            const mode = file.replace('-state.json', '');
-            console.log(`${mode}: ${state.active === true ? 'ACTIVE' : 'inactive'} (phase: ${String(state.current_phase || 'n/a')})`);
+            const mode = file.replace("-state.json", "");
+            console.log(`${mode}: ${state.active === true ? "ACTIVE" : "inactive"} (phase: ${String(state.current_phase || "n/a")})`);
         }
     }
     catch (err) {
         process.stderr.write(`[cli/index] operation failed: ${err}\n`);
-        console.log('No active modes.');
+        console.log("No active modes.");
     }
 }
 async function reasoningCommand(args) {
@@ -529,8 +566,8 @@ async function reasoningCommand(args) {
             console.log(REASONING_USAGE);
             return;
         }
-        const { readFile } = await import('fs/promises');
-        const content = await readFile(configPath, 'utf-8');
+        const { readFile } = await import("fs/promises");
+        const content = await readFile(configPath, "utf-8");
         const current = readTopLevelTomlString(content, REASONING_KEY);
         if (current) {
             console.log(`Current ${REASONING_KEY}: ${current}`);
@@ -541,37 +578,39 @@ async function reasoningCommand(args) {
         return;
     }
     if (!REASONING_MODE_SET.has(mode)) {
-        throw new Error(`Invalid reasoning mode "${mode}". Expected one of: ${REASONING_MODES.join(', ')}.\n${REASONING_USAGE}`);
+        throw new Error(`Invalid reasoning mode "${mode}". Expected one of: ${REASONING_MODES.join(", ")}.\n${REASONING_USAGE}`);
     }
-    const { mkdir, readFile, writeFile } = await import('fs/promises');
+    const { mkdir, readFile, writeFile } = await import("fs/promises");
     await mkdir(dirname(configPath), { recursive: true });
-    const existing = existsSync(configPath) ? await readFile(configPath, 'utf-8') : '';
+    const existing = existsSync(configPath)
+        ? await readFile(configPath, "utf-8")
+        : "";
     const updated = upsertTopLevelTomlString(existing, REASONING_KEY, mode);
     await writeFile(configPath, updated);
     console.log(`Set ${REASONING_KEY}="${mode}" in ${configPath}`);
 }
 export async function launchWithHud(args) {
     if (isNativeWindows()) {
-        const { result } = spawnPlatformCommandSync('tmux', ['-V'], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
+        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');
+            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 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();
@@ -584,7 +623,7 @@ export async function launchWithHud(args) {
     if (parsedWorktree.mode.enabled) {
         const planned = planWorktreeTarget({
             cwd: launchCwd,
-            scope: 'launch',
+            scope: "launch",
             mode: parsedWorktree.mode,
         });
         const ensured = ensureWorktree(planned);
@@ -614,7 +653,7 @@ export async function launchWithHud(args) {
     try {
         const repaired = await repairConfigIfNeeded(codexConfigPath(), getPackageRoot());
         if (repaired) {
-            console.log('[omx] Repaired duplicate [tui] section in config.toml.');
+            console.log("[omx] Repaired duplicate [tui] section in config.toml.");
         }
     }
     catch {
@@ -650,7 +689,7 @@ export async function execWithOverlay(args) {
     if (parsedWorktree.mode.enabled) {
         const planned = planWorktreeTarget({
             cwd: launchCwd,
-            scope: 'launch',
+            scope: "launch",
             mode: parsedWorktree.mode,
         });
         const ensured = ensureWorktree(planned);
@@ -674,7 +713,7 @@ export async function execWithOverlay(args) {
     try {
         const repaired = await repairConfigIfNeeded(codexConfigPath(), getPackageRoot());
         if (repaired) {
-            console.log('[omx] Repaired duplicate [tui] section in config.toml.');
+            console.log("[omx] Repaired duplicate [tui] section in config.toml.");
         }
     }
     catch {
@@ -690,12 +729,15 @@ export async function execWithOverlay(args) {
         const notifyTempContractRaw = notifyTempResult.contract.active
             ? serializeNotifyTempContract(notifyTempResult.contract)
             : null;
-        const codexArgs = injectModelInstructionsBypassArgs(cwd, ['exec', ...normalizedArgs], process.env, sessionModelInstructionsPath(cwd, sessionId));
+        const codexArgs = injectModelInstructionsBypassArgs(cwd, ["exec", ...normalizedArgs], process.env, sessionModelInstructionsPath(cwd, sessionId));
         const codexEnvBase = codexHomeOverride
             ? { ...process.env, CODEX_HOME: codexHomeOverride }
             : process.env;
         const codexEnv = notifyTempContractRaw
-            ? { ...codexEnvBase, [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw }
+            ? {
+                ...codexEnvBase,
+                [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw,
+            }
             : codexEnvBase;
         runCodexBlocking(cwd, codexArgs, codexEnv);
     }
@@ -723,11 +765,11 @@ export function normalizeCodexLaunchArgs(args) {
             continue;
         }
         if (arg === HIGH_REASONING_FLAG) {
-            reasoningMode = 'high';
+            reasoningMode = "high";
             continue;
         }
         if (arg === XHIGH_REASONING_FLAG) {
-            reasoningMode = 'xhigh';
+            reasoningMode = "xhigh";
             continue;
         }
         if (arg === SPARK_FLAG) {
@@ -770,7 +812,8 @@ function hasModelInstructionsOverride(args) {
         const arg = args[i];
         if (arg === CONFIG_FLAG || arg === LONG_CONFIG_FLAG) {
             const maybeValue = args[i + 1];
-            if (typeof maybeValue === 'string' && isModelInstructionsOverride(maybeValue)) {
+            if (typeof maybeValue === "string" &&
+                isModelInstructionsOverride(maybeValue)) {
                 return true;
             }
             continue;
@@ -784,18 +827,20 @@ function hasModelInstructionsOverride(args) {
     return false;
 }
 function shouldBypassDefaultSystemPrompt(env) {
-    return env[OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV] !== '0';
+    return env[OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV] !== "0";
 }
 function buildModelInstructionsOverride(cwd, env, defaultFilePath) {
-    const filePath = env[OMX_MODEL_INSTRUCTIONS_FILE_ENV] || defaultFilePath || join(cwd, 'AGENTS.md');
+    const filePath = env[OMX_MODEL_INSTRUCTIONS_FILE_ENV] ||
+        defaultFilePath ||
+        join(cwd, "AGENTS.md");
     return `${MODEL_INSTRUCTIONS_FILE_KEY}="${escapeTomlString(filePath)}"`;
 }
 function tryReadGitValue(cwd, args) {
     try {
-        const value = execFileSync('git', args, {
+        const value = execFileSync("git", args, {
             cwd,
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
             timeout: 2000,
         }).trim();
         return value || undefined;
@@ -814,9 +859,9 @@ function extractIssueNumber(text) {
 function resolveNativeSessionName(cwd, sessionId) {
     if (process.env.TMUX) {
         try {
-            const tmuxSession = execFileSync('tmux', ['display-message', '-p', '#S'], {
-                encoding: 'utf-8',
-                stdio: ['ignore', 'pipe', 'ignore'],
+            const tmuxSession = execFileSync("tmux", ["display-message", "-p", "#S"], {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
                 timeout: 2000,
             }).trim();
             if (tmuxSession)
@@ -829,9 +874,9 @@ function resolveNativeSessionName(cwd, sessionId) {
     return buildTmuxSessionName(cwd, sessionId);
 }
 function buildNativeHookBaseContext(cwd, sessionId, normalizedEvent, extra = {}) {
-    const repoPath = tryReadGitValue(cwd, ['rev-parse', '--show-toplevel']) || cwd;
-    const branch = tryReadGitValue(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
-    const issueNumber = extractIssueNumber([branch, basename(cwd)].filter(Boolean).join(' '));
+    const repoPath = tryReadGitValue(cwd, ["rev-parse", "--show-toplevel"]) || cwd;
+    const branch = tryReadGitValue(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const issueNumber = extractIssueNumber([branch, basename(cwd)].filter(Boolean).join(" "));
     return {
         normalized_event: normalizedEvent,
         session_name: resolveNativeSessionName(cwd, sessionId),
@@ -848,13 +893,19 @@ export function injectModelInstructionsBypassArgs(cwd, args, env = process.env,
         return [...args];
     if (hasModelInstructionsOverride(args))
         return [...args];
-    return [...args, CONFIG_FLAG, buildModelInstructionsOverride(cwd, env, defaultFilePath)];
+    return [
+        ...args,
+        CONFIG_FLAG,
+        buildModelInstructionsOverride(cwd, env, defaultFilePath),
+    ];
 }
 export function collectInheritableTeamWorkerArgs(codexArgs) {
     return collectInheritableTeamWorkerArgsShared(codexArgs);
 }
 export function resolveTeamWorkerLaunchArgsEnv(existingRaw, codexArgs, inheritLeaderFlags = true, defaultModel) {
-    const inheritedArgs = inheritLeaderFlags ? collectInheritableTeamWorkerArgs(codexArgs) : [];
+    const inheritedArgs = inheritLeaderFlags
+        ? collectInheritableTeamWorkerArgs(codexArgs)
+        : [];
     const normalized = resolveTeamWorkerLaunchArgs({
         existingRaw,
         inheritedArgs,
@@ -862,14 +913,14 @@ export function resolveTeamWorkerLaunchArgsEnv(existingRaw, codexArgs, inheritLe
     });
     if (normalized.length === 0)
         return null;
-    return normalized.join(' ');
+    return normalized.join(" ");
 }
 export function readTopLevelTomlString(content, key) {
     let inTopLevel = true;
     const lines = content.split(/\r?\n/);
     for (const line of lines) {
         const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
+        if (!trimmed || trimmed.startsWith("#"))
             continue;
         if (/^\[[^[\]]+\]\s*(#.*)?$/.test(trimmed)) {
             inTopLevel = false;
@@ -885,7 +936,7 @@ export function readTopLevelTomlString(content, key) {
     return null;
 }
 export function upsertTopLevelTomlString(content, key, value) {
-    const eol = content.includes('\r\n') ? '\r\n' : '\n';
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
     const assignment = `${key} = "${escapeTomlString(value)}"`;
     if (!content.trim()) {
         return assignment + eol;
@@ -896,7 +947,7 @@ export function upsertTopLevelTomlString(content, key, value) {
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
+        if (!trimmed || trimmed.startsWith("#"))
             continue;
         if (/^\[[^[\]]+\]\s*(#.*)?$/.test(trimmed)) {
             inTopLevel = false;
@@ -912,7 +963,7 @@ export function upsertTopLevelTomlString(content, key, value) {
         }
     }
     if (!replaced) {
-        const firstTableIndex = lines.findIndex(line => /^\s*\[[^[\]]+\]\s*(#.*)?$/.test(line.trim()));
+        const firstTableIndex = lines.findIndex((line) => /^\s*\[[^[\]]+\]\s*(#.*)?$/.test(line.trim()));
         if (firstTableIndex >= 0) {
             lines.splice(firstTableIndex, 0, assignment);
         }
@@ -930,43 +981,54 @@ function parseTomlStringValue(value) {
     if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
         return trimmed.slice(1, -1);
     }
-    if (trimmed.startsWith('\'') && trimmed.endsWith('\'') && trimmed.length >= 2) {
+    if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
         return trimmed.slice(1, -1);
     }
     return trimmed;
 }
 function escapeTomlString(value) {
-    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 function sanitizeTmuxToken(value) {
-    const cleaned = value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-    return cleaned || 'unknown';
+    const cleaned = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return cleaned || "unknown";
 }
 export function buildTmuxSessionName(cwd, sessionId) {
-    const parentDir = basename(dirname(cwd));
+    const parentPath = dirname(cwd);
+    const parentDir = basename(parentPath);
     const dirName = basename(cwd);
-    const dirToken = parentDir.endsWith('.omx-worktrees')
-        ? sanitizeTmuxToken(`${parentDir.slice(0, -'.omx-worktrees'.length)}-${dirName}`)
+    const grandparentPath = dirname(parentPath);
+    const grandparentDir = basename(grandparentPath);
+    const repoDir = parentDir.endsWith(".omx-worktrees")
+        ? parentDir.slice(0, -".omx-worktrees".length)
+        : parentDir === "worktrees" && grandparentDir === ".omx"
+            ? basename(dirname(grandparentPath))
+            : null;
+    const dirToken = repoDir
+        ? sanitizeTmuxToken(`${repoDir}-${dirName}`)
         : sanitizeTmuxToken(dirName);
-    let branchToken = 'detached';
-    const branch = tryReadGitValue(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    let branchToken = "detached";
+    const branch = tryReadGitValue(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
     if (branch)
         branchToken = sanitizeTmuxToken(branch);
-    const sessionToken = sanitizeTmuxToken(sessionId.replace(/^omx-/, ''));
+    const sessionToken = sanitizeTmuxToken(sessionId.replace(/^omx-/, ""));
     const name = `omx-${dirToken}-${branchToken}-${sessionToken}`;
     return name.length > 120 ? name.slice(0, 120) : name;
 }
 function parsePaneIdFromTmuxOutput(rawOutput) {
-    const paneId = rawOutput.split('\n')[0]?.trim() || '';
-    return paneId.startsWith('%') ? paneId : null;
+    const paneId = rawOutput.split("\n")[0]?.trim() || "";
+    return paneId.startsWith("%") ? paneId : null;
 }
 function parseWindowIndexFromTmuxOutput(rawOutput) {
-    const windowIndex = rawOutput.split('\n')[0]?.trim() || '';
+    const windowIndex = rawOutput.split("\n")[0]?.trim() || "";
     return /^[0-9]+$/.test(windowIndex) ? windowIndex : null;
 }
 function detectDetachedSessionWindowIndex(sessionName) {
     try {
-        const output = execFileSync('tmux', ['display-message', '-p', '-t', sessionName, '#{window_index}'], { encoding: 'utf-8' });
+        const output = execFileSync("tmux", ["display-message", "-p", "-t", sessionName, "#{window_index}"], { encoding: "utf-8" });
         return parseWindowIndexFromTmuxOutput(output);
     }
     catch (err) {
@@ -976,87 +1038,146 @@ function detectDetachedSessionWindowIndex(sessionName) {
 }
 export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false) {
     const newSessionArgs = [
-        'new-session', '-d', '-s', sessionName, '-c', cwd,
-        ...(workerLaunchArgs ? ['-e', `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`] : []),
-        ...(codexHomeOverride ? ['-e', `CODEX_HOME=${codexHomeOverride}`] : []),
-        ...(notifyTempContractRaw ? ['-e', `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`] : []),
-        nativeWindows ? 'powershell.exe' : codexCmd,
+        "new-session",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-s",
+        sessionName,
+        "-c",
+        cwd,
+        ...(workerLaunchArgs
+            ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`]
+            : []),
+        ...(codexHomeOverride ? ["-e", `CODEX_HOME=${codexHomeOverride}`] : []),
+        ...(notifyTempContractRaw
+            ? ["-e", `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`]
+            : []),
+        nativeWindows ? "powershell.exe" : codexCmd,
     ];
     const splitCaptureArgs = [
-        'split-window', '-v', '-l', String(HUD_TMUX_HEIGHT_LINES), '-d', '-t', sessionName,
-        '-c', cwd, '-P', '-F', '#{pane_id}', hudCmd,
+        "split-window",
+        "-v",
+        "-l",
+        String(HUD_TMUX_HEIGHT_LINES),
+        "-d",
+        "-t",
+        sessionName,
+        "-c",
+        cwd,
+        "-P",
+        "-F",
+        "#{pane_id}",
+        hudCmd,
     ];
     return [
-        { name: 'new-session', args: newSessionArgs },
-        { name: 'split-and-capture-hud-pane', args: splitCaptureArgs },
+        { name: "new-session", args: newSessionArgs },
+        { name: "split-and-capture-hud-pane", args: splitCaptureArgs },
     ];
 }
+async function updateActiveRalphthonLaunchTarget(cwd, patch) {
+    const state = await readModeState("ralphthon", cwd).catch(() => null);
+    if (!state || state.active !== true)
+        return;
+    const next = {};
+    if (typeof patch.leader_pane_id === "string" &&
+        patch.leader_pane_id.trim().startsWith("%")) {
+        next.leader_pane_id = patch.leader_pane_id.trim();
+        next.tmux_pane_id = patch.leader_pane_id.trim();
+    }
+    else if (typeof patch.tmux_pane_id === "string" &&
+        patch.tmux_pane_id.trim().startsWith("%")) {
+        next.tmux_pane_id = patch.tmux_pane_id.trim();
+    }
+    if (typeof patch.tmux_session === "string" &&
+        patch.tmux_session.trim() !== "") {
+        next.tmux_session = patch.tmux_session.trim();
+    }
+    if (Object.keys(next).length === 0)
+        return;
+    await updateModeState("ralphthon", next, cwd).catch(() => { });
+}
+async function readLaunchAppendInstructions() {
+    const appendixCandidates = [
+        process.env[OMX_RALPH_APPEND_INSTRUCTIONS_FILE_ENV]?.trim(),
+        process.env[OMX_RALPHTHON_APPEND_INSTRUCTIONS_FILE_ENV]?.trim(),
+        process.env[OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV]?.trim(),
+    ].filter((value) => typeof value === "string" && value.length > 0);
+    if (appendixCandidates.length === 0)
+        return "";
+    const appendixPath = appendixCandidates[0];
+    if (!existsSync(appendixPath)) {
+        throw new Error(`launch instructions file not found: ${appendixPath}`);
+    }
+    const { readFile } = await import("fs/promises");
+    return (await readFile(appendixPath, "utf-8")).trim();
+}
 export function buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, enableMouse, nativeWindows = false) {
     const steps = [];
     if (!nativeWindows && hudPaneId && hookWindowIndex) {
         const hookTarget = buildResizeHookTarget(sessionName, hookWindowIndex);
-        const hookName = buildResizeHookName('launch', sessionName, hookWindowIndex, hudPaneId);
-        const clientAttachedHookName = buildClientAttachedReconcileHookName('launch', sessionName, hookWindowIndex, hudPaneId);
+        const hookName = buildResizeHookName("launch", sessionName, hookWindowIndex, hudPaneId);
+        const clientAttachedHookName = buildClientAttachedReconcileHookName("launch", sessionName, hookWindowIndex, hudPaneId);
         steps.push({
-            name: 'register-resize-hook',
+            name: "register-resize-hook",
             args: buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId, HUD_TMUX_HEIGHT_LINES),
         });
         steps.push({
-            name: 'register-client-attached-reconcile',
+            name: "register-client-attached-reconcile",
             args: buildRegisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName, hudPaneId, HUD_TMUX_HEIGHT_LINES),
         });
         steps.push({
-            name: 'schedule-delayed-resize',
+            name: "schedule-delayed-resize",
             args: buildScheduleDelayedHudResizeArgs(hudPaneId, undefined, HUD_TMUX_HEIGHT_LINES),
         });
         steps.push({
-            name: 'reconcile-hud-resize',
+            name: "reconcile-hud-resize",
             args: buildReconcileHudResizeArgs(hudPaneId, HUD_TMUX_HEIGHT_LINES),
         });
     }
     if (enableMouse) {
-        steps.push({ name: 'set-mouse', args: ['set-option', '-t', sessionName, 'mouse', 'on'] });
+        steps.push({
+            name: "set-mouse",
+            args: ["set-option", "-t", sessionName, "mouse", "on"],
+        });
     }
-    steps.push({ name: 'attach-session', args: ['attach-session', '-t', sessionName] });
+    steps.push({
+        name: "attach-session",
+        args: ["attach-session", "-t", sessionName],
+    });
     return steps;
 }
 export function buildDetachedSessionRollbackSteps(sessionName, hookTarget, hookName, clientAttachedHookName) {
     const steps = [];
     if (hookTarget && clientAttachedHookName) {
         steps.push({
-            name: 'unregister-client-attached-reconcile',
+            name: "unregister-client-attached-reconcile",
             args: buildUnregisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName),
         });
     }
     if (hookTarget && hookName) {
         steps.push({
-            name: 'unregister-resize-hook',
+            name: "unregister-resize-hook",
             args: buildUnregisterResizeHookArgs(hookTarget, hookName),
         });
     }
-    steps.push({ name: 'kill-session', args: ['kill-session', '-t', sessionName] });
+    steps.push({
+        name: "kill-session",
+        args: ["kill-session", "-t", sessionName],
+    });
     return steps;
 }
-async function readAutoresearchAppendInstructions() {
-    const appendixPath = process.env[OMX_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV]?.trim();
-    if (!appendixPath)
-        return '';
-    if (!existsSync(appendixPath)) {
-        throw new Error(`autoresearch instructions file not found: ${appendixPath}`);
-    }
-    const { readFile } = await import('fs/promises');
-    return (await readFile(appendixPath, 'utf-8')).trim();
-}
 export function buildNotifyTempStartupMessages(contract, hasValidProviders) {
     const providers = contract.canonicalSelectors.length > 0
-        ? contract.canonicalSelectors.join(',')
-        : 'none';
+        ? contract.canonicalSelectors.join(",")
+        : "none";
     const infoLines = [
         `notify temp: active | providers=${providers} | persistent-routing=bypassed`,
     ];
     const warningLines = [...contract.warnings];
     if (!hasValidProviders) {
-        warningLines.push('notify temp: no valid providers resolved; notifications skipped');
+        warningLines.push("notify temp: no valid providers resolved; notifications skipped");
     }
     return { infoLines, warningLines };
 }
@@ -1076,9 +1197,9 @@ async function preLaunch(cwd, sessionId, notifyTempContract) {
         catch (err) {
             process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         }
-        const { unlink } = await import('fs/promises');
+        const { unlink } = await import("fs/promises");
         try {
-            await unlink(join(cwd, '.omx', 'state', 'session.json'));
+            await unlink(join(cwd, ".omx", "state", "session.json"));
         }
         catch (err) {
             process.stderr.write(`[cli/index] operation failed: ${err}\n`);
@@ -1087,11 +1208,11 @@ async function preLaunch(cwd, sessionId, notifyTempContract) {
     // 2. Generate runtime overlay + write session-scoped model instructions file
     const orchestrationMode = await resolveSessionOrchestrationMode(cwd, sessionId);
     const overlay = await generateOverlay(cwd, sessionId, { orchestrationMode });
-    const autoresearchAppendix = await readAutoresearchAppendInstructions();
-    const sessionInstructions = autoresearchAppendix
+    const launchAppendix = await readLaunchAppendInstructions();
+    const sessionInstructions = launchAppendix.trim().length > 0
         ? `${overlay}
 
-${autoresearchAppendix}`
+${launchAppendix}`
         : overlay;
     await writeSessionModelInstructionsFile(cwd, sessionId, sessionInstructions);
     // 3. Write session state
@@ -1116,8 +1237,9 @@ ${autoresearchAppendix}`
     // 6. Emit temp notification startup summary + warnings, then send session-start lifecycle notification (best effort)
     try {
         if (notifyTempContract?.active) {
-            process.env[OMX_NOTIFY_TEMP_CONTRACT_ENV] = serializeNotifyTempContract(notifyTempContract);
-            const { getNotificationConfig } = await import('../notifications/config.js');
+            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) {
@@ -1130,8 +1252,8 @@ ${autoresearchAppendix}`
         else {
             delete process.env[OMX_NOTIFY_TEMP_CONTRACT_ENV];
         }
-        const { notifyLifecycle } = await import('../notifications/index.js');
-        await notifyLifecycle('session-start', {
+        const { notifyLifecycle } = await import("../notifications/index.js");
+        await notifyLifecycle("session-start", {
             sessionId,
             projectPath: cwd,
             projectName: basename(cwd),
@@ -1143,12 +1265,12 @@ ${autoresearchAppendix}`
     }
     // 7. Dispatch native hook event (best effort)
     try {
-        await emitNativeHookEvent(cwd, 'session-start', {
+        await emitNativeHookEvent(cwd, "session-start", {
             session_id: sessionId,
-            context: buildNativeHookBaseContext(cwd, sessionId, 'started', {
+            context: buildNativeHookBaseContext(cwd, sessionId, "started", {
                 project_path: cwd,
                 project_name: basename(cwd),
-                status: 'started',
+                status: "started",
             }),
         });
     }
@@ -1166,9 +1288,9 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
     const nativeWindows = isNativeWindows();
     const omxBin = process.argv[1];
     const hudCmd = nativeWindows
-        ? buildWindowsPromptCommand('node', [omxBin, 'hud', '--watch'])
-        : buildTmuxPaneCommand('node', [omxBin, 'hud', '--watch']);
-    const inheritLeaderFlags = process.env[TEAM_INHERIT_LEADER_FLAGS_ENV] !== '0';
+        ? buildWindowsPromptCommand("node", [omxBin, "hud", "--watch"])
+        : buildTmuxPaneCommand("node", [omxBin, "hud", "--watch"]);
+    const inheritLeaderFlags = process.env[TEAM_INHERIT_LEADER_FLAGS_ENV] !== "0";
     const workerLaunchArgs = resolveTeamWorkerLaunchArgsEnv(process.env[TEAM_WORKER_LAUNCH_ARGS_ENV], launchArgs, inheritLeaderFlags, workerDefaultModel);
     const codexBaseEnv = codexHomeOverride
         ? { ...process.env, CODEX_HOME: codexHomeOverride }
@@ -1184,7 +1306,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
         runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
         return;
     }
-    if (launchPolicy === 'inside-tmux') {
+    if (launchPolicy === "inside-tmux") {
         // Already in tmux: launch codex in current pane, HUD in bottom split
         const currentPaneId = process.env.TMUX_PANE;
         const staleHudPaneIds = listHudWatchPaneIdsInCurrentWindow(currentPaneId);
@@ -1202,13 +1324,15 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
         // Enable mouse scrolling at session start so scroll works before team
         // expansion. Previously this was only called from createTeamSession().
         // Opt-out: set OMX_MOUSE=0. (closes #128)
-        if (process.env.OMX_MOUSE !== '0') {
+        if (process.env.OMX_MOUSE !== "0") {
             try {
                 const tmuxPaneTarget = process.env.TMUX_PANE;
                 const displayArgs = tmuxPaneTarget
-                    ? ['display-message', '-p', '-t', tmuxPaneTarget, '#S']
-                    : ['display-message', '-p', '#S'];
-                const tmuxSession = execFileSync('tmux', displayArgs, { encoding: 'utf-8' }).trim();
+                    ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+                    : ["display-message", "-p", "#S"];
+                const tmuxSession = execFileSync("tmux", displayArgs, {
+                    encoding: "utf-8",
+                }).trim();
                 if (tmuxSession)
                     enableMouseScrolling(tmuxSession);
             }
@@ -1217,6 +1341,22 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
                 // Non-fatal: mouse scrolling is a convenience feature
             }
         }
+        const activePaneId = process.env.TMUX_PANE?.trim();
+        if (activePaneId) {
+            let tmuxSessionName;
+            try {
+                const displayArgs = ["display-message", "-p", "-t", activePaneId, "#S"];
+                tmuxSessionName =
+                    execFileSync("tmux", displayArgs, { encoding: "utf-8" }).trim() ||
+                        undefined;
+            }
+            catch { }
+            void updateActiveRalphthonLaunchTarget(cwd, {
+                leader_pane_id: activePaneId,
+                tmux_pane_id: activePaneId,
+                tmux_session: tmuxSessionName ?? null,
+            });
+        }
         try {
             runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
         }
@@ -1227,62 +1367,77 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
             }
         }
     }
-    else if (launchPolicy === 'direct') {
+    else if (launchPolicy === "direct") {
         // Detached HUD sessions require tmux. Skip the bootstrap entirely when the
         // binary is unavailable so direct launches do not emit noisy ENOENT logs.
         runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
     }
     else {
         // Not in tmux: create a new tmux session with codex + HUD pane
-        const codexCmd = buildTmuxPaneCommand('codex', launchArgs);
+        const codexCmd = buildTmuxPaneCommand("codex", launchArgs);
         const detachedWindowsCodexCmd = nativeWindows
-            ? buildWindowsPromptCommand('codex', launchArgs)
+            ? buildWindowsPromptCommand("codex", launchArgs)
             : null;
         const tmuxSessionId = `omx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const sessionName = buildTmuxSessionName(cwd, tmuxSessionId);
         let createdDetachedSession = false;
+        let detachedLeaderPaneId = null;
         let registeredHookTarget = null;
         let registeredHookName = null;
         let registeredClientAttachedHookName = null;
         try {
             const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows);
             for (const step of bootstrapSteps) {
-                const output = execFileSync('tmux', step.args, { stdio: step.name === 'new-session' ? 'ignore' : 'pipe', encoding: 'utf-8' });
-                if (step.name === 'new-session') {
+                const output = execFileSync("tmux", step.args, {
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+                if (step.name === "new-session") {
                     createdDetachedSession = true;
+                    detachedLeaderPaneId = parsePaneIdFromTmuxOutput(output || "");
+                    void updateActiveRalphthonLaunchTarget(cwd, {
+                        leader_pane_id: detachedLeaderPaneId,
+                        tmux_pane_id: detachedLeaderPaneId,
+                        tmux_session: sessionName,
+                    });
                 }
-                if (step.name === 'split-and-capture-hud-pane') {
-                    const hudPaneId = parsePaneIdFromTmuxOutput(output || '');
-                    const hookWindowIndex = hudPaneId ? detectDetachedSessionWindowIndex(sessionName) : null;
+                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)
+                        ? buildResizeHookName("launch", sessionName, hookWindowIndex, hudPaneId)
                         : null;
                     const clientAttachedHookName = hudPaneId && hookWindowIndex
-                        ? buildClientAttachedReconcileHookName('launch', sessionName, hookWindowIndex, hudPaneId)
+                        ? buildClientAttachedReconcileHookName("launch", sessionName, hookWindowIndex, hudPaneId)
                         : null;
-                    const finalizeSteps = buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, process.env.OMX_MOUSE !== '0', nativeWindows);
+                    const finalizeSteps = buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, process.env.OMX_MOUSE !== "0", nativeWindows);
                     if (nativeWindows && detachedWindowsCodexCmd) {
                         scheduleDetachedWindowsCodexLaunch(sessionName, detachedWindowsCodexCmd);
                     }
                     for (const finalizeStep of finalizeSteps) {
-                        const stdio = finalizeStep.name === 'attach-session' ? 'inherit' : 'ignore';
+                        const stdio = finalizeStep.name === "attach-session" ? "inherit" : "ignore";
                         try {
-                            execFileSync('tmux', finalizeStep.args, { stdio });
+                            execFileSync("tmux", finalizeStep.args, { stdio });
                         }
                         catch (err) {
                             process.stderr.write(`[cli/index] operation failed: ${err}\n`);
-                            if (finalizeStep.name === 'attach-session')
-                                throw new Error('failed to attach detached tmux session');
+                            if (finalizeStep.name === "attach-session")
+                                throw new Error("failed to attach detached tmux session");
                             continue;
                         }
-                        if (finalizeStep.name === 'register-resize-hook' && hookTarget && hookName) {
+                        if (finalizeStep.name === "register-resize-hook" &&
+                            hookTarget &&
+                            hookName) {
                             registeredHookTarget = hookTarget;
                             registeredHookName = hookName;
                         }
-                        if (finalizeStep.name === 'register-client-attached-reconcile' && clientAttachedHookName) {
+                        if (finalizeStep.name === "register-client-attached-reconcile" &&
+                            clientAttachedHookName) {
                             registeredClientAttachedHookName = clientAttachedHookName;
                         }
                     }
@@ -1295,7 +1450,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
                 const rollbackSteps = buildDetachedSessionRollbackSteps(sessionName, registeredHookTarget, registeredHookName, registeredClientAttachedHookName);
                 for (const rollbackStep of rollbackSteps) {
                     try {
-                        execFileSync('tmux', rollbackStep.args, { stdio: 'ignore' });
+                        execFileSync("tmux", rollbackStep.args, { stdio: "ignore" });
                     }
                     catch (err) {
                         process.stderr.write(`[cli/index] operation failed: ${err}\n`);
@@ -1310,7 +1465,11 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, n
 }
 function listHudWatchPaneIdsInCurrentWindow(currentPaneId) {
     try {
-        const output = execFileSync('tmux', ['list-panes', '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}'], { encoding: 'utf-8' });
+        const output = execFileSync("tmux", [
+            "list-panes",
+            "-F",
+            "#{pane_id}\t#{pane_current_command}\t#{pane_start_command}",
+        ], { encoding: "utf-8" });
         return findHudWatchPaneIds(parseTmuxPaneSnapshot(output), currentPaneId);
     }
     catch (err) {
@@ -1319,14 +1478,26 @@ function listHudWatchPaneIdsInCurrentWindow(currentPaneId) {
     }
 }
 function createHudWatchPane(cwd, hudCmd) {
-    const output = execFileSync('tmux', ['split-window', '-v', '-l', String(HUD_TMUX_HEIGHT_LINES), '-d', '-c', cwd, '-P', '-F', '#{pane_id}', hudCmd], { encoding: 'utf-8' });
+    const output = execFileSync("tmux", [
+        "split-window",
+        "-v",
+        "-l",
+        String(HUD_TMUX_HEIGHT_LINES),
+        "-d",
+        "-c",
+        cwd,
+        "-P",
+        "-F",
+        "#{pane_id}",
+        hudCmd,
+    ], { encoding: "utf-8" });
     return parsePaneIdFromTmuxOutput(output);
 }
 function killTmuxPane(paneId) {
-    if (!paneId.startsWith('%'))
+    if (!paneId.startsWith("%"))
         return;
     try {
-        execFileSync('tmux', ['kill-pane', '-t', paneId], { stdio: 'ignore' });
+        execFileSync("tmux", ["kill-pane", "-t", paneId], { stdio: "ignore" });
     }
     catch (err) {
         process.stderr.write(`[cli/index] operation failed: ${err}\n`);
@@ -1334,20 +1505,24 @@ function killTmuxPane(paneId) {
     }
 }
 export function buildTmuxShellCommand(command, args) {
-    return [quoteShellArg(command), ...args.map(quoteShellArg)].join(' ');
+    return [quoteShellArg(command), ...args.map(quoteShellArg)].join(" ");
 }
 function encodePowerShellCommand(commandText) {
-    return Buffer.from(commandText, 'utf16le').toString('base64');
+    return Buffer.from(commandText, "utf16le").toString("base64");
 }
 function isCodexVersionRequest(args) {
     return args.some((arg) => CODEX_VERSION_FLAGS.has(arg));
 }
 export function buildWindowsPromptCommand(command, args) {
-    const invocation = ['&', quotePowerShellArg(command), ...args.map(quotePowerShellArg)].join(' ');
+    const invocation = [
+        "&",
+        quotePowerShellArg(command),
+        ...args.map(quotePowerShellArg),
+    ].join(" ");
     const wrappedCommand = [
         "$ErrorActionPreference = 'Stop'",
         `& { ${invocation} }`,
-    ].join('; ');
+    ].join("; ");
     return `powershell.exe -NoLogo -NoExit -EncodedCommand ${encodePowerShellCommand(wrappedCommand)}`;
 }
 /**
@@ -1357,15 +1532,15 @@ export function buildWindowsPromptCommand(command, args) {
  */
 export function buildTmuxPaneCommand(command, args, shellPath = process.env.SHELL) {
     const bareCmd = buildTmuxShellCommand(command, args);
-    let rcSource = '';
+    let rcSource = "";
     if (shellPath && /\/zsh$/i.test(shellPath)) {
-        rcSource = 'if [ -f ~/.zshrc ]; then source ~/.zshrc; fi; ';
+        rcSource = "if [ -f ~/.zshrc ]; then source ~/.zshrc; fi; ";
     }
     else if (shellPath && /\/bash$/i.test(shellPath)) {
-        rcSource = 'if [ -f ~/.bashrc ]; then source ~/.bashrc; fi; ';
+        rcSource = "if [ -f ~/.bashrc ]; then source ~/.bashrc; fi; ";
     }
-    const rawShell = shellPath && shellPath.trim() !== '' ? shellPath.trim() : '/bin/sh';
-    const shellBin = ALLOWED_SHELLS.has(rawShell) ? rawShell : '/bin/sh';
+    const rawShell = shellPath && shellPath.trim() !== "" ? shellPath.trim() : "/bin/sh";
+    const shellBin = ALLOWED_SHELLS.has(rawShell) ? rawShell : "/bin/sh";
     const inner = `${rcSource}exec ${bareCmd}`;
     return `${quoteShellArg(shellBin)} -lc ${quoteShellArg(inner)}`;
 }
@@ -1387,12 +1562,12 @@ function buildDetachedWindowsBootstrapScript(sessionName, commandText, delayMs =
         `try { execFileSync('tmux', ['send-keys', '-t', ${targetLiteral}, '-l', '--', ${commandLiteral}], { stdio: 'ignore' }); } catch {}`,
         `try { execFileSync('tmux', ['send-keys', '-t', ${targetLiteral}, 'C-m'], { stdio: 'ignore' }); } catch {}`,
         `}, ${delay});`,
-    ].join('');
+    ].join("");
 }
 function scheduleDetachedWindowsCodexLaunch(sessionName, commandText) {
-    const child = spawn(process.execPath, ['-e', buildDetachedWindowsBootstrapScript(sessionName, commandText)], {
+    const child = spawn(process.execPath, ["-e", buildDetachedWindowsBootstrapScript(sessionName, commandText)], {
         detached: true,
-        stdio: 'ignore',
+        stdio: "ignore",
         windowsHide: true,
     });
     child.unref();
@@ -1460,15 +1635,15 @@ async function postLaunch(cwd, sessionId) {
     }
     // 3. Cancel any still-active modes
     try {
-        const { readdir, writeFile, readFile } = await import('fs/promises');
+        const { readdir, writeFile, readFile } = await import("fs/promises");
         const scopedDirs = [getBaseStateDir(cwd), getStateDir(cwd, sessionId)];
         for (const stateDir of scopedDirs) {
             const files = await readdir(stateDir).catch(() => []);
             for (const file of files) {
-                if (!file.endsWith('-state.json') || file === 'session.json')
+                if (!file.endsWith("-state.json") || file === "session.json")
                     continue;
                 const path = join(stateDir, file);
-                const content = await readFile(path, 'utf-8');
+                const content = await readFile(path, "utf-8");
                 const state = JSON.parse(content);
                 if (state.active) {
                     state.active = false;
@@ -1483,16 +1658,16 @@ async function postLaunch(cwd, sessionId) {
     }
     // 4. Send session-end lifecycle notification (best effort)
     try {
-        const { notifyLifecycle } = await import('../notifications/index.js');
+        const { notifyLifecycle } = await import("../notifications/index.js");
         const durationMs = sessionStartedAt
             ? Date.now() - new Date(sessionStartedAt).getTime()
             : undefined;
-        await notifyLifecycle('session-end', {
+        await notifyLifecycle("session-end", {
             sessionId,
             projectPath: cwd,
             projectName: basename(cwd),
             durationMs,
-            reason: 'session_exit',
+            reason: "session_exit",
         });
     }
     catch (err) {
@@ -1504,19 +1679,21 @@ async function postLaunch(cwd, sessionId) {
         const durationMs = sessionStartedAt
             ? Date.now() - new Date(sessionStartedAt).getTime()
             : undefined;
-        const normalizedEvent = process.exitCode && process.exitCode !== 0 ? 'failed' : 'finished';
-        const errorSummary = normalizedEvent === 'failed'
+        const normalizedEvent = process.exitCode && process.exitCode !== 0 ? "failed" : "finished";
+        const errorSummary = normalizedEvent === "failed"
             ? `codex exited with code ${process.exitCode}`
             : undefined;
-        await emitNativeHookEvent(cwd, 'session-end', {
+        await emitNativeHookEvent(cwd, "session-end", {
             session_id: sessionId,
             context: buildNativeHookBaseContext(cwd, sessionId, normalizedEvent, {
                 project_path: cwd,
                 project_name: basename(cwd),
                 duration_ms: durationMs,
-                reason: 'session_exit',
-                status: normalizedEvent === 'failed' ? 'failed' : 'finished',
-                ...(process.exitCode !== undefined ? { exit_code: process.exitCode } : {}),
+                reason: "session_exit",
+                status: normalizedEvent === "failed" ? "failed" : "finished",
+                ...(process.exitCode !== undefined
+                    ? { exit_code: process.exitCode }
+                    : {}),
                 ...(errorSummary ? { error_summary: errorSummary } : {}),
             }),
         });
@@ -1528,7 +1705,7 @@ async function postLaunch(cwd, sessionId) {
 }
 async function emitNativeHookEvent(cwd, event, opts = {}) {
     const payload = buildHookEvent(event, {
-        source: 'native',
+        source: "native",
         context: opts.context || {},
         session_id: opts.session_id,
         thread_id: opts.thread_id,
@@ -1540,10 +1717,10 @@ async function emitNativeHookEvent(cwd, event, opts = {}) {
     });
 }
 function notifyFallbackPidPath(cwd) {
-    return join(cwd, '.omx', 'state', 'notify-fallback.pid');
+    return join(cwd, ".omx", "state", "notify-fallback.pid");
 }
 function hookDerivedWatcherPidPath(cwd) {
-    return join(cwd, '.omx', 'state', 'hook-derived-watcher.pid');
+    return join(cwd, ".omx", "state", "hook-derived-watcher.pid");
 }
 function parseWatcherPidFile(content) {
     const trimmed = content.trim();
@@ -1551,217 +1728,221 @@ function parseWatcherPidFile(content) {
         return null;
     try {
         const parsed = JSON.parse(trimmed);
-        return typeof parsed.pid === 'number' && Number.isFinite(parsed.pid) && parsed.pid > 0 ? parsed.pid : null;
+        return typeof parsed.pid === "number" &&
+            Number.isFinite(parsed.pid) &&
+            parsed.pid > 0
+            ? parsed.pid
+            : null;
     }
     catch {
         const pid = Number.parseInt(trimmed, 10);
         return Number.isFinite(pid) && pid > 0 ? pid : null;
     }
 }
-function tryKillPid(pid, signal = 'SIGTERM') {
+function tryKillPid(pid, signal = "SIGTERM") {
     try {
         process.kill(pid, signal);
         return true;
     }
     catch (error) {
         const code = error.code;
-        if (code === 'ESRCH')
+        if (code === "ESRCH")
             return false;
         throw error;
     }
 }
 async function startNotifyFallbackWatcher(cwd) {
-    if (process.env.OMX_NOTIFY_FALLBACK === '0')
+    if (process.env.OMX_NOTIFY_FALLBACK === "0")
         return;
-    const { mkdir, writeFile, readFile } = await import('fs/promises');
+    const { mkdir, writeFile, readFile } = await import("fs/promises");
     const pidPath = notifyFallbackPidPath(cwd);
     const pkgRoot = getPackageRoot();
-    const watcherScript = join(pkgRoot, 'scripts', 'notify-fallback-watcher.js');
-    const notifyScript = join(pkgRoot, 'scripts', 'notify-hook.js');
+    const watcherScript = join(pkgRoot, "scripts", "notify-fallback-watcher.js");
+    const notifyScript = join(pkgRoot, "scripts", "notify-hook.js");
     if (!existsSync(watcherScript) || !existsSync(notifyScript))
         return;
     // Stop stale watcher from a previous run.
     if (existsSync(pidPath)) {
         try {
-            const prevPid = parseWatcherPidFile(await readFile(pidPath, 'utf-8'));
+            const prevPid = parseWatcherPidFile(await readFile(pidPath, "utf-8"));
             if (prevPid) {
-                tryKillPid(prevPid, 'SIGTERM');
+                tryKillPid(prevPid, "SIGTERM");
             }
         }
         catch (error) {
-            if (!hasErrnoCode(error, 'ESRCH')) {
-                console.warn('[omx] warning: failed to stop stale notify fallback watcher', {
+            if (!hasErrnoCode(error, "ESRCH")) {
+                console.warn("[omx] warning: failed to stop stale notify fallback watcher", {
                     path: pidPath,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
         }
     }
-    await mkdir(join(cwd, '.omx', 'state'), { recursive: true }).catch((error) => {
-        console.warn('[omx] warning: failed to create notify fallback watcher state directory', {
+    await mkdir(join(cwd, ".omx", "state"), { recursive: true }).catch((error) => {
+        console.warn("[omx] warning: failed to create notify fallback watcher state directory", {
             cwd,
             error: error instanceof Error ? error.message : String(error),
         });
     });
     const child = spawn(process.execPath, [
         watcherScript,
-        '--cwd',
+        "--cwd",
         cwd,
-        '--notify-script',
+        "--notify-script",
         notifyScript,
-        '--pid-file',
+        "--pid-file",
         pidPath,
-        '--parent-pid',
+        "--parent-pid",
         String(process.pid),
         ...(process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS
-            ? ['--max-lifetime-ms', process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS]
+            ? ["--max-lifetime-ms", process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS]
             : []),
     ], {
         cwd,
         detached: true,
-        stdio: 'ignore',
+        stdio: "ignore",
     });
     child.unref();
     await writeFile(pidPath, JSON.stringify({ pid: child.pid, started_at: new Date().toISOString() }, null, 2)).catch((error) => {
-        console.warn('[omx] warning: failed to write notify fallback watcher pid file', {
+        console.warn("[omx] warning: failed to write notify fallback watcher pid file", {
             path: pidPath,
             error: error instanceof Error ? error.message : String(error),
         });
     });
 }
 async function startHookDerivedWatcher(cwd) {
-    if (process.env.OMX_HOOK_DERIVED_SIGNALS !== '1')
+    if (process.env.OMX_HOOK_DERIVED_SIGNALS !== "1")
         return;
-    const { mkdir, writeFile, readFile } = await import('fs/promises');
+    const { mkdir, writeFile, readFile } = await import("fs/promises");
     const pidPath = hookDerivedWatcherPidPath(cwd);
     const pkgRoot = getPackageRoot();
-    const watcherScript = join(pkgRoot, 'scripts', 'hook-derived-watcher.js');
+    const watcherScript = join(pkgRoot, "scripts", "hook-derived-watcher.js");
     if (!existsSync(watcherScript))
         return;
     if (existsSync(pidPath)) {
         try {
-            const prev = JSON.parse(await readFile(pidPath, 'utf-8'));
-            if (prev && typeof prev.pid === 'number') {
-                process.kill(prev.pid, 'SIGTERM');
+            const prev = JSON.parse(await readFile(pidPath, "utf-8"));
+            if (prev && typeof prev.pid === "number") {
+                process.kill(prev.pid, "SIGTERM");
             }
         }
         catch (error) {
-            console.warn('[omx] warning: failed to stop stale hook-derived watcher', {
+            console.warn("[omx] warning: failed to stop stale hook-derived watcher", {
                 path: pidPath,
                 error: error instanceof Error ? error.message : String(error),
             });
         }
     }
-    await mkdir(join(cwd, '.omx', 'state'), { recursive: true }).catch((error) => {
-        console.warn('[omx] warning: failed to create hook-derived watcher state directory', {
+    await mkdir(join(cwd, ".omx", "state"), { recursive: true }).catch((error) => {
+        console.warn("[omx] warning: failed to create hook-derived watcher state directory", {
             cwd,
             error: error instanceof Error ? error.message : String(error),
         });
     });
-    const child = spawn(process.execPath, [watcherScript, '--cwd', cwd], {
+    const child = spawn(process.execPath, [watcherScript, "--cwd", cwd], {
         cwd,
         detached: true,
-        stdio: 'ignore',
+        stdio: "ignore",
         env: process.env,
     });
     child.unref();
     await writeFile(pidPath, JSON.stringify({ pid: child.pid, started_at: new Date().toISOString() }, null, 2)).catch((error) => {
-        console.warn('[omx] warning: failed to write hook-derived watcher pid file', {
+        console.warn("[omx] warning: failed to write hook-derived watcher pid file", {
             path: pidPath,
             error: error instanceof Error ? error.message : String(error),
         });
     });
 }
 async function stopNotifyFallbackWatcher(cwd) {
-    const { readFile, unlink } = await import('fs/promises');
+    const { readFile, unlink } = await import("fs/promises");
     const pidPath = notifyFallbackPidPath(cwd);
     if (!existsSync(pidPath))
         return;
     try {
-        const pid = parseWatcherPidFile(await readFile(pidPath, 'utf-8'));
+        const pid = parseWatcherPidFile(await readFile(pidPath, "utf-8"));
         if (pid) {
-            tryKillPid(pid, 'SIGTERM');
+            tryKillPid(pid, "SIGTERM");
         }
     }
     catch (error) {
-        if (!hasErrnoCode(error, 'ESRCH')) {
-            console.warn('[omx] warning: failed to stop notify fallback watcher process', {
+        if (!hasErrnoCode(error, "ESRCH")) {
+            console.warn("[omx] warning: failed to stop notify fallback watcher process", {
                 path: pidPath,
                 error: error instanceof Error ? error.message : String(error),
             });
         }
     }
     await unlink(pidPath).catch((error) => {
-        console.warn('[omx] warning: failed to remove notify fallback watcher pid file', {
+        console.warn("[omx] warning: failed to remove notify fallback watcher pid file", {
             path: pidPath,
             error: error instanceof Error ? error.message : String(error),
         });
     });
 }
 async function stopHookDerivedWatcher(cwd) {
-    const { readFile, unlink } = await import('fs/promises');
+    const { readFile, unlink } = await import("fs/promises");
     const pidPath = hookDerivedWatcherPidPath(cwd);
     if (!existsSync(pidPath))
         return;
     try {
-        const parsed = JSON.parse(await readFile(pidPath, 'utf-8'));
-        if (parsed && typeof parsed.pid === 'number') {
-            process.kill(parsed.pid, 'SIGTERM');
+        const parsed = JSON.parse(await readFile(pidPath, "utf-8"));
+        if (parsed && typeof parsed.pid === "number") {
+            process.kill(parsed.pid, "SIGTERM");
         }
     }
     catch (error) {
-        console.warn('[omx] warning: failed to stop hook-derived watcher process', {
+        console.warn("[omx] warning: failed to stop hook-derived watcher process", {
             path: pidPath,
             error: error instanceof Error ? error.message : String(error),
         });
     }
     await unlink(pidPath).catch((error) => {
-        console.warn('[omx] warning: failed to remove hook-derived watcher pid file', {
+        console.warn("[omx] warning: failed to remove hook-derived watcher pid file", {
             path: pidPath,
             error: error instanceof Error ? error.message : String(error),
         });
     });
 }
 async function flushNotifyFallbackOnce(cwd) {
-    const { spawnSync } = await import('child_process');
+    const { spawnSync } = await import("child_process");
     const pkgRoot = getPackageRoot();
-    const watcherScript = join(pkgRoot, 'scripts', 'notify-fallback-watcher.js');
-    const notifyScript = join(pkgRoot, 'scripts', 'notify-hook.js');
+    const watcherScript = join(pkgRoot, "scripts", "notify-fallback-watcher.js");
+    const notifyScript = join(pkgRoot, "scripts", "notify-hook.js");
     if (!existsSync(watcherScript) || !existsSync(notifyScript))
         return;
-    spawnSync(process.execPath, [watcherScript, '--once', '--cwd', cwd, '--notify-script', notifyScript], {
+    spawnSync(process.execPath, [watcherScript, "--once", "--cwd", cwd, "--notify-script", notifyScript], {
         cwd,
-        stdio: 'ignore',
+        stdio: "ignore",
         timeout: 3000,
     });
 }
 async function flushHookDerivedWatcherOnce(cwd) {
-    if (process.env.OMX_HOOK_DERIVED_SIGNALS !== '1')
+    if (process.env.OMX_HOOK_DERIVED_SIGNALS !== "1")
         return;
-    const { spawnSync } = await import('child_process');
+    const { spawnSync } = await import("child_process");
     const pkgRoot = getPackageRoot();
-    const watcherScript = join(pkgRoot, 'scripts', 'hook-derived-watcher.js');
+    const watcherScript = join(pkgRoot, "scripts", "hook-derived-watcher.js");
     if (!existsSync(watcherScript))
         return;
-    spawnSync(process.execPath, [watcherScript, '--once', '--cwd', cwd], {
+    spawnSync(process.execPath, [watcherScript, "--once", "--cwd", cwd], {
         cwd,
-        stdio: 'ignore',
+        stdio: "ignore",
         timeout: 3000,
         env: {
             ...process.env,
-            OMX_HOOK_DERIVED_SIGNALS: '1',
+            OMX_HOOK_DERIVED_SIGNALS: "1",
         },
     });
 }
 async function cancelModes() {
-    const { writeFile, readFile } = await import('fs/promises');
+    const { writeFile, readFile } = await import("fs/promises");
     const cwd = process.cwd();
     const nowIso = new Date().toISOString();
     try {
         const refs = await listModeStateFilesWithScopePreference(cwd);
         const states = new Map();
         for (const ref of refs) {
-            const content = await readFile(ref.path, 'utf-8');
+            const content = await readFile(ref.path, "utf-8");
             let parsedState;
             try {
                 parsedState = JSON.parse(content);
@@ -1778,15 +1959,15 @@ async function cancelModes() {
         }
         const changed = new Set();
         const reported = new Set();
-        const cancelMode = (mode, phase = 'cancelled', reportIfWasActive = true) => {
+        const cancelMode = (mode, phase = "cancelled", reportIfWasActive = true) => {
             const entry = states.get(mode);
             if (!entry)
                 return;
             const wasActive = entry.state.active === true;
-            const needsChange = entry.state.active !== false
-                || entry.state.current_phase !== phase
-                || typeof entry.state.completed_at !== 'string'
-                || String(entry.state.completed_at).trim() === '';
+            const needsChange = entry.state.active !== false ||
+                entry.state.current_phase !== phase ||
+                typeof entry.state.completed_at !== "string" ||
+                String(entry.state.completed_at).trim() === "";
             if (!needsChange)
                 return;
             entry.state.active = false;
@@ -1797,30 +1978,32 @@ async function cancelModes() {
             if (reportIfWasActive && wasActive)
                 reported.add(mode);
         };
-        const ralphLinksUltrawork = (state) => state.linked_ultrawork === true || state.linked_mode === 'ultrawork';
-        const team = states.get('team');
-        const ralph = states.get('ralph');
+        const ralphLinksUltrawork = (state) => state.linked_ultrawork === true || state.linked_mode === "ultrawork";
+        const team = states.get("team");
+        const ralph = states.get("ralph");
         const hadActiveRalph = !!(ralph && ralph.state.active === true);
-        if (team && team.state.active === true && team.state.linked_ralph === true) {
-            cancelMode('team', 'cancelled', true);
+        if (team &&
+            team.state.active === true &&
+            team.state.linked_ralph === true) {
+            cancelMode("team", "cancelled", true);
             if (ralph && ralph.state.linked_team === true) {
-                cancelMode('ralph', 'cancelled', true);
-                ralph.state.linked_team_terminal_phase = 'cancelled';
+                cancelMode("ralph", "cancelled", true);
+                ralph.state.linked_team_terminal_phase = "cancelled";
                 ralph.state.linked_team_terminal_at = nowIso;
-                changed.add('ralph');
+                changed.add("ralph");
                 if (ralphLinksUltrawork(ralph.state))
-                    cancelMode('ultrawork', 'cancelled', true);
+                    cancelMode("ultrawork", "cancelled", true);
             }
         }
         if (ralph && ralph.state.active === true) {
-            cancelMode('ralph', 'cancelled', true);
+            cancelMode("ralph", "cancelled", true);
             if (ralphLinksUltrawork(ralph.state))
-                cancelMode('ultrawork', 'cancelled', true);
+                cancelMode("ultrawork", "cancelled", true);
         }
         if (!hadActiveRalph) {
             for (const [mode, entry] of states.entries()) {
                 if (entry.state.active === true)
-                    cancelMode(mode, 'cancelled', true);
+                    cancelMode(mode, "cancelled", true);
             }
         }
         for (const [mode, entry] of states.entries()) {
@@ -1832,12 +2015,12 @@ async function cancelModes() {
             console.log(`Cancelled: ${mode}`);
         }
         if (reported.size === 0) {
-            console.log('No active modes to cancel.');
+            console.log("No active modes to cancel.");
         }
     }
     catch (err) {
         process.stderr.write(`[cli/index] operation failed: ${err}\n`);
-        console.log('No active modes to cancel.');
+        console.log("No active modes to cancel.");
     }
 }
 //# sourceMappingURL=index.js.map