@jstn-sdk/rcs 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,3117 @@
+/**
+ * roblox-ai-os-creator-skills CLI
+ * Multi-agent orchestration for OpenAI Codex CLI
+ */
+import { execFileSync, spawn } from "child_process";
+import { basename, dirname, join } from "path";
+import { writeSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { copyFile, cp, lstat, mkdir, readdir, rm, symlink } from "fs/promises";
+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 { sidecarCommand } from "../sidecar/index.js";
+import { teamCommand } from "./team.js";
+import { ralphCommand } from "./ralph.js";
+import { askCommand } from "./ask.js";
+import { questionCommand } from "./question.js";
+import { stateCommand } from "./state.js";
+import { cleanupCommand, cleanupRcsMcpProcesses, findLaunchSafeCleanupCandidates, } 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 { mcpParityCommand } from "./mcp-parity.js";
+import { mcpServeCommand } from "./mcp-serve.js";
+import { adaptCommand } from "./adapt.js";
+import { listCommand } from "./list.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 { resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
+export { readPersistedSetupPreferences, readPersistedSetupScope, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
+import { SKILL_ACTIVE_STATE_MODE, syncCanonicalSkillStateForMode } from "../state/skill-active.js";
+import { isTrackedWorkflowMode } from "../state/workflow-transition.js";
+import { maybeCheckAndPromptUpdate, runImmediateUpdate } from "./update.js";
+import { maybePromptGithubStar } from "./star-prompt.js";
+import { generateOverlay, removeSessionModelInstructionsFile, resolveSessionOrchestrationMode, sessionModelInstructionsPath, writeSessionModelInstructionsFile, } from "../hooks/agents-overlay.js";
+import { readSessionState, writeSessionStart, writeSessionEnd, resetSessionMetrics, } from "../hooks/session.js";
+import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isMsysOrGitBash, isNativeWindows, isTmuxAvailable, mitigateCopyModeUnderlineArtifacts, } from "../team/tmux-session.js";
+import { getPackageRoot } from "../utils/package.js";
+import { codexConfigPath, rememberRcsLaunchContext, resolveRcsEntryPath } from "../utils/paths.js";
+import { cleanCodexModelAvailabilityNuxIfNeeded, repairConfigIfNeeded } from "../config/generator.js";
+import { HUD_TMUX_HEIGHT_LINES } from "../hud/constants.js";
+import { createHudWatchPane as createSharedHudWatchPane, killTmuxPane as killSharedTmuxPane, listCurrentWindowHudPaneIds, parsePaneIdFromTmuxOutput, } from "../hud/tmux.js";
+export { parseTmuxPaneSnapshot, isHudWatchPane, findHudWatchPaneIds } from "../hud/tmux.js";
+rememberRcsLaunchContext();
+import { classifySpawnError, resolveTmuxBinaryForPlatform, spawnPlatformCommandSync, } from "../utils/platform-command.js";
+import { buildHookEvent } from "../hooks/extensibility/events.js";
+import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
+import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, } from "../team/model-contract.js";
+import { parseWorktreeMode, planWorktreeTarget, ensureWorktree, } from "../team/worktree.js";
+import { ensureReusableNodeModules } from "../utils/repo-deps.js";
+import { RCS_NOTIFY_TEMP_CONTRACT_ENV, parseNotifyTempContractFromArgs, serializeNotifyTempContract, } from "../notifications/temp-contract.js";
+import { execInjectCommand } from "../exec/followup.js";
+export function resolveNotifyFallbackWatcherScript(pkgRoot = getPackageRoot()) {
+    return resolveDistScript(pkgRoot, "notify-fallback-watcher.js");
+}
+function writeStdoutLine(line) {
+    const rendered = `${line}\n`;
+    if (process.stdout.isTTY)
+        process.stdout.write(rendered);
+    else
+        writeSync(1, rendered);
+}
+export function resolveHookDerivedWatcherScript(pkgRoot = getPackageRoot()) {
+    return resolveDistScript(pkgRoot, "hook-derived-watcher.js");
+}
+export function resolveNotifyHookScript(pkgRoot = getPackageRoot()) {
+    return resolveDistScript(pkgRoot, "notify-hook.js");
+}
+function resolveDistScript(pkgRoot, scriptName) {
+    return join(pkgRoot, "dist", "scripts", scriptName);
+}
+export const HELP = `
+Roblox Creator Skills (rcs) - Creator workflow runtime for Codex CLI
+
+Usage:
+  rcs           Launch Codex CLI (detached tmux by default on supported interactive terminals)
+  rcs exec      Run codex exec non-interactively with RCS AGENTS/overlay injection
+  rcs exec inject <session-id> --prompt <text>
+                Queue audited follow-up instructions for a running non-interactive exec job
+  rcs setup     Install skills, prompts, MCP servers, and scope-specific AGENTS.md
+                (user scope prompts for legacy vs plugin skill delivery when needed)
+  rcs update    Check npm now, update the global install immediately, then refresh setup
+  rcs uninstall Remove RCS configuration and clean up installed artifacts
+  rcs doctor    Check installation health
+  rcs list      List packaged RCS skills and native agent prompts (--json)
+  rcs cleanup   Kill orphaned RCS MCP server processes and remove stale RCS /tmp directories
+  rcs doctor --team  Check team/swarm runtime health diagnostics
+  rcs ask       Ask local provider CLI (claude|gemini) and write artifact output
+  rcs question  RCS-owned blocking question UI entrypoint for agent-invoked user questions
+  rcs adapt     Scaffold RCS-owned adapter foundations for persistent external targets
+  rcs resume    Resume a previous interactive Codex session
+  rcs explore   Default read-only exploration entrypoint (may adaptively use sparkshell backend)
+  rcs session   Search prior local session transcripts and history artifacts
+  rcs agents-init [path]
+                Bootstrap lightweight AGENTS.md files for a repo/subtree
+  rcs agents    Manage Codex native agent TOML files
+  rcs deepinit [path]
+                Alias for agents-init (lightweight AGENTS bootstrap only)
+  rcs team      Spawn parallel worker panes in tmux and bootstrap inbox/task state
+  rcs ralph     Launch Codex with ralph persistence mode active
+  rcs autoresearch [DEPRECATED] Use $autoresearch; direct CLI launch removed
+  rcs version   Show version information
+  rcs tmux-hook Manage tmux prompt injection workaround (init|status|validate|test)
+  rcs hooks     Manage hook plugins (init|status|validate|test)
+  rcs hud       Show HUD statusline (--watch, --json, --preset=NAME)
+  rcs sidecar   Show read-only team/multi-agent visualization (--watch, --json, --tmux)
+  rcs state     Read/write/list RCS mode state via CLI parity surface
+  rcs notepad   CLI parity for RCS notepad MCP tools
+  rcs project-memory
+                CLI parity for RCS project-memory MCP tools
+  rcs trace     CLI parity for RCS trace MCP tools
+  rcs code-intel
+                CLI parity for RCS code-intel MCP tools
+  rcs wiki      CLI parity for RCS wiki MCP tools
+  rcs mcp-serve Launch an RCS stdio MCP server target (plugin/runtime use)
+  rcs sparkshell <command> [args...]
+  rcs sparkshell --tmux-pane <pane-id> [--tail-lines <100-1000>]
+                Run native sparkshell sidecar for direct command execution or explicit tmux-pane summarization
+                (also used as an adaptive backend for qualifying read-only explore tasks)
+  rcs help      Show this help message
+  rcs status    Show active modes and state
+  rcs cancel    Cancel active execution modes
+  rcs reasoning Show or set model reasoning effort (low|medium|high|xhigh)
+
+Creator workflow triggers (use inside Codex sessions):
+  $brief         Capture goals, constraints, genre, audience, and outcome
+  $blueprint     Generate structured design and planning artifacts
+  $forge         Generate concrete creator-facing deliverables and specs
+  $crew          Orchestrate multi-role creator workflows
+  $autoforge     Run the end-to-end creator workflow with minimal supervision
+
+Psychology-aware creator triggers:
+  $brief:audience      Target fantasy, habit patterns, pain language, return motive
+  $brief:motivation    Driver ranking + anti-pattern risk scan
+  $blueprint:psych     Player psychology blueprint
+  $blueprint:loop      Session, daily, weekly, and comeback loop map
+  $blueprint:retention D1/D7/D30 retention assumptions and cadence
+  $blueprint:social    Social machine design
+  $forge:reward-loop   Reward loop specification
+  $forge:daily-loop    Daily return motivator spec
+  $forge:event-loop    Event and urgency loop spec
+  $forge:progression   XP, level, prestige, rebirth, and unlock ladders
+  $forge:status        Prestige and visible status systems
+  $forge:fomo          Fair urgency mechanics with guardrails
+  $forge:mastery       Skill-expression and optimization systems
+  $forge:community     Social stickiness systems
+
+Options:
+  --yolo        Launch Codex in yolo mode (shorthand for: rcs launch --yolo)
+  --high        Launch Codex with high reasoning effort
+                (shorthand for: -c model_reasoning_effort="high")
+  --xhigh       Launch Codex with xhigh reasoning effort
+                (shorthand for: -c model_reasoning_effort="xhigh")
+  --madmax      DANGEROUS: bypass Codex approvals and sandbox
+                (alias for --dangerously-bypass-approvals-and-sandbox)
+  --spark       Use the Codex spark model (~1.3x faster) for team workers only
+                Workers get the configured low-complexity team model; leader model unchanged
+  --madmax-spark  spark model for workers + bypass approvals for leader and workers
+                (shorthand for: --spark --madmax)
+  --notify-temp  Enable temporary notification routing for this run/session only
+  --direct       Launch the interactive leader directly without RCS tmux/HUD management
+  --tmux         Launch the interactive leader session in detached tmux
+  --discord      Select Discord provider for temporary notification mode
+  --slack        Select Slack provider for temporary notification mode
+  --telegram     Select Telegram provider for temporary notification mode
+  --custom <name>
+                Select custom/OpenClaw gateway name for temporary notification mode
+  -w, --worktree[=<name>]
+                Launch Codex in a git worktree (detached when no name is given)
+  --force       Force reinstall (overwrite existing files)
+  --merge-agents
+                Merge RCS-managed AGENTS.md sections into an existing AGENTS.md
+                instead of overwriting user-authored content
+  --dry-run     Show what would be done without doing it
+  --plugin      Use Codex plugin delivery for rcs setup and remove legacy RCS-managed user/project components
+  --legacy      Use legacy setup delivery for rcs setup, overriding persisted plugin mode
+  --install-mode <legacy|plugin>
+                Explicit setup install mode (canonical form; --legacy/--plugin are aliases)
+  --keep-config Skip config.toml cleanup during uninstall
+  --purge       Remove .rcs/ cache directory during uninstall
+  --verbose     Show detailed output
+  --scope       Setup scope for "rcs setup" only:
+                user | project
+
+Launch policy:
+  RCS_LAUNCH_POLICY=direct|tmux|detached-tmux|auto
+                Choose the default leader launch policy when no CLI policy flag is present
+  unset RCS_LAUNCH_POLICY
+                Return to the auto/default policy (detached tmux on supported interactive terminals)
+  rcs --direct --yolo
+                Run this launch without RCS tmux/HUD management
+  RCS_LAUNCH_POLICY=direct rcs --yolo
+                Use direct launch from the environment
+  RCS_LAUNCH_POLICY=direct rcs --tmux --yolo
+                CLI policy flags override the environment for one launch
+  Config files are intentionally not used for launch policy in this release.
+`;
+const REASONING_KEY = "model_reasoning_effort";
+const MODEL_INSTRUCTIONS_FILE_KEY = "model_instructions_file";
+const TEAM_WORKER_LAUNCH_ARGS_ENV = "RCS_TEAM_WORKER_LAUNCH_ARGS";
+const TEAM_INHERIT_LEADER_FLAGS_ENV = "RCS_TEAM_INHERIT_LEADER_FLAGS";
+const RCS_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV = "RCS_BYPASS_DEFAULT_SYSTEM_PROMPT";
+const RCS_MODEL_INSTRUCTIONS_FILE_ENV = "RCS_MODEL_INSTRUCTIONS_FILE";
+const RCS_INSTANCE_OPTION = "@rcs_instance_id";
+const RCS_RALPH_APPEND_INSTRUCTIONS_FILE_ENV = "RCS_RALPH_APPEND_INSTRUCTIONS_FILE";
+const RCS_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE_ENV = "RCS_AUTORESEARCH_APPEND_INSTRUCTIONS_FILE";
+const REASONING_MODES = ["low", "medium", "high", "xhigh"];
+const REASONING_MODE_SET = new Set(REASONING_MODES);
+const REASONING_USAGE = "Usage: rcs reasoning <low|medium|high|xhigh>";
+const ALLOWED_SHELLS = new Set([
+    "/bin/sh",
+    "/bin/bash",
+    "/bin/zsh",
+    "/bin/dash",
+    "/bin/fish",
+    "/usr/bin/sh",
+    "/usr/bin/bash",
+    "/usr/bin/zsh",
+    "/usr/bin/dash",
+    "/usr/bin/fish",
+    "/usr/local/bin/bash",
+    "/usr/local/bin/zsh",
+    "/usr/local/bin/fish",
+    "/opt/local/bin/zsh",
+    "/opt/homebrew/bin/zsh",
+]);
+const WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS = 2500;
+const CODEX_VERSION_FLAGS = new Set(["--version", "-V"]);
+const TMUX_EXTENDED_KEYS_MODE = "always";
+const TMUX_EXTENDED_KEYS_FALLBACK_MODE = "off";
+const TMUX_EXTENDED_KEYS_LEASE_DIR = "tmux-extended-keys";
+const TMUX_EXTENDED_KEYS_LOCK_RETRY_MS = 20;
+const TMUX_EXTENDED_KEYS_LOCK_MAX_ATTEMPTS = 100;
+const TMUX_EXTENDED_KEYS_LOCK_STALE_MS = 30_000;
+const NESTED_HELP_COMMANDS = new Set([
+    "ask",
+    "question",
+    "cleanup",
+    "adapt",
+    "autoresearch",
+    "agents",
+    "agents-init",
+    "deepinit",
+    "exec",
+    "hooks",
+    "list",
+    "hud",
+    "sidecar",
+    "state",
+    "wiki",
+    "mcp-serve",
+    "ralph",
+    "resume",
+    "session",
+    "sparkshell",
+    "team",
+    "tmux-hook",
+]);
+export function resolveSetupInstallModeArg(args) {
+    let value;
+    const setValue = (next, source) => {
+        if (value && value !== next) {
+            throw new Error(`Conflicting setup install mode flags: ${source} selects ${next}, but another flag already selected ${value}`);
+        }
+        value = next;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--plugin") {
+            setValue("plugin", arg);
+            continue;
+        }
+        if (arg === "--legacy") {
+            setValue("legacy", arg);
+            continue;
+        }
+        if (arg === "--install-mode") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup install mode value after --install-mode. Expected one of: legacy, plugin`);
+            }
+            if (next !== "legacy" && next !== "plugin") {
+                throw new Error(`Invalid setup install mode: ${next}. Expected one of: legacy, plugin`);
+            }
+            setValue(next, arg);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--install-mode=")) {
+            const next = arg.slice("--install-mode=".length);
+            if (next !== "legacy" && next !== "plugin") {
+                throw new Error(`Invalid setup install mode: ${next}. Expected one of: legacy, plugin`);
+            }
+            setValue(next, "--install-mode");
+        }
+    }
+    return value;
+}
+export function resolveSetupScopeArg(args) {
+    let value;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--scope") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup scope value after --scope. Expected one of: ${SETUP_SCOPES.join(", ")}`);
+            }
+            value = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--scope=")) {
+            value = arg.slice("--scope=".length);
+        }
+    }
+    if (!value)
+        return undefined;
+    if (SETUP_SCOPES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid setup scope: ${value}. Expected one of: ${SETUP_SCOPES.join(", ")}`);
+}
+export function resolveCliInvocation(args) {
+    const firstArg = args[0];
+    if (firstArg === "--help" || firstArg === "-h") {
+        return { command: "help", launchArgs: [] };
+    }
+    if (firstArg === "--version" || firstArg === "-v") {
+        return { command: "version", launchArgs: [] };
+    }
+    if (!firstArg || firstArg.startsWith("--")) {
+        return { command: "launch", launchArgs: firstArg ? args : [] };
+    }
+    if (firstArg === "launch") {
+        return { command: "launch", launchArgs: args.slice(1) };
+    }
+    if (firstArg === "exec") {
+        return { command: "exec", launchArgs: args.slice(1) };
+    }
+    if (firstArg === "resume") {
+        return { command: "resume", launchArgs: args.slice(1) };
+    }
+    return { command: firstArg, launchArgs: [] };
+}
+export function resolveNotifyTempContract(args, env = process.env) {
+    return parseNotifyTempContractFromArgs(args, env);
+}
+export function commandOwnsLocalHelp(command) {
+    return NESTED_HELP_COMMANDS.has(command);
+}
+const RCS_LAUNCH_POLICY_ENV = "RCS_LAUNCH_POLICY";
+let warnedInvalidEnvLaunchPolicy = false;
+function splitLeaderLaunchPolicyArgs(args) {
+    const remainingArgs = [];
+    let explicitPolicy;
+    let passthroughOnly = false;
+    for (const arg of args) {
+        if (passthroughOnly) {
+            remainingArgs.push(arg);
+            continue;
+        }
+        if (arg === "--") {
+            passthroughOnly = true;
+            remainingArgs.push(arg);
+            continue;
+        }
+        if (arg === "--direct") {
+            explicitPolicy = "direct";
+            continue;
+        }
+        if (arg === "--tmux") {
+            explicitPolicy = "detached-tmux";
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return { explicitPolicy, remainingArgs };
+}
+export function resolveLeaderLaunchPolicyOverride(args) {
+    return splitLeaderLaunchPolicyArgs(args).explicitPolicy;
+}
+export function resolveEnvLaunchPolicyOverride(env = process.env) {
+    const rawValue = env[RCS_LAUNCH_POLICY_ENV]?.trim();
+    if (!rawValue)
+        return undefined;
+    const value = rawValue.toLowerCase();
+    if (value === "auto")
+        return undefined;
+    if (value === "direct")
+        return "direct";
+    if (value === "tmux" || value === "detached-tmux")
+        return "detached-tmux";
+    if (!warnedInvalidEnvLaunchPolicy) {
+        warnedInvalidEnvLaunchPolicy = true;
+        console.warn(`[rcs] warning: invalid ${RCS_LAUNCH_POLICY_ENV}="${rawValue}". ` +
+            "Expected direct, tmux, detached-tmux, or auto. Falling back to auto/default launch policy.");
+    }
+    return undefined;
+}
+export function resolveEffectiveLeaderLaunchPolicyOverride(args, env = process.env) {
+    return (resolveLeaderLaunchPolicyOverride(args) ?? resolveEnvLaunchPolicyOverride(env));
+}
+export function resolveCodexLaunchPolicy(env = process.env, _platform = process.platform, tmuxAvailable = isTmuxAvailable(), nativeWindows = isNativeWindows(), stdinIsTTY = Boolean(process.stdin.isTTY), stdoutIsTTY = Boolean(process.stdout.isTTY), explicitPolicy) {
+    if (explicitPolicy === "direct")
+        return "direct";
+    if (env.TMUX)
+        return "inside-tmux";
+    if (explicitPolicy === "detached-tmux")
+        return tmuxAvailable ? "detached-tmux" : "direct";
+    if (_platform === "win32")
+        return "direct";
+    if (nativeWindows)
+        return "direct";
+    if (!stdinIsTTY || !stdoutIsTTY)
+        return "direct";
+    return tmuxAvailable ? "detached-tmux" : "direct";
+}
+function resolveTmuxExecutableForLaunch() {
+    return resolveTmuxBinaryForPlatform() || "tmux";
+}
+export function runtimeCodexHomePath(cwd, sessionId) {
+    return join(cwd, ".rcs", "runtime", "codex-home", sessionId);
+}
+async function linkOrCopyCodexHomeEntry(source, destination) {
+    const stat = await lstat(source);
+    try {
+        await symlink(source, destination, stat.isDirectory() && process.platform === "win32" ? "junction" : undefined);
+    }
+    catch {
+        if (stat.isDirectory()) {
+            await cp(source, destination, { recursive: true, force: true, verbatimSymlinks: true });
+            return;
+        }
+        await copyFile(source, destination);
+    }
+}
+/**
+ * Project-scope setup keeps durable Codex config under <repo>/.codex, but the
+ * Codex TUI also stores model-availability NUX counters in CODEX_HOME/config.toml.
+ * Launch against a session mirror so those runtime writes never dirty the
+ * durable project config while preserving the project config as the launch input.
+ */
+export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectCodexHome) {
+    const runtimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
+    await rm(runtimeCodexHome, { recursive: true, force: true });
+    await mkdir(runtimeCodexHome, { recursive: true });
+    if (!existsSync(projectCodexHome))
+        return runtimeCodexHome;
+    for (const entry of await readdir(projectCodexHome, { withFileTypes: true })) {
+        const source = join(projectCodexHome, entry.name);
+        const destination = join(runtimeCodexHome, entry.name);
+        if (entry.name === "config.toml") {
+            await copyFile(source, destination);
+            continue;
+        }
+        await linkOrCopyCodexHomeEntry(source, destination);
+    }
+    return runtimeCodexHome;
+}
+export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.env) {
+    const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(cwd, env);
+    if (projectLocalCodexHomeForCleanup) {
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup);
+        return {
+            codexHomeOverride: runtimeCodexHome,
+            projectLocalCodexHomeForCleanup,
+            runtimeCodexHomeForCleanup: runtimeCodexHome,
+        };
+    }
+    return {
+        codexHomeOverride: resolveCodexHomeForLaunch(cwd, env),
+        projectLocalCodexHomeForCleanup,
+    };
+}
+async function cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup) {
+    if (!runtimeCodexHomeForCleanup)
+        return;
+    await rm(runtimeCodexHomeForCleanup, { recursive: true, force: true });
+}
+function execTmuxFileSync(args, options) {
+    return execFileSync(resolveTmuxExecutableForLaunch(), args, {
+        ...(options ?? {}),
+        ...(process.platform === "win32" ? { windowsHide: true } : {}),
+    });
+}
+function hasErrnoCode(error, code) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === code);
+}
+function isMissingTmuxLaunchNoise(error) {
+    return error instanceof Error && /spawnSync tmux ENOENT/i.test(error.message);
+}
+function logCliOperationFailure(error) {
+    if (isMissingTmuxLaunchNoise(error))
+        return;
+    process.stderr.write(`[cli/index] operation failed: ${error}
+`);
+}
+function tmuxFailureMessage(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const err = error;
+    const stderr = typeof err.stderr === "string" ? err.stderr : err.stderr?.toString();
+    const stdout = typeof err.stdout === "string" ? err.stdout : err.stdout?.toString();
+    const detail = (stderr || stdout || err.message || String(error)).trim();
+    return detail.replace(/\s+/g, " ");
+}
+function isUnsupportedTmuxExtendedKeysFailure(error) {
+    const message = tmuxFailureMessage(error).toLowerCase();
+    return (message.includes("extended-keys") &&
+        /(?:invalid|unknown|unsupported) (?:option|flag|argument)|no such option|unknown option/.test(message));
+}
+function isBenignMissingTmuxServerMessage(message) {
+    return (/no server running/i.test(message) ||
+        /error connecting to .*\(No such file or directory\)/i.test(message));
+}
+export function checkDetachedTmuxLaunchHealth() {
+    try {
+        execTmuxFileSync(["list-sessions"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return { usable: true };
+    }
+    catch (err) {
+        const reason = tmuxFailureMessage(err);
+        if (isBenignMissingTmuxServerMessage(reason)) {
+            return { usable: true };
+        }
+        return { usable: false, reason };
+    }
+}
+function warnDetachedTmuxFallback(reason) {
+    const suffix = reason ? ` (${reason})` : "";
+    console.warn(`[rcs] warning: tmux is installed but its server/socket is unusable${suffix}. Falling back to direct Codex launch.`);
+}
+function resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows) {
+    const launchPolicy = resolveCodexLaunchPolicy(process.env, process.platform, undefined, nativeWindows, undefined, undefined, explicitLaunchPolicy);
+    if (launchPolicy !== "detached-tmux") {
+        return { launchPolicy, effectiveExplicitLaunchPolicy: explicitLaunchPolicy };
+    }
+    const tmuxHealth = checkDetachedTmuxLaunchHealth();
+    if (tmuxHealth.usable) {
+        return { launchPolicy, effectiveExplicitLaunchPolicy: explicitLaunchPolicy };
+    }
+    warnDetachedTmuxFallback(tmuxHealth.reason);
+    return { launchPolicy: "direct", effectiveExplicitLaunchPolicy: "direct" };
+}
+export function resolveSignalExitCode(signal) {
+    if (!signal)
+        return 1;
+    const signalNumber = osConstants.signals[signal];
+    if (typeof signalNumber === "number" && Number.isFinite(signalNumber)) {
+        return 128 + signalNumber;
+    }
+    return 1;
+}
+export function classifyCodexExecFailure(error) {
+    if (!error || typeof error !== "object") {
+        return {
+            kind: "launch-error",
+            message: String(error),
+        };
+    }
+    const err = error;
+    const code = typeof err.code === "string" ? err.code : undefined;
+    const message = typeof err.message === "string" && err.message.length > 0
+        ? err.message
+        : "unknown codex launch failure";
+    const hasExitStatus = typeof err.status === "number";
+    const hasSignal = typeof err.signal === "string" && err.signal.length > 0;
+    if (hasExitStatus || hasSignal) {
+        return {
+            kind: "exit",
+            code,
+            message,
+            exitCode: hasExitStatus
+                ? err.status
+                : resolveSignalExitCode(err.signal),
+            signal: hasSignal ? err.signal : undefined,
+        };
+    }
+    return {
+        kind: "launch-error",
+        code,
+        message,
+    };
+}
+function runCodexBlocking(cwd, launchArgs, codexEnv) {
+    const { result } = spawnPlatformCommandSync("codex", launchArgs, {
+        cwd,
+        stdio: "inherit",
+        env: codexEnv,
+        encoding: "utf-8",
+    });
+    if (result.error) {
+        const errno = result.error;
+        const kind = classifySpawnError(errno);
+        if (kind === "missing") {
+            console.error("[rcs] failed to launch codex: executable not found in PATH");
+        }
+        else if (kind === "blocked") {
+            console.error(`[rcs] failed to launch codex: executable is present but blocked in the current environment (${errno.code || "blocked"})`);
+        }
+        else {
+            console.error(`[rcs] failed to launch codex: ${errno.message}`);
+        }
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        process.exitCode =
+            typeof result.status === "number"
+                ? result.status
+                : resolveSignalExitCode(result.signal);
+        if (result.signal) {
+            console.error(`[rcs] codex exited due to signal ${result.signal}`);
+        }
+    }
+}
+export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leaderPaneId) {
+    const targets = new Set(existingPaneIds.filter((id) => id.startsWith("%")));
+    if (createdPaneId && createdPaneId.startsWith("%")) {
+        targets.add(createdPaneId);
+    }
+    // Guard: never kill the leader's own pane under any circumstances.
+    if (leaderPaneId && leaderPaneId.startsWith("%")) {
+        targets.delete(leaderPaneId);
+    }
+    return [...targets];
+}
+export async function main(args) {
+    const knownCommands = new Set([
+        "launch",
+        "exec",
+        "setup",
+        "update",
+        "list",
+        "agents",
+        "agents-init",
+        "deepinit",
+        "uninstall",
+        "doctor",
+        "cleanup",
+        "ask",
+        "question",
+        "autoresearch",
+        "explore",
+        "sparkshell",
+        "team",
+        "ralph",
+        "session",
+        "resume",
+        "version",
+        "tmux-hook",
+        "hooks",
+        "hud",
+        "sidecar",
+        "state",
+        "mcp-serve",
+        "status",
+        "cancel",
+        "help",
+        "--help",
+        "-h",
+    ]);
+    const firstArg = args[0];
+    const { command, launchArgs } = resolveCliInvocation(args);
+    const flags = new Set(args.filter((a) => a.startsWith("--")));
+    const options = {
+        force: flags.has("--force"),
+        mergeAgents: flags.has("--merge-agents"),
+        dryRun: flags.has("--dry-run"),
+        verbose: flags.has("--verbose"),
+        team: flags.has("--team"),
+    };
+    if (flags.has("--help") && !commandOwnsLocalHelp(command)) {
+        console.log(HELP);
+        return;
+    }
+    try {
+        switch (command) {
+            case "launch":
+                await launchWithHud(launchArgs);
+                break;
+            case "resume":
+                await launchWithHud(["resume", ...launchArgs]);
+                break;
+            case "setup":
+                await setup({
+                    force: options.force,
+                    mergeAgents: options.mergeAgents,
+                    dryRun: options.dryRun,
+                    verbose: options.verbose,
+                    scope: resolveSetupScopeArg(args.slice(1)),
+                    installMode: resolveSetupInstallModeArg(args.slice(1)),
+                });
+                break;
+            case "update":
+                await runImmediateUpdate(process.cwd());
+                break;
+            case "list":
+                await listCommand(args.slice(1));
+                break;
+            case "agents":
+                await agentsCommand(args.slice(1));
+                break;
+            case "agents-init":
+                await agentsInitCommand(args.slice(1));
+                break;
+            case "deepinit":
+                await agentsInitCommand(args.slice(1));
+                break;
+            case "uninstall":
+                await uninstall({
+                    dryRun: options.dryRun,
+                    keepConfig: flags.has("--keep-config"),
+                    verbose: options.verbose,
+                    purge: flags.has("--purge"),
+                    scope: resolveSetupScopeArg(args.slice(1)),
+                });
+                break;
+            case "doctor": {
+                const { doctor } = await import("./doctor.js");
+                await doctor(options);
+                break;
+            }
+            case "ask":
+                await askCommand(args.slice(1));
+                break;
+            case "question":
+                await questionCommand(args.slice(1));
+                break;
+            case "adapt":
+                await adaptCommand(args.slice(1));
+                break;
+            case "cleanup":
+                await cleanupCommand(args.slice(1));
+                break;
+            case "autoresearch":
+                await autoresearchCommand(args.slice(1));
+                break;
+            case "explore":
+                await exploreCommand(args.slice(1));
+                break;
+            case "exec":
+                if (launchArgs[0] === "inject") {
+                    await execInjectCommand(launchArgs);
+                }
+                else {
+                    await execWithOverlay(launchArgs);
+                }
+                break;
+            case "sparkshell":
+                await sparkshellCommand(args.slice(1));
+                break;
+            case "team":
+                await teamCommand(args.slice(1), options);
+                break;
+            case "session":
+                await sessionCommand(args.slice(1));
+                break;
+            case "ralph":
+                await ralphCommand(args.slice(1));
+                break;
+            case "version":
+                version();
+                break;
+            case "hud":
+                await hudCommand(args.slice(1));
+                break;
+            case "sidecar":
+                await sidecarCommand(args.slice(1));
+                break;
+            case "state":
+                await stateCommand(args.slice(1));
+                break;
+            case "notepad":
+                await mcpParityCommand("notepad", args.slice(1));
+                break;
+            case "project-memory":
+                await mcpParityCommand("project-memory", args.slice(1));
+                break;
+            case "trace":
+                await mcpParityCommand("trace", args.slice(1));
+                break;
+            case "code-intel":
+                await mcpParityCommand("code-intel", args.slice(1));
+                break;
+            case "wiki":
+                await mcpParityCommand("wiki", args.slice(1));
+                break;
+            case "mcp-serve":
+                await mcpServeCommand(args.slice(1));
+                break;
+            case "tmux-hook":
+                await tmuxHookCommand(args.slice(1));
+                break;
+            case "hooks":
+                await hooksCommand(args.slice(1));
+                break;
+            case "status":
+                await showStatus();
+                break;
+            case "cancel":
+                await cancelModes();
+                break;
+            case "reasoning":
+                await reasoningCommand(args.slice(1));
+                break;
+            case "help":
+            case "--help":
+            case "-h":
+                console.log(HELP);
+                break;
+            default:
+                if (firstArg &&
+                    firstArg.startsWith("-") &&
+                    !knownCommands.has(firstArg)) {
+                    await launchWithHud(args);
+                    break;
+                }
+                console.error(`Unknown command: ${command}`);
+                console.log(HELP);
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}
+async function showStatus() {
+    const { readFile } = await import("fs/promises");
+    const cwd = process.cwd();
+    try {
+        const refs = await listModeStateFilesWithScopePreference(cwd);
+        const states = refs.map((ref) => ref.path);
+        if (states.length === 0) {
+            writeStdoutLine("No active modes.");
+            return;
+        }
+        for (const path of states) {
+            const content = await readFile(path, "utf-8");
+            let state;
+            try {
+                state = JSON.parse(content);
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+                continue;
+            }
+            const file = basename(path);
+            const mode = file.replace("-state.json", "");
+            writeStdoutLine(`${mode}: ${state.active === true ? "ACTIVE" : "inactive"} (phase: ${String(state.current_phase || "n/a")})`);
+        }
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        writeStdoutLine("No active modes.");
+    }
+}
+async function reasoningCommand(args) {
+    const mode = args[0];
+    const configPath = codexConfigPath();
+    if (!mode) {
+        if (!existsSync(configPath)) {
+            console.log(`model_reasoning_effort is not set (${configPath} does not exist).`);
+            console.log(REASONING_USAGE);
+            return;
+        }
+        const { readFile } = await import("fs/promises");
+        const content = await readFile(configPath, "utf-8");
+        const current = readTopLevelTomlString(content, REASONING_KEY);
+        if (current) {
+            console.log(`Current ${REASONING_KEY}: ${current}`);
+            return;
+        }
+        console.log(`${REASONING_KEY} is not set in ${configPath}.`);
+        console.log(REASONING_USAGE);
+        return;
+    }
+    if (!REASONING_MODE_SET.has(mode)) {
+        throw new Error(`Invalid reasoning mode "${mode}". Expected one of: ${REASONING_MODES.join(", ")}.\n${REASONING_USAGE}`);
+    }
+    const { mkdir, readFile, writeFile } = await import("fs/promises");
+    await mkdir(dirname(configPath), { recursive: true });
+    const existing = existsSync(configPath)
+        ? await readFile(configPath, "utf-8")
+        : "";
+    const updated = upsertTopLevelTomlString(existing, REASONING_KEY, mode);
+    await writeFile(configPath, updated);
+    console.log(`Set ${REASONING_KEY}="${mode}" in ${configPath}`);
+}
+export async function launchWithHud(args) {
+    if (isNativeWindows()) {
+        const { result } = spawnPlatformCommandSync("tmux", ["-V"], {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (result.error) {
+            const errno = result.error;
+            const kind = classifySpawnError(errno);
+            if (kind === "missing") {
+                console.warn("[rcs] warning: tmux was not found on native Windows. Continuing without tmux/HUD.\n" +
+                    "[rcs] To enable tmux-backed features, install psmux:\n" +
+                    "[rcs]   winget install psmux\n" +
+                    "[rcs] See: https://github.com/marlocarlo/psmux");
+            }
+            else {
+                console.warn(`[rcs] 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(`[rcs] warning: tmux reported an error on native Windows${stderr ? ` (${stderr})` : ""}. Continuing without tmux/HUD.`);
+        }
+    }
+    const launchCwd = process.cwd();
+    const parsedWorktree = parseWorktreeMode(args);
+    const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
+    const explicitLaunchPolicy = resolveEffectiveLeaderLaunchPolicyOverride(notifyTempResult.passthroughArgs, process.env);
+    const persistentCodexHomeForLaunch = resolveCodexHomeForLaunch(launchCwd, process.env);
+    const { launchPolicy, effectiveExplicitLaunchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
+    const enableNotifyFallbackAuthority = launchPolicy === "direct";
+    const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, persistentCodexHomeForLaunch);
+    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
+    let cwd = launchCwd;
+    let worktreeDirty = false;
+    if (parsedWorktree.mode.enabled) {
+        const planned = planWorktreeTarget({
+            cwd: launchCwd,
+            scope: "launch",
+            mode: parsedWorktree.mode,
+        });
+        const ensured = ensureWorktree(planned, { allowDirtyReuse: true });
+        if (ensured.enabled) {
+            cwd = ensured.worktreePath;
+            if (ensured.dirty) {
+                worktreeDirty = true;
+                process.stderr.write(`[rcs] Caution: worktree at ${cwd} has uncommitted changes.\n` +
+                    `  The session will launch as-is. Resolve the dirty state with RCS after launch, then proceed with your task.\n`);
+            }
+            const depBootstrap = ensureReusableNodeModules(cwd);
+            if (depBootstrap.strategy === "symlink") {
+                console.log(`[rcs] Reusing node_modules from ${depBootstrap.sourceNodeModulesPath}`);
+            }
+            else if (depBootstrap.strategy === "missing" && depBootstrap.warning) {
+                console.warn(`[rcs] ${depBootstrap.warning}`);
+            }
+        }
+    }
+    const sessionId = `rcs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await maybeCheckAndPromptUpdate(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: update checks must never block launch
+    }
+    try {
+        await maybePromptGithubStar();
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: star prompt must never block launch
+    }
+    // ── Phase 0.5: config repair ────────────────────────────────────────────
+    // After an rcs version upgrade the OLD setup code (still in memory) may
+    // have written a config.toml with duplicate [tui] sections.  Codex CLI's
+    // TOML parser rejects duplicates, so we repair before spawning the CLI.
+    try {
+        const repaired = await repairConfigIfNeeded(resolveCodexConfigPathForLaunch(launchCwd, process.env), getPackageRoot());
+        if (repaired) {
+            console.log("[rcs] Repaired managed config.toml compatibility issue.");
+        }
+    }
+    catch {
+        // Non-fatal: repair failure must not block launch
+    }
+    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env);
+    const codexHomeOverride = preparedCodexHome.codexHomeOverride;
+    const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
+    // ── Phase 1: preLaunch ──────────────────────────────────────────────────
+    try {
+        await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, enableNotifyFallbackAuthority, worktreeDirty);
+    }
+    catch (err) {
+        // preLaunch errors must NOT prevent Codex from starting
+        console.error(`[rcs] preLaunch warning: ${err instanceof Error ? err.message : err}`);
+    }
+    // ── Phase 2: run ────────────────────────────────────────────────────────
+    let postLaunchHandledExternally = false;
+    try {
+        const notifyTempContractRaw = notifyTempResult.contract.active
+            ? serializeNotifyTempContract(notifyTempResult.contract)
+            : null;
+        const launchResult = runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, notifyTempContractRaw, effectiveExplicitLaunchPolicy, projectLocalCodexHomeForCleanup, preparedCodexHome.runtimeCodexHomeForCleanup);
+        postLaunchHandledExternally = launchResult.postLaunchHandledExternally;
+    }
+    finally {
+        // ── Phase 3: postLaunch ─────────────────────────────────────────────
+        if (!postLaunchHandledExternally) {
+            await postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority, projectLocalCodexHomeForCleanup);
+            await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup).catch(logCliOperationFailure);
+        }
+    }
+}
+export async function execWithOverlay(args) {
+    const launchCwd = process.cwd();
+    const parsedWorktree = parseWorktreeMode(args);
+    const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
+    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
+    let cwd = launchCwd;
+    let worktreeDirty = false;
+    if (parsedWorktree.mode.enabled) {
+        const planned = planWorktreeTarget({
+            cwd: launchCwd,
+            scope: "launch",
+            mode: parsedWorktree.mode,
+        });
+        const ensured = ensureWorktree(planned, { allowDirtyReuse: true });
+        if (ensured.enabled) {
+            cwd = ensured.worktreePath;
+            if (ensured.dirty) {
+                worktreeDirty = true;
+                process.stderr.write(`[rcs] Caution: worktree at ${cwd} has uncommitted changes.\n` +
+                    `  The session will launch as-is. Resolve the dirty state with RCS after launch, then proceed with your task.\n`);
+            }
+            const depBootstrap = ensureReusableNodeModules(cwd);
+            if (depBootstrap.strategy === "symlink") {
+                console.log(`[rcs] Reusing node_modules from ${depBootstrap.sourceNodeModulesPath}`);
+            }
+            else if (depBootstrap.strategy === "missing" && depBootstrap.warning) {
+                console.warn(`[rcs] ${depBootstrap.warning}`);
+            }
+        }
+    }
+    const sessionId = `rcs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await maybeCheckAndPromptUpdate(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    try {
+        await maybePromptGithubStar();
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+    }
+    try {
+        const repaired = await repairConfigIfNeeded(resolveCodexConfigPathForLaunch(launchCwd, process.env), getPackageRoot());
+        if (repaired) {
+            console.log("[rcs] Repaired managed config.toml compatibility issue.");
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env);
+    const codexHomeOverride = preparedCodexHome.codexHomeOverride;
+    const projectLocalCodexHomeForCleanup = preparedCodexHome.projectLocalCodexHomeForCleanup;
+    try {
+        await preLaunch(cwd, sessionId, notifyTempResult.contract, codexHomeOverride, true, worktreeDirty);
+    }
+    catch (err) {
+        console.error(`[rcs] preLaunch warning: ${err instanceof Error ? err.message : err}`);
+    }
+    try {
+        const notifyTempContractRaw = notifyTempResult.contract.active
+            ? serializeNotifyTempContract(notifyTempResult.contract)
+            : null;
+        const codexArgs = injectModelInstructionsBypassArgs(cwd, ["exec", ...normalizedArgs], process.env, sessionModelInstructionsPath(cwd, sessionId));
+        const codexEnvBase = codexHomeOverride
+            ? { ...process.env, CODEX_HOME: codexHomeOverride }
+            : process.env;
+        const codexEnv = notifyTempContractRaw
+            ? {
+                ...codexEnvBase,
+                [RCS_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw,
+            }
+            : codexEnvBase;
+        runCodexBlocking(cwd, codexArgs, codexEnv);
+    }
+    finally {
+        await postLaunch(cwd, sessionId, codexHomeOverride, true, projectLocalCodexHomeForCleanup);
+        await cleanupRuntimeCodexHome(preparedCodexHome.runtimeCodexHomeForCleanup).catch(logCliOperationFailure);
+    }
+}
+export function normalizeCodexLaunchArgs(args) {
+    const parsed = parseWorktreeMode(args);
+    const launchPolicyParsed = splitLeaderLaunchPolicyArgs(parsed.remainingArgs);
+    const normalized = [];
+    let wantsBypass = false;
+    let hasBypass = false;
+    let reasoningMode = null;
+    for (const arg of launchPolicyParsed.remainingArgs) {
+        if (arg === MADMAX_FLAG) {
+            wantsBypass = true;
+            continue;
+        }
+        if (arg === CODEX_BYPASS_FLAG) {
+            wantsBypass = true;
+            if (!hasBypass) {
+                normalized.push(arg);
+                hasBypass = true;
+            }
+            continue;
+        }
+        if (arg === HIGH_REASONING_FLAG) {
+            reasoningMode = "high";
+            continue;
+        }
+        if (arg === XHIGH_REASONING_FLAG) {
+            reasoningMode = "xhigh";
+            continue;
+        }
+        if (arg === SPARK_FLAG) {
+            // Spark model is injected into worker env only (not the leader). Consume flag.
+            continue;
+        }
+        if (arg === MADMAX_SPARK_FLAG) {
+            // Bypass applies to leader; spark model goes to workers only. Consume flag.
+            wantsBypass = true;
+            continue;
+        }
+        normalized.push(arg);
+    }
+    if (wantsBypass && !hasBypass) {
+        normalized.push(CODEX_BYPASS_FLAG);
+    }
+    if (reasoningMode) {
+        normalized.push(CONFIG_FLAG, `${REASONING_KEY}="${reasoningMode}"`);
+    }
+    return normalized;
+}
+/**
+ * Returns the spark model string if --spark or --madmax-spark appears in the
+ * raw (pre-normalize) args, or undefined if neither flag is present.
+ * Used to route the spark model to team workers without affecting the leader.
+ */
+export function resolveWorkerSparkModel(args, codexHomeOverride) {
+    for (const arg of args) {
+        if (arg === SPARK_FLAG || arg === MADMAX_SPARK_FLAG) {
+            return resolveTeamLowComplexityDefaultModel(codexHomeOverride);
+        }
+    }
+    return undefined;
+}
+function isModelInstructionsOverride(value) {
+    return new RegExp(`^${MODEL_INSTRUCTIONS_FILE_KEY}\\s*=`).test(value.trim());
+}
+function hasModelInstructionsOverride(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === CONFIG_FLAG || arg === LONG_CONFIG_FLAG) {
+            const maybeValue = args[i + 1];
+            if (typeof maybeValue === "string" &&
+                isModelInstructionsOverride(maybeValue)) {
+                return true;
+            }
+            continue;
+        }
+        if (arg.startsWith(`${LONG_CONFIG_FLAG}=`)) {
+            const inlineValue = arg.slice(`${LONG_CONFIG_FLAG}=`.length);
+            if (isModelInstructionsOverride(inlineValue))
+                return true;
+        }
+    }
+    return false;
+}
+function shouldBypassDefaultSystemPrompt(env) {
+    return env[RCS_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV] !== "0";
+}
+function buildModelInstructionsOverride(cwd, env, defaultFilePath) {
+    const filePath = env[RCS_MODEL_INSTRUCTIONS_FILE_ENV] ||
+        defaultFilePath ||
+        join(cwd, "AGENTS.md");
+    return `${MODEL_INSTRUCTIONS_FILE_KEY}="${escapeTomlString(filePath)}"`;
+}
+function tryReadGitValue(cwd, args) {
+    try {
+        const value = execFileSync("git", args, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }).trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractIssueNumber(text) {
+    const explicit = text.match(/\bissue\s*#(\d+)\b/i);
+    if (explicit)
+        return Number.parseInt(explicit[1], 10);
+    const generic = text.match(/(^|[^\w/])#(\d+)\b/);
+    return generic ? Number.parseInt(generic[2], 10) : undefined;
+}
+export function resolveNativeSessionName(cwd, sessionId, env = process.env) {
+    if (env.TMUX) {
+        try {
+            const tmuxPaneTarget = env.TMUX_PANE?.trim();
+            const displayArgs = tmuxPaneTarget
+                ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+                : ["display-message", "-p", "#S"];
+            const tmuxSession = execTmuxFileSync(displayArgs, {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 2000,
+            }).trim();
+            if (tmuxSession)
+                return tmuxSession;
+        }
+        catch {
+            // best effort only
+        }
+    }
+    return buildTmuxSessionName(cwd, sessionId);
+}
+function tagTmuxSessionWithInstance(sessionName, sessionId) {
+    const target = sessionName.trim();
+    const instanceId = sessionId.trim();
+    if (!target || !instanceId)
+        return;
+    execFileSync("tmux", ["set-option", "-t", target, RCS_INSTANCE_OPTION, instanceId], {
+        stdio: ["ignore", "ignore", "ignore"],
+        timeout: 2000,
+    });
+}
+function tagCurrentTmuxSessionWithInstance(sessionId) {
+    if (!process.env.TMUX)
+        return;
+    try {
+        const tmuxPaneTarget = process.env.TMUX_PANE;
+        const displayArgs = tmuxPaneTarget
+            ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+            : ["display-message", "-p", "#S"];
+        const sessionName = execFileSync("tmux", displayArgs, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }).trim();
+        if (sessionName)
+            tagTmuxSessionWithInstance(sessionName, sessionId);
+    }
+    catch {
+        // Best effort only: launch should not fail just because tmux tagging failed.
+    }
+}
+function buildNativeHookBaseContext(cwd, sessionId, normalizedEvent, extra = {}) {
+    const repoPath = tryReadGitValue(cwd, ["rev-parse", "--show-toplevel"]) || cwd;
+    const branch = tryReadGitValue(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const issueNumber = extractIssueNumber([branch, basename(cwd)].filter(Boolean).join(" "));
+    return {
+        normalized_event: normalizedEvent,
+        session_name: resolveNativeSessionName(cwd, sessionId),
+        repo_path: repoPath,
+        repo_name: basename(repoPath),
+        worktree_path: cwd,
+        ...(branch ? { branch } : {}),
+        ...(issueNumber !== undefined ? { issue_number: issueNumber } : {}),
+        ...extra,
+    };
+}
+export function injectModelInstructionsBypassArgs(cwd, args, env = process.env, defaultFilePath) {
+    if (!shouldBypassDefaultSystemPrompt(env))
+        return [...args];
+    if (hasModelInstructionsOverride(args))
+        return [...args];
+    return [
+        ...args,
+        CONFIG_FLAG,
+        buildModelInstructionsOverride(cwd, env, defaultFilePath),
+    ];
+}
+export function collectInheritableTeamWorkerArgs(codexArgs) {
+    return collectInheritableTeamWorkerArgsShared(codexArgs);
+}
+export function resolveTeamWorkerLaunchArgsEnv(existingRaw, codexArgs, inheritLeaderFlags = true, defaultModel) {
+    const inheritedArgs = inheritLeaderFlags
+        ? collectInheritableTeamWorkerArgs(codexArgs)
+        : [];
+    const normalized = resolveTeamWorkerLaunchArgs({
+        existingRaw,
+        inheritedArgs,
+        fallbackModel: defaultModel,
+    });
+    if (normalized.length === 0)
+        return null;
+    return normalized.join(" ");
+}
+export 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("#"))
+            continue;
+        if (/^\[[^[\]]+\]\s*(#.*)?$/.test(trimmed)) {
+            inTopLevel = false;
+            continue;
+        }
+        if (!inTopLevel)
+            continue;
+        const match = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=\s*(.*?)\s*(?:#.*)?$/);
+        if (!match || match[1] !== key)
+            continue;
+        return parseTomlStringValue(match[2]);
+    }
+    return null;
+}
+export function upsertTopLevelTomlString(content, key, value) {
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const assignment = `${key} = "${escapeTomlString(value)}"`;
+    if (!content.trim()) {
+        return assignment + eol;
+    }
+    const lines = content.split(/\r?\n/);
+    let replaced = false;
+    let inTopLevel = true;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        if (/^\[[^[\]]+\]\s*(#.*)?$/.test(trimmed)) {
+            inTopLevel = false;
+            continue;
+        }
+        if (!inTopLevel)
+            continue;
+        const match = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=/);
+        if (match && match[1] === key) {
+            lines[i] = assignment;
+            replaced = true;
+            break;
+        }
+    }
+    if (!replaced) {
+        const firstTableIndex = lines.findIndex((line) => /^\s*\[[^[\]]+\]\s*(#.*)?$/.test(line.trim()));
+        if (firstTableIndex >= 0) {
+            lines.splice(firstTableIndex, 0, assignment);
+        }
+        else {
+            lines.push(assignment);
+        }
+    }
+    let out = lines.join(eol);
+    if (!out.endsWith(eol))
+        out += eol;
+    return out;
+}
+function parseTomlStringValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function escapeTomlString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function sanitizeTmuxToken(value) {
+    const cleaned = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return cleaned || "unknown";
+}
+export function buildTmuxSessionName(cwd, sessionId) {
+    const parentPath = dirname(cwd);
+    const parentDir = basename(parentPath);
+    const dirName = basename(cwd);
+    const grandparentPath = dirname(parentPath);
+    const grandparentDir = basename(grandparentPath);
+    const repoDir = parentDir.endsWith(".rcs-worktrees")
+        ? parentDir.slice(0, -".rcs-worktrees".length)
+        : parentDir === "worktrees" && grandparentDir === ".rcs"
+            ? basename(dirname(grandparentPath))
+            : null;
+    const dirToken = repoDir
+        ? sanitizeTmuxToken(`${repoDir}-${dirName}`)
+        : sanitizeTmuxToken(dirName);
+    let branchToken = "detached";
+    const branch = tryReadGitValue(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (branch)
+        branchToken = sanitizeTmuxToken(branch);
+    const sessionToken = sanitizeTmuxToken(sessionId.replace(/^rcs-/, ""));
+    const prefix = `rcs-${dirToken}-${branchToken}`;
+    const name = `${prefix}-${sessionToken}`;
+    if (name.length <= 120)
+        return name;
+    const prefixBudget = Math.max(4, 120 - sessionToken.length - 1);
+    const trimmedPrefix = prefix.slice(0, prefixBudget).replace(/-+$/g, "");
+    return `${trimmedPrefix}-${sessionToken}`.slice(0, 120);
+}
+export function buildDetachedTmuxSessionName(cwd, sessionId) {
+    return buildTmuxSessionName(cwd, sessionId);
+}
+function parseWindowIndexFromTmuxOutput(rawOutput) {
+    const windowIndex = rawOutput.split("\n")[0]?.trim() || "";
+    return /^[0-9]+$/.test(windowIndex) ? windowIndex : null;
+}
+export function detectDetachedSessionWindowIndex(sessionName) {
+    try {
+        const output = execTmuxFileSync(["display-message", "-p", "-t", sessionName, "#{window_index}"], { encoding: "utf-8" });
+        return parseWindowIndexFromTmuxOutput(output);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        return null;
+    }
+}
+function escapeShellDoubleQuotedValue(value) {
+    return value.replace(/["\\$`]/g, "\\$&");
+}
+function sanitizeTmuxLeaseKey(value) {
+    const cleaned = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return cleaned || "default";
+}
+function blockMs(ms) {
+    const delay = Math.max(1, Math.floor(ms));
+    const shared = new SharedArrayBuffer(4);
+    const view = new Int32Array(shared);
+    Atomics.wait(view, 0, 0, delay);
+}
+function tmuxExtendedKeysLeaseRoot(cwd) {
+    return join(cwd, ".rcs", "state", TMUX_EXTENDED_KEYS_LEASE_DIR);
+}
+function resolveTmuxSocketPath(execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+})) {
+    return (execTmuxSync(["display-message", "-p", "#{socket_path}"], execFileSyncImpl) ||
+        "default");
+}
+function tmuxExtendedKeysLeasePath(cwd, socketPath) {
+    return join(tmuxExtendedKeysLeaseRoot(cwd), `${sanitizeTmuxLeaseKey(socketPath)}.json`);
+}
+function isTmuxExtendedKeysLeaseHolderRecord(holder) {
+    if (!holder || typeof holder !== "object")
+        return false;
+    const record = holder;
+    if (typeof record.id !== "string" || !record.id.trim())
+        return false;
+    if (!Number.isSafeInteger(record.pid) || Number(record.pid) <= 0)
+        return false;
+    if (record.platform !== undefined && typeof record.platform !== "string")
+        return false;
+    if (record.linuxStartTicks !== undefined &&
+        !Number.isSafeInteger(record.linuxStartTicks))
+        return false;
+    return true;
+}
+function isTmuxExtendedKeysLeaseHolder(holder) {
+    return typeof holder === "string" || isTmuxExtendedKeysLeaseHolderRecord(holder);
+}
+function readTmuxExtendedKeysLeaseState(leasePath) {
+    if (!existsSync(leasePath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(leasePath, "utf-8"));
+        if (typeof parsed.originalMode !== "string" ||
+            !Array.isArray(parsed.holders) ||
+            !parsed.holders.every(isTmuxExtendedKeysLeaseHolder)) {
+            return null;
+        }
+        return {
+            originalMode: parsed.originalMode,
+            holders: [...parsed.holders],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writeTmuxExtendedKeysLeaseState(leasePath, state) {
+    mkdirSync(dirname(leasePath), { recursive: true });
+    writeFileSync(leasePath, JSON.stringify(state, null, 2));
+}
+function parseTmuxExtendedKeysLeaseHolderPid(holder) {
+    const match = /^([1-9]\d*)-/.exec(holder);
+    if (!match)
+        return null;
+    const pid = Number.parseInt(match[1], 10);
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function getTmuxExtendedKeysLeaseHolderId(holder) {
+    return typeof holder === "string" ? holder : holder.id;
+}
+function getTmuxExtendedKeysLeaseHolderPid(holder) {
+    if (typeof holder === "string")
+        return parseTmuxExtendedKeysLeaseHolderPid(holder);
+    return Number.isSafeInteger(holder.pid) && holder.pid > 0 ? holder.pid : null;
+}
+function parseLinuxProcStartTicks(statContent) {
+    const commandEnd = statContent.lastIndexOf(")");
+    if (commandEnd === -1)
+        return null;
+    const remainder = statContent.slice(commandEnd + 1).trim();
+    const fields = remainder.split(/\s+/);
+    if (fields.length <= 19)
+        return null;
+    const startTicks = Number(fields[19]);
+    return Number.isSafeInteger(startTicks) ? startTicks : null;
+}
+function readLinuxProcessStartTicks(pid) {
+    try {
+        return parseLinuxProcStartTicks(readFileSync(`/proc/${pid}/stat`, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function createTmuxExtendedKeysLeaseHolder(id, pid) {
+    const linuxStartTicks = process.platform === "linux"
+        ? readLinuxProcessStartTicks(pid) ?? undefined
+        : undefined;
+    return {
+        id,
+        pid,
+        platform: process.platform,
+        ...(linuxStartTicks !== undefined ? { linuxStartTicks } : {}),
+    };
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : "";
+        return code === "EPERM";
+    }
+}
+function isTmuxExtendedKeysLeaseHolderAlive(holder) {
+    const pid = getTmuxExtendedKeysLeaseHolderPid(holder);
+    if (pid === null || !isProcessAlive(pid))
+        return false;
+    if (typeof holder === "string")
+        return true;
+    if (holder.platform !== "linux" || process.platform !== "linux")
+        return true;
+    if (holder.linuxStartTicks === undefined)
+        return true;
+    return readLinuxProcessStartTicks(pid) === holder.linuxStartTicks;
+}
+function reapDeadTmuxExtendedKeysLeaseHolders(state) {
+    return {
+        originalMode: state.originalMode,
+        holders: state.holders.filter(isTmuxExtendedKeysLeaseHolderAlive),
+    };
+}
+function withTmuxExtendedKeysLeaseLock(cwd, socketPath, run) {
+    const leaseRoot = tmuxExtendedKeysLeaseRoot(cwd);
+    mkdirSync(leaseRoot, { recursive: true });
+    const lockPath = join(leaseRoot, `${sanitizeTmuxLeaseKey(socketPath)}.lock`);
+    for (let attempt = 0; attempt < TMUX_EXTENDED_KEYS_LOCK_MAX_ATTEMPTS; attempt++) {
+        try {
+            mkdirSync(lockPath);
+            try {
+                writeFileSync(join(lockPath, "pid"), String(process.pid));
+                return run();
+            }
+            finally {
+                rmSync(lockPath, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            const code = err && typeof err === "object" && "code" in err
+                ? String(err.code)
+                : "";
+            if (code !== "EEXIST")
+                throw err;
+            const lockStat = statSync(lockPath, { throwIfNoEntry: false });
+            if (lockStat && Date.now() - lockStat.mtimeMs > TMUX_EXTENDED_KEYS_LOCK_STALE_MS) {
+                let holderAlive = false;
+                try {
+                    const holderPid = Number.parseInt(readFileSync(join(lockPath, "pid"), "utf-8").trim(), 10);
+                    if (Number.isFinite(holderPid) && holderPid > 0) {
+                        process.kill(holderPid, 0);
+                        holderAlive = true;
+                    }
+                }
+                catch {
+                    // PID file missing/unreadable or process dead (ESRCH) — treat as stale
+                }
+                if (!holderAlive) {
+                    rmSync(lockPath, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            blockMs(TMUX_EXTENDED_KEYS_LOCK_RETRY_MS);
+        }
+    }
+    throw new Error(`timed out waiting for tmux extended-keys lease lock: ${lockPath}`);
+}
+function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    const detachedPostLaunchHelper = sessionId
+        ? `${buildDetachedSessionPostLaunchHelperCommand(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup)} >/dev/null 2>&1 || true;`
+        : "";
+    const wrapped = [
+        buildTmuxExtendedKeysAcquireShellSnippet(cwd),
+        'exec 3<&0;',
+        'rcs_codex_pid="";',
+        "rcs_detached_session_cleanup() {",
+        "status=$?;",
+        "trap - 0 INT TERM HUP;",
+        'if [ -n "$rcs_codex_pid" ] && kill -0 "$rcs_codex_pid" 2>/dev/null; then',
+        'kill -TERM "$rcs_codex_pid" 2>/dev/null || true;',
+        'wait "$rcs_codex_pid" 2>/dev/null || true;',
+        "fi;",
+        'exec 3<&- 2>/dev/null || true;',
+        buildTmuxExtendedKeysReleaseShellSnippet(cwd),
+        detachedPostLaunchHelper,
+        'if [ "$status" -lt 128 ]; then',
+        `tmux kill-session -t "${escapeShellDoubleQuotedValue(sessionName)}" >/dev/null 2>&1 || true;`,
+        "fi;",
+        "exit $status;",
+        "};",
+        "trap rcs_detached_session_cleanup 0 INT TERM HUP;",
+        `${codexCmd} <&3 &`,
+        "rcs_codex_pid=$!;",
+        'wait "$rcs_codex_pid";',
+    ].join(" ");
+    return `/bin/sh -c ${quoteShellArg(wrapped)}`;
+}
+function buildDetachedSessionPostLaunchHelperCommand(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    const cwdLiteral = JSON.stringify(cwd);
+    const sessionIdLiteral = JSON.stringify(sessionId);
+    const codexHomeLiteral = typeof codexHomeOverride === "string" && codexHomeOverride.length > 0
+        ? JSON.stringify(codexHomeOverride)
+        : "undefined";
+    const projectLocalCleanupLiteral = typeof projectLocalCodexHomeForCleanup === "string" &&
+        projectLocalCodexHomeForCleanup.length > 0
+        ? JSON.stringify(projectLocalCodexHomeForCleanup)
+        : "undefined";
+    const runtimeCodexHomeCleanupLiteral = typeof runtimeCodexHomeForCleanup === "string" &&
+        runtimeCodexHomeForCleanup.length > 0
+        ? JSON.stringify(runtimeCodexHomeForCleanup)
+        : "undefined";
+    const moduleUrlLiteral = JSON.stringify(import.meta.url);
+    const script = [
+        `const mod = await import(${moduleUrlLiteral});`,
+        `await mod.runDetachedSessionPostLaunch(${cwdLiteral}, ${sessionIdLiteral}, ${codexHomeLiteral}, ${projectLocalCleanupLiteral}, ${runtimeCodexHomeCleanupLiteral});`,
+    ].join(" ");
+    return `${quoteShellArg(process.execPath)} --input-type=module -e ${quoteShellArg(script)}`;
+}
+function execTmuxSync(args, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+})) {
+    return execFileSyncImpl(resolveTmuxExecutableForLaunch(), [...args]).trim();
+}
+export function acquireTmuxExtendedKeysLease(cwd, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+}), ownerPid = process.pid) {
+    try {
+        const socketPath = resolveTmuxSocketPath(execFileSyncImpl);
+        const leasePath = tmuxExtendedKeysLeasePath(cwd, socketPath);
+        const holderPid = Number.isSafeInteger(ownerPid) && ownerPid > 0 ? ownerPid : process.pid;
+        const leaseId = `${holderPid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        withTmuxExtendedKeysLeaseLock(cwd, socketPath, () => {
+            const stateRaw = readTmuxExtendedKeysLeaseState(leasePath);
+            const state = stateRaw ? reapDeadTmuxExtendedKeysLeaseHolders(stateRaw) : null;
+            if (stateRaw && state?.holders.length === 0) {
+                execTmuxSync(["set-option", "-sq", "extended-keys", state.originalMode], execFileSyncImpl);
+                rmSync(leasePath, { force: true });
+            }
+            if (!state || state.holders.length === 0) {
+                const previousMode = execTmuxSync(["show-options", "-sv", "extended-keys"], execFileSyncImpl) ||
+                    TMUX_EXTENDED_KEYS_FALLBACK_MODE;
+                execTmuxSync(["set-option", "-sq", "extended-keys", TMUX_EXTENDED_KEYS_MODE], execFileSyncImpl);
+                writeTmuxExtendedKeysLeaseState(leasePath, {
+                    originalMode: previousMode,
+                    holders: [createTmuxExtendedKeysLeaseHolder(leaseId, holderPid)],
+                });
+                return;
+            }
+            state.holders.push(createTmuxExtendedKeysLeaseHolder(leaseId, holderPid));
+            writeTmuxExtendedKeysLeaseState(leasePath, state);
+        });
+        return `${socketPath}\t${leaseId}`;
+    }
+    catch (err) {
+        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
+            logCliOperationFailure(err);
+        }
+        return null;
+    }
+}
+export function releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+})) {
+    if (!leaseHandle.trim())
+        return;
+    const [socketPathRaw = "", leaseId = ""] = leaseHandle.split("\t");
+    const socketPath = socketPathRaw.trim() || "default";
+    if (!leaseId)
+        return;
+    try {
+        const leasePath = tmuxExtendedKeysLeasePath(cwd, socketPath);
+        withTmuxExtendedKeysLeaseLock(cwd, socketPath, () => {
+            const stateRaw = readTmuxExtendedKeysLeaseState(leasePath);
+            const state = stateRaw ? reapDeadTmuxExtendedKeysLeaseHolders(stateRaw) : null;
+            if (!state || state.holders.length === 0) {
+                if (stateRaw) {
+                    execTmuxSync(["set-option", "-sq", "extended-keys", stateRaw.originalMode], execFileSyncImpl);
+                }
+                rmSync(leasePath, { force: true });
+                return;
+            }
+            const holders = state.holders.filter((holder) => getTmuxExtendedKeysLeaseHolderId(holder) !== leaseId);
+            if (holders.length > 0) {
+                writeTmuxExtendedKeysLeaseState(leasePath, {
+                    originalMode: state.originalMode,
+                    holders,
+                });
+                return;
+            }
+            execTmuxSync(["set-option", "-sq", "extended-keys", state.originalMode], execFileSyncImpl);
+            rmSync(leasePath, { force: true });
+        });
+    }
+    catch (err) {
+        if (!isUnsupportedTmuxExtendedKeysFailure(err)) {
+            logCliOperationFailure(err);
+        }
+    }
+}
+function buildTmuxExtendedKeysHelperCommand(cwd, operation) {
+    const cwdLiteral = JSON.stringify(cwd);
+    const moduleUrlLiteral = JSON.stringify(import.meta.url);
+    const script = operation === "acquire"
+        ? `const mod = await import(${moduleUrlLiteral}); const ownerPid = Number.parseInt(process.argv[1] ?? "", 10); const lease = mod.acquireTmuxExtendedKeysLease(${cwdLiteral}, undefined, Number.isSafeInteger(ownerPid) && ownerPid > 0 ? ownerPid : undefined); if (lease) process.stdout.write(lease);`
+        : `const mod = await import(${moduleUrlLiteral}); mod.releaseTmuxExtendedKeysLease(${cwdLiteral}, process.argv[1] ?? "");`;
+    return `${quoteShellArg(process.execPath)} --input-type=module -e ${quoteShellArg(script)}`;
+}
+function buildTmuxExtendedKeysAcquireShellSnippet(cwd) {
+    return `RCS_TMUX_EXTENDED_KEYS_LEASE=$(${buildTmuxExtendedKeysHelperCommand(cwd, "acquire")} "$$" 2>/dev/null || true);`;
+}
+function buildTmuxExtendedKeysReleaseShellSnippet(cwd) {
+    return `if [ -n "\${RCS_TMUX_EXTENDED_KEYS_LEASE:-}" ]; then ${buildTmuxExtendedKeysHelperCommand(cwd, "release")} "\${RCS_TMUX_EXTENDED_KEYS_LEASE}" >/dev/null 2>&1 || true; fi;`;
+}
+export function withTmuxExtendedKeys(cwd, run, execFileSyncImpl = (file, tmuxArgs) => execFileSync(file, tmuxArgs, {
+    encoding: "utf-8",
+    ...(process.platform === "win32" ? { windowsHide: true } : {}),
+})) {
+    const leaseHandle = acquireTmuxExtendedKeysLease(cwd, execFileSyncImpl);
+    try {
+        return run();
+    }
+    finally {
+        if (leaseHandle)
+            releaseTmuxExtendedKeysLease(cwd, leaseHandle, execFileSyncImpl);
+    }
+}
+export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows = false, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    const detachedLeaderCmd = nativeWindows
+        ? "powershell.exe"
+        : buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup);
+    const newSessionArgs = [
+        "new-session",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-s",
+        sessionName,
+        "-c",
+        cwd,
+        ...(workerLaunchArgs
+            ? ["-e", `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`]
+            : []),
+        ...(sessionId ? ["-e", `RCS_SESSION_ID=${sessionId}`] : []),
+        ...(codexHomeOverride ? ["-e", `CODEX_HOME=${codexHomeOverride}`] : []),
+        ...(notifyTempContractRaw
+            ? ["-e", `${RCS_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`]
+            : []),
+        detachedLeaderCmd,
+    ];
+    const splitCaptureArgs = [
+        "split-window",
+        "-v",
+        "-l",
+        String(HUD_TMUX_HEIGHT_LINES),
+        "-d",
+        "-t",
+        sessionName,
+        "-c",
+        cwd,
+        "-P",
+        "-F",
+        "#{pane_id}",
+        hudCmd,
+    ];
+    return [
+        { name: "new-session", args: newSessionArgs },
+        ...(sessionId
+            ? [
+                {
+                    name: "tag-session",
+                    args: ["set-option", "-t", sessionName, RCS_INSTANCE_OPTION, sessionId],
+                },
+            ]
+            : []),
+        { name: "split-and-capture-hud-pane", args: splitCaptureArgs },
+    ];
+}
+async function readLaunchAppendInstructions() {
+    const appendixCandidates = [
+        process.env[RCS_RALPH_APPEND_INSTRUCTIONS_FILE_ENV]?.trim(),
+        process.env[RCS_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);
+        steps.push({
+            name: "register-resize-hook",
+            args: buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId, HUD_TMUX_HEIGHT_LINES),
+        });
+        steps.push({
+            name: "register-client-attached-reconcile",
+            args: buildRegisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName, hudPaneId, HUD_TMUX_HEIGHT_LINES),
+        });
+        steps.push({
+            name: "schedule-delayed-resize",
+            args: buildScheduleDelayedHudResizeArgs(hudPaneId, undefined, HUD_TMUX_HEIGHT_LINES),
+        });
+        steps.push({
+            name: "reconcile-hud-resize",
+            args: buildReconcileHudResizeArgs(hudPaneId, HUD_TMUX_HEIGHT_LINES),
+        });
+    }
+    if (enableMouse) {
+        steps.push({
+            name: "set-mouse",
+            args: ["set-option", "-t", sessionName, "mouse", "on"],
+        });
+        steps.push({
+            name: "sanitize-copy-mode-style",
+            args: [],
+        });
+    }
+    steps.push({
+        name: "attach-session",
+        args: ["attach-session", "-t", sessionName],
+    });
+    return steps;
+}
+export function buildDetachedSessionRollbackSteps(sessionName, hookTarget, hookName, clientAttachedHookName) {
+    const steps = [];
+    if (hookTarget && clientAttachedHookName) {
+        steps.push({
+            name: "unregister-client-attached-reconcile",
+            args: buildUnregisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName),
+        });
+    }
+    if (hookTarget && hookName) {
+        steps.push({
+            name: "unregister-resize-hook",
+            args: buildUnregisterResizeHookArgs(hookTarget, hookName),
+        });
+    }
+    steps.push({
+        name: "kill-session",
+        args: ["kill-session", "-t", sessionName],
+    });
+    return steps;
+}
+export function buildNotifyTempStartupMessages(contract, hasValidProviders) {
+    const providers = contract.canonicalSelectors.length > 0
+        ? contract.canonicalSelectors.join(",")
+        : "none";
+    const infoLines = [
+        `notify temp: active | providers=${providers} | persistent-routing=bypassed`,
+    ];
+    const warningLines = [...contract.warnings];
+    if (!hasValidProviders) {
+        warningLines.push("notify temp: no valid providers resolved; notifications skipped");
+    }
+    return { infoLines, warningLines };
+}
+export function buildNotifyFallbackWatcherEnv(env = process.env, options = {}) {
+    const nextEnv = { ...env };
+    delete nextEnv.TMUX;
+    delete nextEnv.TMUX_PANE;
+    return {
+        ...nextEnv,
+        ...(options.codexHomeOverride ? { CODEX_HOME: options.codexHomeOverride } : {}),
+        ...(options.sessionId ? { RCS_SESSION_ID: options.sessionId } : {}),
+        RCS_HUD_AUTHORITY: options.enableAuthority ? "1" : "0",
+    };
+}
+export function shouldEnableNotifyFallbackWatcher(env = process.env, platform = process.platform) {
+    const toggle = String(env.RCS_NOTIFY_FALLBACK ?? "").trim();
+    if (platform === "win32") {
+        return toggle === "1";
+    }
+    return toggle !== "0";
+}
+export async function cleanupLaunchOrphanedMcpProcesses(dependencies = {}) {
+    return cleanupRcsMcpProcesses([], {
+        ...dependencies,
+        selectCandidates: dependencies.selectCandidates ?? findLaunchSafeCleanupCandidates,
+        writeLine: dependencies.writeLine ?? (() => { }),
+    });
+}
+const POST_LAUNCH_MODE_STATE_RETRY_DELAY_MS = 10;
+const POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS = 2;
+function isLikelyTransientModeStateParseFailure(raw, err) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return true;
+    if (!(err instanceof SyntaxError))
+        return false;
+    if (!trimmed.startsWith("{") || trimmed.endsWith("}"))
+        return false;
+    return (/Unexpected end of JSON input/.test(err.message) ||
+        /Unterminated string in JSON/.test(err.message) ||
+        /Expected double-quoted property name in JSON/.test(err.message) ||
+        /Expected property name or '}' in JSON/.test(err.message) ||
+        /Expected ':' after property name in JSON/.test(err.message) ||
+        /Expected ',' or '}' after property value in JSON/.test(err.message));
+}
+async function readPostLaunchModeStateFile(path, dependencies = {}) {
+    const readFile = dependencies.readFile ?? (await import("fs/promises")).readFile;
+    const sleep = dependencies.sleep
+        ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    for (let attempt = 1; attempt <= POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS; attempt += 1) {
+        try {
+            const raw = await readFile(path, "utf-8");
+            const trimmed = raw.trim();
+            if (trimmed.length === 0) {
+                if (attempt < POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS) {
+                    await sleep(POST_LAUNCH_MODE_STATE_RETRY_DELAY_MS);
+                    continue;
+                }
+                return { kind: "recoverable" };
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (err) {
+                if (isLikelyTransientModeStateParseFailure(raw, err)) {
+                    if (attempt < POST_LAUNCH_MODE_STATE_MAX_READ_ATTEMPTS) {
+                        await sleep(POST_LAUNCH_MODE_STATE_RETRY_DELAY_MS);
+                        continue;
+                    }
+                    return { kind: "recoverable" };
+                }
+                return {
+                    kind: "malformed",
+                    message: err instanceof Error ? err.message : String(err),
+                };
+            }
+            if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+                return { kind: "malformed", message: "mode state must be a JSON object" };
+            }
+            return { kind: "ok", state: parsed };
+        }
+        catch (err) {
+            const error = err;
+            if (error?.code === "ENOENT")
+                return { kind: "missing" };
+            return {
+                kind: "malformed",
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    return { kind: "recoverable" };
+}
+function buildRecoveredPostLaunchModeState(mode, completedAt) {
+    return {
+        active: false,
+        mode,
+        current_phase: "cancelled",
+        completed_at: completedAt,
+        last_turn_at: completedAt,
+    };
+}
+function buildRecoveredPostLaunchSkillActiveState(completedAt) {
+    return {
+        version: 1,
+        active: false,
+        skill: "",
+        phase: "complete",
+        updated_at: completedAt,
+        active_skills: [],
+    };
+}
+export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependencies = {}) {
+    const readdir = dependencies.readdir ?? (await import("fs/promises")).readdir;
+    const writeFile = dependencies.writeFile ?? (await import("fs/promises")).writeFile;
+    const writeWarn = dependencies.writeWarn ?? console.warn;
+    const now = dependencies.now ?? (() => new Date());
+    const scopedDirs = [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")
+                continue;
+            const path = join(stateDir, file);
+            const mode = file.slice(0, -"-state.json".length);
+            const result = await readPostLaunchModeStateFile(path, dependencies);
+            if (result.kind !== "ok") {
+                if (result.kind === "recoverable") {
+                    try {
+                        const completedAt = now().toISOString();
+                        await writeFile(path, JSON.stringify(mode === SKILL_ACTIVE_STATE_MODE
+                            ? buildRecoveredPostLaunchSkillActiveState(completedAt)
+                            : buildRecoveredPostLaunchModeState(mode, completedAt), null, 2));
+                        if (isTrackedWorkflowMode(mode)) {
+                            await syncCanonicalSkillStateForMode({
+                                cwd,
+                                mode,
+                                active: false,
+                                currentPhase: "cancelled",
+                                sessionId: stateDir === getStateDir(cwd, sessionId) ? sessionId : undefined,
+                                nowIso: completedAt,
+                                source: "postLaunchCleanup",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        writeWarn(`[rcs] postLaunch: failed to recover mode state ${path}: ${err instanceof Error ? err.message : err}`);
+                    }
+                }
+                else if (result.kind === "malformed") {
+                    writeWarn(`[rcs] postLaunch: skipped malformed mode state ${path}: ${result.message}`);
+                }
+                continue;
+            }
+            const skillStateStillVisible = mode === SKILL_ACTIVE_STATE_MODE
+                && Array.isArray(result.state.active_skills)
+                && result.state.active_skills.length > 0;
+            if (result.state.active !== true && !skillStateStillVisible)
+                continue;
+            try {
+                const completedAt = now().toISOString();
+                if (mode === SKILL_ACTIVE_STATE_MODE) {
+                    result.state.active = false;
+                    result.state.phase = "complete";
+                    result.state.updated_at = completedAt;
+                    result.state.active_skills = [];
+                    await writeFile(path, JSON.stringify(result.state, null, 2));
+                    continue;
+                }
+                result.state.active = false;
+                result.state.current_phase = "cancelled";
+                result.state.completed_at = completedAt;
+                await writeFile(path, JSON.stringify(result.state, null, 2));
+                if (isTrackedWorkflowMode(mode)) {
+                    await syncCanonicalSkillStateForMode({
+                        cwd,
+                        mode,
+                        active: false,
+                        currentPhase: "cancelled",
+                        sessionId: stateDir === getStateDir(cwd, sessionId) ? sessionId : undefined,
+                        nowIso: completedAt,
+                        source: "postLaunchCleanup",
+                    });
+                }
+            }
+            catch (err) {
+                writeWarn(`[rcs] postLaunch: failed to update mode state ${path}: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    }
+}
+export async function reapPostLaunchOrphanedMcpProcesses(dependencies = {}) {
+    const cleanup = dependencies.cleanup ?? cleanupLaunchOrphanedMcpProcesses;
+    const writeInfo = dependencies.writeInfo ?? console.log;
+    const writeWarn = dependencies.writeWarn ?? console.warn;
+    const writeError = dependencies.writeError ?? ((line) => process.stderr.write(line));
+    try {
+        const result = await cleanup();
+        if (result.terminatedCount > 0) {
+            writeInfo(`[rcs] postLaunch: reaped ${result.terminatedCount} orphaned RCS MCP process(es).`);
+        }
+        if (result.failedPids.length > 0) {
+            writeWarn(`[rcs] postLaunch: failed to reap ${result.failedPids.length} orphaned RCS MCP process(es); continuing cleanup.`);
+        }
+    }
+    catch (err) {
+        writeError(`[cli/index] postLaunch MCP cleanup failed: ${err}\n`);
+    }
+}
+/**
+ * preLaunch: Prepare environment before Codex starts.
+ * 1. Best-effort launch-safe orphan cleanup for detached RCS MCP processes
+ * 2. Generate runtime overlay + write session-scoped model instructions file
+ * 3. Write session.json
+ *
+ * Automatic broad stale-session cleanup remains disabled here. Only detached
+ * RCS MCP processes without a live Codex ancestor are reaped so new launches
+ * do not accumulate stale processes from prior crashed/closed sessions.
+ */
+async function preLaunch(cwd, sessionId, notifyTempContract, codexHomeOverride, enableNotifyFallbackAuthority = false, worktreeDirty = false) {
+    // 1. Best-effort launch-safe orphan cleanup
+    try {
+        const cleanup = await cleanupLaunchOrphanedMcpProcesses();
+        if (cleanup.terminatedCount > 0) {
+            console.log(`[rcs] Reaped ${cleanup.terminatedCount} orphaned RCS MCP process(es) before launch.`);
+        }
+        if (cleanup.failedPids.length > 0) {
+            console.warn(`[rcs] Failed to reap ${cleanup.failedPids.length} orphaned RCS MCP process(es); continuing launch.`);
+        }
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 2. Generate runtime overlay + write session-scoped model instructions file
+    const orchestrationMode = await resolveSessionOrchestrationMode(cwd, sessionId);
+    const overlay = await generateOverlay(cwd, sessionId, { orchestrationMode });
+    const launchAppendix = await readLaunchAppendInstructions();
+    const dirtyWorktreeGuidance = worktreeDirty
+        ? `\n\n## Session start: dirty worktree detected\n\nThis worktree has uncommitted changes that were present when the session launched.\nBefore executing the requested task, resolve the dirty state first:\n1. Review uncommitted changes with \`git status\` and \`git diff\`.\n2. Commit, stash, or discard changes as appropriate.\n3. Then proceed with the original task.`
+        : "";
+    const sessionInstructions = launchAppendix.trim().length > 0
+        ? `${overlay}
+
+${launchAppendix}${dirtyWorktreeGuidance}`
+        : `${overlay}${dirtyWorktreeGuidance}`;
+    await writeSessionModelInstructionsFile(cwd, sessionId, sessionInstructions);
+    // 3. Write session state
+    await resetSessionMetrics(cwd, sessionId);
+    await writeSessionStart(cwd, sessionId);
+    tagCurrentTmuxSessionWithInstance(sessionId);
+    // 4. Start notify fallback watcher (best effort)
+    try {
+        await startNotifyFallbackWatcher(cwd, { codexHomeOverride, enableAuthority: enableNotifyFallbackAuthority, sessionId });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 5. Start derived watcher (best effort, opt-in)
+    try {
+        await startHookDerivedWatcher(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 6. Emit temp notification startup summary + warnings, then send session-start lifecycle notification (best effort)
+    try {
+        if (notifyTempContract?.active) {
+            process.env[RCS_NOTIFY_TEMP_CONTRACT_ENV] =
+                serializeNotifyTempContract(notifyTempContract);
+            const { getNotificationConfig } = await import("../notifications/config.js");
+            const resolved = getNotificationConfig();
+            const startup = buildNotifyTempStartupMessages(notifyTempContract, Boolean(resolved?.enabled));
+            for (const info of startup.infoLines) {
+                console.log(`[rcs] ${info}`);
+            }
+            for (const warning of startup.warningLines) {
+                console.warn(`[rcs] ${warning}`);
+            }
+        }
+        else {
+            delete process.env[RCS_NOTIFY_TEMP_CONTRACT_ENV];
+        }
+        const { notifyLifecycle } = await import("../notifications/index.js");
+        await notifyLifecycle("session-start", {
+            sessionId,
+            projectPath: cwd,
+            projectName: basename(cwd),
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: notification failures must never block launch
+    }
+    // 7. Dispatch native hook event (best effort)
+    try {
+        await emitNativeHookEvent(cwd, "session-start", {
+            session_id: sessionId,
+            context: buildNativeHookBaseContext(cwd, sessionId, "started", {
+                project_path: cwd,
+                project_name: basename(cwd),
+                status: "started",
+            }),
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+}
+/**
+ * runCodex: Launch Codex CLI (blocks until exit).
+ * All 3 paths (new tmux, existing tmux, no tmux) block via execSync/execFileSync.
+ */
+function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, notifyTempContractRaw, explicitLaunchPolicy, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    const launchArgs = injectModelInstructionsBypassArgs(cwd, args, process.env, sessionModelInstructionsPath(cwd, sessionId));
+    const nativeWindows = isNativeWindows();
+    const rcsBin = resolveRcsEntryPath();
+    if (!rcsBin) {
+        throw new Error("Unable to resolve RCS launcher path for tmux HUD bootstrap");
+    }
+    const hudCmd = nativeWindows
+        ? buildWindowsPromptCommand("node", [rcsBin, "hud", "--watch"])
+        : buildTmuxPaneCommand("env", [`RCS_SESSION_ID=${sessionId}`, "node", rcsBin, "hud", "--watch"]);
+    const inheritLeaderFlags = process.env[TEAM_INHERIT_LEADER_FLAGS_ENV] !== "0";
+    const workerLaunchArgs = resolveTeamWorkerLaunchArgsEnv(process.env[TEAM_WORKER_LAUNCH_ARGS_ENV], launchArgs, inheritLeaderFlags, workerDefaultModel);
+    const codexBaseEnv = codexHomeOverride
+        ? { ...process.env, CODEX_HOME: codexHomeOverride }
+        : process.env;
+    const codexEnvWithSession = { ...codexBaseEnv, RCS_SESSION_ID: sessionId };
+    const codexEnv = workerLaunchArgs
+        ? { ...codexEnvWithSession, [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs }
+        : codexEnvWithSession;
+    const codexEnvWithNotify = notifyTempContractRaw
+        ? { ...codexEnv, [RCS_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw }
+        : codexEnv;
+    const { launchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, nativeWindows);
+    if (isCodexVersionRequest(launchArgs)) {
+        runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+        return { postLaunchHandledExternally: false };
+    }
+    if (launchPolicy === "inside-tmux") {
+        // Already in tmux: launch codex in current pane, HUD in bottom split
+        const currentPaneId = process.env.TMUX_PANE;
+        const staleHudPaneIds = listHudWatchPaneIdsInCurrentWindow(currentPaneId);
+        for (const paneId of staleHudPaneIds) {
+            killTmuxPane(paneId);
+        }
+        let hudPaneId = null;
+        try {
+            hudPaneId = createHudWatchPane(cwd, hudCmd);
+        }
+        catch (err) {
+            logCliOperationFailure(err);
+            // HUD split failed, continue without it
+        }
+        // Enable mouse scrolling at session start so scroll works before team
+        // expansion. Previously this was only called from createTeamSession().
+        // Opt-out: set RCS_MOUSE=0. (closes #128)
+        if (process.env.RCS_MOUSE !== "0") {
+            try {
+                const tmuxPaneTarget = process.env.TMUX_PANE;
+                const displayArgs = tmuxPaneTarget
+                    ? ["display-message", "-p", "-t", tmuxPaneTarget, "#S"]
+                    : ["display-message", "-p", "#S"];
+                const tmuxSession = execTmuxFileSync(displayArgs, {
+                    encoding: "utf-8",
+                }).trim();
+                if (tmuxSession)
+                    enableMouseScrolling(tmuxSession);
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+                // Non-fatal: mouse scrolling is a convenience feature
+            }
+        }
+        const activePaneId = process.env.TMUX_PANE?.trim();
+        if (activePaneId) {
+            try {
+                execTmuxFileSync(["display-message", "-p", "-t", activePaneId, "#S"], {
+                    encoding: "utf-8",
+                });
+            }
+            catch { }
+        }
+        try {
+            withTmuxExtendedKeys(cwd, () => {
+                runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+            });
+        }
+        finally {
+            const cleanupPaneIds = buildHudPaneCleanupTargets(listHudWatchPaneIdsInCurrentWindow(currentPaneId), hudPaneId, currentPaneId);
+            for (const paneId of cleanupPaneIds) {
+                killTmuxPane(paneId);
+            }
+        }
+        return { postLaunchHandledExternally: false };
+    }
+    else if (launchPolicy === "direct") {
+        // Detached HUD sessions require tmux. Skip the bootstrap entirely when the
+        // binary is unavailable so direct launches do not emit noisy ENOENT logs.
+        runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+        return { postLaunchHandledExternally: false };
+    }
+    else {
+        // Not in tmux: create a new tmux session with codex + HUD pane
+        const codexCmd = buildTmuxPaneCommand("codex", launchArgs);
+        const detachedWindowsCodexCmd = nativeWindows
+            ? buildWindowsPromptCommand("codex", launchArgs)
+            : null;
+        const sessionName = buildDetachedTmuxSessionName(cwd, sessionId);
+        void writeSessionStart(cwd, sessionId, { tmuxSessionName: sessionName }).catch((err) => {
+            logCliOperationFailure(err);
+            // Non-fatal: managed tmux recovery can still use compatibility fallback.
+        });
+        let createdDetachedSession = false;
+        let registeredHookTarget = null;
+        let registeredHookName = null;
+        let registeredClientAttachedHookName = null;
+        try {
+            const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw, nativeWindows, sessionId, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup);
+            for (const step of bootstrapSteps) {
+                const output = execTmuxFileSync(step.args, {
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+                if (step.name === "new-session") {
+                    createdDetachedSession = true;
+                    parsePaneIdFromTmuxOutput(output || "");
+                }
+                if (step.name === "split-and-capture-hud-pane") {
+                    const hudPaneId = parsePaneIdFromTmuxOutput(output || "");
+                    const hookWindowIndex = hudPaneId
+                        ? detectDetachedSessionWindowIndex(sessionName)
+                        : null;
+                    const hookTarget = hudPaneId && hookWindowIndex
+                        ? buildResizeHookTarget(sessionName, hookWindowIndex)
+                        : null;
+                    const hookName = hudPaneId && hookWindowIndex
+                        ? buildResizeHookName("launch", sessionName, hookWindowIndex, hudPaneId)
+                        : null;
+                    const clientAttachedHookName = hudPaneId && hookWindowIndex
+                        ? buildClientAttachedReconcileHookName("launch", sessionName, hookWindowIndex, hudPaneId)
+                        : null;
+                    const finalizeSteps = buildDetachedSessionFinalizeSteps(sessionName, hudPaneId, hookWindowIndex, process.env.RCS_MOUSE !== "0", nativeWindows);
+                    if (nativeWindows && detachedWindowsCodexCmd) {
+                        scheduleDetachedWindowsCodexLaunch(sessionName, detachedWindowsCodexCmd);
+                    }
+                    for (const finalizeStep of finalizeSteps) {
+                        if (finalizeStep.name === "sanitize-copy-mode-style") {
+                            try {
+                                mitigateCopyModeUnderlineArtifacts(sessionName);
+                            }
+                            catch (err) {
+                                logCliOperationFailure(err);
+                            }
+                            continue;
+                        }
+                        const stdio = finalizeStep.name === "attach-session" ? "inherit" : "ignore";
+                        try {
+                            execTmuxFileSync(finalizeStep.args, { stdio });
+                        }
+                        catch (err) {
+                            logCliOperationFailure(err);
+                            if (finalizeStep.name === "attach-session")
+                                throw new Error("failed to attach detached tmux session");
+                            continue;
+                        }
+                        if (finalizeStep.name === "register-resize-hook" &&
+                            hookTarget &&
+                            hookName) {
+                            registeredHookTarget = hookTarget;
+                            registeredHookName = hookName;
+                        }
+                        if (finalizeStep.name === "register-client-attached-reconcile" &&
+                            clientAttachedHookName) {
+                            registeredClientAttachedHookName = clientAttachedHookName;
+                        }
+                    }
+                }
+            }
+            return { postLaunchHandledExternally: !nativeWindows };
+        }
+        catch (err) {
+            logCliOperationFailure(err);
+            if (createdDetachedSession) {
+                const rollbackSteps = buildDetachedSessionRollbackSteps(sessionName, registeredHookTarget, registeredHookName, registeredClientAttachedHookName);
+                for (const rollbackStep of rollbackSteps) {
+                    try {
+                        execTmuxFileSync(rollbackStep.args, { stdio: "ignore" });
+                    }
+                    catch (err) {
+                        logCliOperationFailure(err);
+                        // best-effort rollback only
+                    }
+                }
+            }
+            // tmux not available or failed, just run codex directly
+            runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
+            return { postLaunchHandledExternally: false };
+        }
+    }
+}
+function listHudWatchPaneIdsInCurrentWindow(currentPaneId) {
+    try {
+        return listCurrentWindowHudPaneIds(currentPaneId);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        return [];
+    }
+}
+function createHudWatchPane(cwd, hudCmd) {
+    return createSharedHudWatchPane(cwd, hudCmd, { heightLines: HUD_TMUX_HEIGHT_LINES });
+}
+function killTmuxPane(paneId) {
+    if (!paneId.startsWith("%"))
+        return;
+    try {
+        killSharedTmuxPane(paneId);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Pane may already be gone; ignore.
+    }
+}
+export function buildTmuxShellCommand(command, args) {
+    return [quoteShellArg(command), ...args.map(quoteShellArg)].join(" ");
+}
+function encodePowerShellCommand(commandText) {
+    return Buffer.from(commandText, "utf16le").toString("base64");
+}
+function isCodexVersionRequest(args) {
+    return args.some((arg) => CODEX_VERSION_FLAGS.has(arg));
+}
+export function buildWindowsPromptCommand(command, args) {
+    const invocation = [
+        "&",
+        quotePowerShellArg(command),
+        ...args.map(quotePowerShellArg),
+    ].join(" ");
+    const wrappedCommand = [
+        "$ErrorActionPreference = 'Stop'",
+        `& { ${invocation} }`,
+    ].join("; ");
+    return `powershell.exe -NoLogo -NoExit -EncodedCommand ${encodePowerShellCommand(wrappedCommand)}`;
+}
+/**
+ * Wrap a command for tmux pane execution while preserving the tmux pane cwd.
+ * tmux already starts the pane at `-c <cwd>`; using a login shell here can
+ * reset that cwd back to the shell's startup directory on some setups.
+ * Source zsh/bash rc files explicitly when needed, then exec the target.
+ */
+export function buildTmuxPaneCommand(command, args, shellPath = process.env.SHELL) {
+    const bareCmd = buildTmuxShellCommand(command, args);
+    let rcSource = "";
+    if (shellPath && /\/zsh$/i.test(shellPath)) {
+        rcSource = "if [ -f ~/.zshrc ]; then source ~/.zshrc; fi; ";
+    }
+    else if (shellPath && /\/bash$/i.test(shellPath)) {
+        rcSource = "if [ -f ~/.bashrc ]; then source ~/.bashrc; fi; ";
+    }
+    const rawShell = shellPath && shellPath.trim() !== "" ? shellPath.trim() : "/bin/sh";
+    const shellBin = ALLOWED_SHELLS.has(rawShell) ? rawShell : "/bin/sh";
+    const inner = `${rcSource}exec ${bareCmd}`;
+    return `${quoteShellArg(shellBin)} -c ${quoteShellArg(inner)}`;
+}
+function quoteShellArg(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function quotePowerShellArg(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export function buildDetachedWindowsBootstrapScript(sessionName, commandText, delayMs = WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS, tmuxCommand = resolveTmuxExecutableForLaunch()) {
+    const delay = Number.isFinite(delayMs) && delayMs > 0
+        ? Math.floor(delayMs)
+        : WINDOWS_DETACHED_BOOTSTRAP_DELAY_MS;
+    const targetLiteral = JSON.stringify(`${sessionName}:0.0`);
+    const commandLiteral = JSON.stringify(commandText);
+    const tmuxCommandLiteral = JSON.stringify(tmuxCommand);
+    return [
+        "const { execFileSync } = require('child_process');",
+        `const tmuxCommand = ${tmuxCommandLiteral};`,
+        `setTimeout(() => {`,
+        `try { execFileSync(tmuxCommand, ['send-keys', '-t', ${targetLiteral}, '-l', '--', ${commandLiteral}], { stdio: 'ignore' }); } catch {}`,
+        `try { execFileSync(tmuxCommand, ['send-keys', '-t', ${targetLiteral}, 'C-m'], { stdio: 'ignore' }); } catch {}`,
+        `}, ${delay});`,
+    ].join("");
+}
+function scheduleDetachedWindowsCodexLaunch(sessionName, commandText) {
+    const child = spawn(process.execPath, ["-e", buildDetachedWindowsBootstrapScript(sessionName, commandText)], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+}
+/**
+ * postLaunch: Clean up after Codex exits.
+ * Each step is independently fault-tolerant (try/catch per step).
+ */
+async function postLaunch(cwd, sessionId, codexHomeOverride, enableNotifyFallbackAuthority = false, projectLocalCodexHomeForCleanup) {
+    // Capture session start time before cleanup (writeSessionEnd deletes session.json)
+    let sessionStartedAt;
+    try {
+        const sessionState = await readSessionState(cwd);
+        sessionStartedAt = sessionState?.started_at;
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0. Reap MCP orphans left behind by the session that just exited.
+    await reapPostLaunchOrphanedMcpProcesses();
+    // 0. Flush fallback watcher once to reduce race with fast codex exit.
+    try {
+        await flushNotifyFallbackOnce(cwd, { codexHomeOverride, enableAuthority: enableNotifyFallbackAuthority, sessionId });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0. Stop notify fallback watcher first.
+    try {
+        await stopNotifyFallbackWatcher(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0. Flush derived watcher once on shutdown (opt-in, best effort).
+    try {
+        await flushHookDerivedWatcherOnce(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0.1 Stop derived watcher first (opt-in, best effort).
+    try {
+        await stopHookDerivedWatcher(cwd);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 0.5. Remove Codex transient TUI NUX counters from project-local config only.
+    try {
+        if (projectLocalCodexHomeForCleanup) {
+            await cleanCodexModelAvailabilityNuxIfNeeded(join(projectLocalCodexHomeForCleanup, "config.toml"));
+        }
+    }
+    catch (err) {
+        console.error(`[rcs] postLaunch: project config transient NUX cleanup failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 1. Remove session-scoped model instructions file
+    try {
+        await removeSessionModelInstructionsFile(cwd, sessionId);
+    }
+    catch (err) {
+        console.error(`[rcs] postLaunch: model instructions cleanup failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 2. Archive session (write history, delete session.json)
+    try {
+        await writeSessionEnd(cwd, sessionId);
+    }
+    catch (err) {
+        console.error(`[rcs] postLaunch: session archive failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 2.5. Best-effort wiki session capture
+    try {
+        const { onSessionEnd } = await import("../wiki/lifecycle.js");
+        onSessionEnd({ cwd, session_id: sessionId });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: wiki capture must never block session cleanup
+    }
+    // 3. Cancel any still-active modes
+    try {
+        await cleanupPostLaunchModeStateFiles(cwd, sessionId);
+    }
+    catch (err) {
+        console.error(`[rcs] postLaunch: mode cleanup failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // 4. Send session-end lifecycle notification (best effort)
+    try {
+        const { notifyLifecycle } = await import("../notifications/index.js");
+        const durationMs = sessionStartedAt
+            ? Date.now() - new Date(sessionStartedAt).getTime()
+            : undefined;
+        await notifyLifecycle("session-end", {
+            sessionId,
+            projectPath: cwd,
+            projectName: basename(cwd),
+            durationMs,
+            reason: "session_exit",
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal: notification failures must never block session cleanup
+    }
+    // 4.5. Persist team leader attention when an active leader session exits.
+    try {
+        const { markOwnedTeamsLeaderSessionStopped } = await import("../team/state.js");
+        await markOwnedTeamsLeaderSessionStopped(cwd, sessionId);
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+    // 5. Dispatch native hook event (best effort)
+    try {
+        const durationMs = sessionStartedAt
+            ? Date.now() - new Date(sessionStartedAt).getTime()
+            : undefined;
+        const normalizedEvent = process.exitCode && process.exitCode !== 0 ? "failed" : "finished";
+        const errorSummary = normalizedEvent === "failed"
+            ? `codex exited with code ${process.exitCode}`
+            : undefined;
+        await emitNativeHookEvent(cwd, "session-end", {
+            session_id: sessionId,
+            context: buildNativeHookBaseContext(cwd, sessionId, normalizedEvent, {
+                project_path: cwd,
+                project_name: basename(cwd),
+                duration_ms: durationMs,
+                reason: "session_exit",
+                status: normalizedEvent === "failed" ? "failed" : "finished",
+                ...(process.exitCode !== undefined
+                    ? { exit_code: process.exitCode }
+                    : {}),
+                ...(errorSummary ? { error_summary: errorSummary } : {}),
+            }),
+        });
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        // Non-fatal
+    }
+}
+export async function runDetachedSessionPostLaunch(cwd, sessionId, codexHomeOverride, projectLocalCodexHomeForCleanup, runtimeCodexHomeForCleanup) {
+    await postLaunch(cwd, sessionId, codexHomeOverride, false, projectLocalCodexHomeForCleanup);
+    await cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup).catch(logCliOperationFailure);
+}
+async function emitNativeHookEvent(cwd, event, opts = {}) {
+    const payload = buildHookEvent(event, {
+        source: "native",
+        context: opts.context || {},
+        session_id: opts.session_id,
+        thread_id: opts.thread_id,
+        turn_id: opts.turn_id,
+        mode: opts.mode,
+    });
+    await dispatchHookEvent(payload, {
+        cwd,
+        enabled: true,
+    });
+}
+function notifyFallbackPidPath(cwd) {
+    return join(cwd, ".rcs", "state", "notify-fallback.pid");
+}
+function hookDerivedWatcherPidPath(cwd) {
+    return join(cwd, ".rcs", "state", "hook-derived-watcher.pid");
+}
+export function shouldDetachBackgroundHelper(env = process.env, platform = process.platform) {
+    // The long-running watcher/helper itself must stay detached so it can
+    // survive parent loss. Windows Git Bash/MSYS uses a short hidden bootstrap
+    // process so the detached helper is created without stealing focus.
+    void env;
+    void platform;
+    return true;
+}
+export function resolveBackgroundHelperLaunchMode(env = process.env, platform = process.platform) {
+    return platform === "win32" && isMsysOrGitBash(env, platform)
+        ? "windows-msys-bootstrap"
+        : "direct-detached";
+}
+export function buildWindowsMsysBackgroundHelperBootstrapScript(helperArgs, cwd) {
+    const helperArgsLiteral = JSON.stringify(helperArgs);
+    const cwdLiteral = JSON.stringify(cwd);
+    return [
+        "const fs = require('fs');",
+        "const { spawn } = require('child_process');",
+        `const child = spawn(process.execPath, ${helperArgsLiteral}, { cwd: ${cwdLiteral}, detached: true, stdio: 'ignore', windowsHide: true, env: process.env });`,
+        "if (!child.pid) process.exit(1);",
+        "child.unref();",
+        "fs.writeSync(1, String(child.pid));",
+        "process.exit(0);",
+    ].join("");
+}
+async function launchBackgroundHelper(helperArgs, options) {
+    const launchMode = resolveBackgroundHelperLaunchMode(options.env, process.platform);
+    if (launchMode === "windows-msys-bootstrap") {
+        const { spawnSync } = await import("child_process");
+        const bootstrap = spawnSync(process.execPath, [
+            "-e",
+            buildWindowsMsysBackgroundHelperBootstrapScript(helperArgs, options.cwd),
+        ], {
+            cwd: options.cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            env: options.env,
+        });
+        if (bootstrap.error && (bootstrap.status ?? 1) !== 0) {
+            throw bootstrap.error;
+        }
+        if (bootstrap.status !== 0) {
+            const detail = (bootstrap.stderr || bootstrap.stdout || "").trim();
+            throw new Error(detail || `background helper bootstrap exited ${bootstrap.status}`);
+        }
+        const helperPid = Number.parseInt((bootstrap.stdout || "").trim(), 10);
+        return Number.isFinite(helperPid) && helperPid > 0
+            ? helperPid
+            : undefined;
+    }
+    const child = spawn(process.execPath, helperArgs, {
+        cwd: options.cwd,
+        detached: shouldDetachBackgroundHelper(options.env, process.platform),
+        stdio: "ignore",
+        windowsHide: true,
+        env: options.env,
+    });
+    child.unref();
+    return child.pid;
+}
+function parseWatcherPidFile(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "number") {
+            return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+        }
+        const pid = typeof parsed === "object" && parsed !== null
+            ? parsed.pid
+            : undefined;
+        return typeof pid === "number" && Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        const pid = Number.parseInt(trimmed, 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+}
+function parseWatcherPidRecord(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "object" && parsed !== null) {
+            const { pid, started_at: startedAtRaw } = parsed;
+            if (typeof pid === "number" && Number.isFinite(pid) && pid > 0) {
+                return {
+                    pid,
+                    startedAt: typeof startedAtRaw === "string" ? startedAtRaw : null,
+                };
+            }
+        }
+    }
+    catch {
+    }
+    const pid = parseWatcherPidFile(trimmed);
+    return pid ? { pid, startedAt: null } : null;
+}
+function isLikelyRcsWatcherProcess(pid, execFileSyncFn = execFileSync, platform = process.platform) {
+    if (platform === "win32") {
+        // ps is unavailable on native Windows; fall back to unconditional reap
+        // to preserve the pre-identity-check behavior on opted-in Windows hosts.
+        return true;
+    }
+    try {
+        const cmd = execFileSyncFn("ps", ["-p", String(pid), "-o", "command="], {
+            encoding: "utf-8",
+            timeout: 2000,
+            windowsHide: true,
+        });
+        return cmd.includes("notify-fallback-watcher") || cmd.includes("hook-derived-watcher");
+    }
+    catch {
+        return false;
+    }
+}
+export async function reapStaleNotifyFallbackWatcher(pidPath, deps = {}) {
+    const exists = deps.exists ?? existsSync;
+    if (!exists(pidPath))
+        return;
+    const { readFile } = await import("fs/promises");
+    const readFileImpl = deps.readFile ?? readFile;
+    const tryKillPidImpl = deps.tryKillPid ?? tryKillPid;
+    const hasErrnoCodeImpl = deps.hasErrnoCode ?? hasErrnoCode;
+    const warn = deps.warn ?? console.warn;
+    const isWatcherProcessImpl = deps.isWatcherProcess ?? isLikelyRcsWatcherProcess;
+    try {
+        const record = parseWatcherPidRecord(await readFileImpl(pidPath, "utf-8"));
+        if (record && isWatcherProcessImpl(record.pid)) {
+            tryKillPidImpl(record.pid, "SIGTERM");
+        }
+    }
+    catch (error) {
+        if (!hasErrnoCodeImpl(error, "ESRCH")) {
+            warn("[rcs] warning: failed to stop stale notify fallback watcher", {
+                path: pidPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+function tryKillPid(pid, signal = "SIGTERM") {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+async function startNotifyFallbackWatcher(cwd, options = {}) {
+    const { mkdir, writeFile } = await import("fs/promises");
+    const pidPath = notifyFallbackPidPath(cwd);
+    await reapStaleNotifyFallbackWatcher(pidPath);
+    if (!shouldEnableNotifyFallbackWatcher(process.env, process.platform))
+        return;
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveNotifyFallbackWatcherScript(pkgRoot);
+    const notifyScript = resolveNotifyHookScript(pkgRoot);
+    if (!existsSync(watcherScript) || !existsSync(notifyScript))
+        return;
+    await mkdir(join(cwd, ".rcs", "state"), { recursive: true }).catch((error) => {
+        console.warn("[rcs] warning: failed to create notify fallback watcher state directory", {
+            cwd,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+    const watcherEnv = buildNotifyFallbackWatcherEnv(process.env, {
+        codexHomeOverride: options.codexHomeOverride,
+        enableAuthority: options.enableAuthority === true,
+        sessionId: options.sessionId,
+    });
+    let watcherPid;
+    try {
+        watcherPid = await launchBackgroundHelper([
+            watcherScript,
+            "--cwd",
+            cwd,
+            "--notify-script",
+            notifyScript,
+            "--pid-file",
+            pidPath,
+            "--parent-pid",
+            String(process.pid),
+            ...(process.env.RCS_NOTIFY_FALLBACK_MAX_LIFETIME_MS
+                ? [
+                    "--max-lifetime-ms",
+                    process.env.RCS_NOTIFY_FALLBACK_MAX_LIFETIME_MS,
+                ]
+                : []),
+        ], {
+            cwd,
+            env: watcherEnv,
+        });
+    }
+    catch (error) {
+        console.warn("[rcs] warning: failed to launch notify fallback watcher", {
+            cwd,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    if (!watcherPid)
+        return;
+    await writeFile(pidPath, JSON.stringify({ pid: watcherPid, started_at: new Date().toISOString() }, null, 2)).catch((error) => {
+        console.warn("[rcs] 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.RCS_HOOK_DERIVED_SIGNALS !== "1")
+        return;
+    const { mkdir, writeFile, readFile } = await import("fs/promises");
+    const pidPath = hookDerivedWatcherPidPath(cwd);
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveHookDerivedWatcherScript(pkgRoot);
+    if (!existsSync(watcherScript))
+        return;
+    if (existsSync(pidPath)) {
+        try {
+            const prev = JSON.parse(await readFile(pidPath, "utf-8"));
+            if (prev && typeof prev.pid === "number") {
+                process.kill(prev.pid, "SIGTERM");
+            }
+        }
+        catch (error) {
+            console.warn("[rcs] warning: failed to stop stale hook-derived watcher", {
+                path: pidPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    await mkdir(join(cwd, ".rcs", "state"), { recursive: true }).catch((error) => {
+        console.warn("[rcs] warning: failed to create hook-derived watcher state directory", {
+            cwd,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+    let watcherPid;
+    try {
+        watcherPid = await launchBackgroundHelper([watcherScript, "--cwd", cwd], {
+            cwd,
+            env: process.env,
+        });
+    }
+    catch (error) {
+        console.warn("[rcs] warning: failed to launch hook-derived watcher", {
+            cwd,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    if (!watcherPid)
+        return;
+    await writeFile(pidPath, JSON.stringify({ pid: watcherPid, started_at: new Date().toISOString() }, null, 2)).catch((error) => {
+        console.warn("[rcs] warning: failed to write hook-derived watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function stopNotifyFallbackWatcher(cwd) {
+    const { readFile, unlink } = await import("fs/promises");
+    const pidPath = notifyFallbackPidPath(cwd);
+    if (!existsSync(pidPath))
+        return;
+    try {
+        const pid = parseWatcherPidFile(await readFile(pidPath, "utf-8"));
+        if (pid) {
+            tryKillPid(pid, "SIGTERM");
+        }
+    }
+    catch (error) {
+        if (!hasErrnoCode(error, "ESRCH")) {
+            console.warn("[rcs] 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("[rcs] warning: failed to remove notify fallback watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function stopHookDerivedWatcher(cwd) {
+    const { readFile, unlink } = await import("fs/promises");
+    const pidPath = hookDerivedWatcherPidPath(cwd);
+    if (!existsSync(pidPath))
+        return;
+    try {
+        const parsed = JSON.parse(await readFile(pidPath, "utf-8"));
+        if (parsed && typeof parsed.pid === "number") {
+            process.kill(parsed.pid, "SIGTERM");
+        }
+    }
+    catch (error) {
+        console.warn("[rcs] 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("[rcs] warning: failed to remove hook-derived watcher pid file", {
+            path: pidPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function flushNotifyFallbackOnce(cwd, options = {}) {
+    if (!shouldEnableNotifyFallbackWatcher(process.env, process.platform))
+        return;
+    const { spawnSync } = await import("child_process");
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveNotifyFallbackWatcherScript(pkgRoot);
+    const notifyScript = resolveNotifyHookScript(pkgRoot);
+    if (!existsSync(watcherScript) || !existsSync(notifyScript))
+        return;
+    spawnSync(process.execPath, [watcherScript, "--once", "--cwd", cwd, "--notify-script", notifyScript], {
+        cwd,
+        stdio: "ignore",
+        timeout: 3000,
+        windowsHide: true,
+        env: buildNotifyFallbackWatcherEnv(process.env, {
+            codexHomeOverride: options.codexHomeOverride,
+            enableAuthority: options.enableAuthority === true,
+            sessionId: options.sessionId,
+        }),
+    });
+}
+async function flushHookDerivedWatcherOnce(cwd) {
+    if (process.env.RCS_HOOK_DERIVED_SIGNALS !== "1")
+        return;
+    const { spawnSync } = await import("child_process");
+    const pkgRoot = getPackageRoot();
+    const watcherScript = resolveHookDerivedWatcherScript(pkgRoot);
+    if (!existsSync(watcherScript))
+        return;
+    spawnSync(process.execPath, [watcherScript, "--once", "--cwd", cwd], {
+        cwd,
+        stdio: "ignore",
+        timeout: 3000,
+        windowsHide: true,
+        env: {
+            ...process.env,
+            RCS_HOOK_DERIVED_SIGNALS: "1",
+        },
+    });
+}
+async function cancelModes() {
+    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");
+            let parsedState;
+            try {
+                parsedState = JSON.parse(content);
+            }
+            catch (err) {
+                logCliOperationFailure(err);
+                continue;
+            }
+            states.set(ref.mode, {
+                path: ref.path,
+                scope: ref.scope,
+                state: parsedState,
+            });
+        }
+        const changed = new Set();
+        const reported = new Set();
+        const cancelMode = (mode, phase = "cancelled", reportIfWasActive = true) => {
+            const entry = states.get(mode);
+            if (!entry)
+                return;
+            const wasActive = entry.state.active === true;
+            const needsChange = entry.state.active !== false ||
+                entry.state.current_phase !== phase ||
+                typeof entry.state.completed_at !== "string" ||
+                String(entry.state.completed_at).trim() === "";
+            if (!needsChange)
+                return;
+            entry.state.active = false;
+            entry.state.current_phase = phase;
+            entry.state.completed_at = nowIso;
+            entry.state.last_turn_at = nowIso;
+            changed.add(mode);
+            if (reportIfWasActive && wasActive)
+                reported.add(mode);
+        };
+        const ralphLinksUltrawork = (state) => state.linked_ultrawork === true || state.linked_mode === "ultrawork";
+        const ralph = states.get("ralph");
+        const hadActiveRalph = !!(ralph && ralph.state.active === true);
+        if (ralph && ralph.state.active === true) {
+            cancelMode("ralph", "cancelled", true);
+            if (ralphLinksUltrawork(ralph.state))
+                cancelMode("ultrawork", "cancelled", true);
+        }
+        if (!hadActiveRalph) {
+            for (const [mode, entry] of states.entries()) {
+                if (entry.state.active === true)
+                    cancelMode(mode, "cancelled", true);
+            }
+        }
+        for (const [mode, entry] of states.entries()) {
+            if (!changed.has(mode))
+                continue;
+            await writeFile(entry.path, JSON.stringify(entry.state, null, 2));
+        }
+        for (const mode of reported) {
+            writeStdoutLine(`Cancelled: ${mode}`);
+        }
+        if (reported.size === 0) {
+            writeStdoutLine("No active modes to cancel.");
+        }
+    }
+    catch (err) {
+        logCliOperationFailure(err);
+        writeStdoutLine("No active modes to cancel.");
+    }
+}
+//# sourceMappingURL=index.js.map