oh-my-codex 0.18.16 → 0.19.0

package/dist/scripts/codex-native-hook.js

@@ -1,16 +1,17 @@
 import { execFileSync } from "child_process";
-import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "fs";
 import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
-import { extname, join, relative, resolve } from "path";
+import { extname, isAbsolute, join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
 import { readModeStateForActiveDecision, readModeStateForSession, updateModeState } from "../modes/base.js";
 import { redactAuthSecrets } from "../auth/redact.js";
 import { SKILL_ACTIVE_STATE_FILE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, readVisibleSkillActiveStateForStateDir, } from "../state/skill-active.js";
 import { isTrustedSubagentThread, readSubagentSessionSummary, readSubagentTrackingState, recordSubagentTurnForSession, } from "../subagents/tracker.js";
 import { resolveCanonicalTeamStateRoot, resolveWorkerNotifyTeamStateRootPath } from "../team/state-root.js";
-import { appendToLog, isSessionStateUsable, readSessionState, readUsableSessionState, reconcileNativeSessionStart, } from "../hooks/session.js";
+import { inferTerminalLifecycleOutcome } from "../runtime/run-outcome.js";
+import { appendToLog, isSessionStale, isSessionStateUsable, readSessionState, readUsableSessionState, reconcileNativeSessionStart, } from "../hooks/session.js";
 import { appendTeamEvent, readTeamLeaderAttention, readTeamConfig, readTeamManifestV2, readTeamPhase, writeTeamLeaderAttention, writeTeamPhase, } from "../team/state.js";
-import { omxNotepadPath, resolveProjectMemoryPath } from "../utils/paths.js";
+import { codexAgentsDir, omxNotepadPath, projectCodexAgentsDir, resolveProjectMemoryPath } from "../utils/paths.js";
 import { findGitLayout } from "../utils/git-layout.js";
 import { getBaseStateDir, getStateFilePath, getStatePath, getAuthoritativeActiveStatePaths } from "../mcp/state-paths.js";
 import { detectKeywords, detectPrimaryKeyword, recordSkillActivation, } from "../hooks/keyword-detector.js";
@@ -22,12 +23,15 @@ import { handleTeamWorkerPostToolUseSuccess } from "./notify-hook/team-worker-po
 import { maybeNudgeLeaderForAllowedWorkerStop } from "./notify-hook/team-worker-stop.js";
 import { resolveCodexExecutionSurface, } from "./codex-execution-surface.js";
 import { buildNativeHookEvent, } from "../hooks/extensibility/events.js";
+import { isTrackedWorkflowMode } from "../state/workflow-transition.js";
 import { dispatchHookEventRuntime } from "../hooks/extensibility/runtime.js";
 import { getNotificationConfig, getVerbosity } from "../notifications/config.js";
 import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
 import { onPreCompact as buildWikiPreCompactContext, onSessionStart as buildWikiSessionStartContext, } from "../wiki/lifecycle.js";
 import { readAutoresearchCompletionStatus, readAutoresearchModeStateForActiveDecision } from "../autoresearch/skill-validation.js";
-import { normalizeAutopilotPhase } from "../autopilot/fsm.js";
+import { AGENT_DEFINITIONS } from "../agents/definitions.js";
+import { deriveAutopilotChildPhase, normalizeAutopilotPhase } from "../autopilot/fsm.js";
+import { CONDUCTOR_ORCHESTRATION_METADATA_PREFIXES, LEADER_CONDUCTOR_BLOCK, LEADER_CONDUCTOR_REUSE_AND_LEDGER_GUIDANCE, actionKindForConductorArtifact, authorizeConductorAction, classifyConductorArtifactKind, } from "../leader/contract.js";
 import { readRunState } from "../runtime/run-state.js";
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { buildCodexGoalTerminalCleanupNotice, } from "../goal-workflows/codex-goal-snapshot.js";
@@ -45,6 +49,7 @@ const TERMINAL_MODE_PHASES = new Set(["complete", "completed", "failed", "cancel
 const SKILL_STOP_BLOCKERS = new Set(["ralplan"]);
 const TEAM_STOP_BLOCKING_TASK_STATUSES = new Set(["pending", "in_progress", "blocked"]);
 const TEAM_WORKER_TERMINAL_RUN_STATES = new Set(["done", "complete", "completed", "failed", "stopped", "cancelled"]);
+const LEADER_CONDUCTOR_GOLDEN_RULE = "Main-root Conductor golden rule: delegate implementation work; do not self-execute source or plan edits.";
 const NATIVE_STOP_STATE_FILE = "native-stop-state.json";
 const NATIVE_SUBAGENT_CAPACITY_BLOCKER_FILE = "native-subagent-capacity-blocker.json";
 const NATIVE_SUBAGENT_CAPACITY_BLOCKER_TTL_MS = 30 * 60_000;
@@ -84,6 +89,9 @@ const RALPH_LIVE_RISK_PATTERNS = [
     /\b(?:database|db|terraform|kubectl|kubernetes|aws|gcp|azure|external|destructive)\b/i,
     /\b(?:telegram|vps|service|restart|send|notify|notification|notifications|cron)\b/i,
 ];
+const KNOWN_TYPED_AGENT_ROLES = new Set(Object.keys(AGENT_DEFINITIONS));
+let installedTypedAgentRoleNamesCacheKey = "";
+let installedTypedAgentRoleNamesCache = new Set();
 const RALPH_TASK_TEXT_FIELDS = [
     "task_description",
     "taskDescription",
@@ -418,6 +426,9 @@ function readHookEventName(payload) {
 function sanitizeCodexHookOutput(hookEventName, output) {
     if (!output || hookEventName !== "PreToolUse")
         return output;
+    const preToolUseDenyOutput = toPreToolUseDenyOutput(output);
+    if (preToolUseDenyOutput)
+        return preToolUseDenyOutput;
     const systemMessage = safeString(output.systemMessage).trim();
     if (systemMessage)
         return { systemMessage };
@@ -429,6 +440,33 @@ function sanitizeCodexHookOutput(hookEventName, output) {
     const derivedSystemMessage = [reason, additionalContext].filter(Boolean).join("\n\n");
     return derivedSystemMessage ? { systemMessage: derivedSystemMessage } : {};
 }
+function toPreToolUseDenyOutput(output) {
+    const sourceHookSpecificOutput = safeObject(output.hookSpecificOutput);
+    const legacyBlock = output.decision === "block";
+    const hookSpecificDeny = sourceHookSpecificOutput.permissionDecision === "deny";
+    if (!legacyBlock && !hookSpecificDeny)
+        return null;
+    const permissionDecisionReason = safeString(sourceHookSpecificOutput.permissionDecisionReason).trim();
+    const legacyReason = safeString(output.reason).trim();
+    const additionalContext = safeString(sourceHookSpecificOutput.additionalContext).trim();
+    const systemMessage = safeString(output.systemMessage).trim();
+    const reason = permissionDecisionReason || legacyReason || systemMessage;
+    if (!reason) {
+        throw new Error("Malformed PreToolUse block output: explicit deny/block requires non-empty permissionDecisionReason, reason, or systemMessage.");
+    }
+    const hookSpecificOutput = {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: reason,
+    };
+    if (additionalContext) {
+        hookSpecificOutput.additionalContext = additionalContext;
+    }
+    return {
+        ...(systemMessage ? { systemMessage } : {}),
+        hookSpecificOutput,
+    };
+}
 export function mapCodexHookEventToOmxEvent(hookEventName) {
     switch (hookEventName) {
         case "SessionStart":
@@ -1201,6 +1239,28 @@ const SOURCE_DIFF_EXTENSIONS = new Set([
     ".ts",
     ".tsx",
 ]);
+const PLANNING_TMP_SCRIPT_LIKE_EXTENSIONS = new Set([
+    ".bash",
+    ".bat",
+    ".cjs",
+    ".cmd",
+    ".cts",
+    ".fish",
+    ".js",
+    ".jsx",
+    ".ksh",
+    ".mjs",
+    ".mts",
+    ".php",
+    ".pl",
+    ".ps1",
+    ".py",
+    ".rb",
+    ".sh",
+    ".ts",
+    ".tsx",
+    ".zsh",
+]);
 function gitOutput(cwd, args) {
     try {
         return execFileSync("git", args, {
@@ -1673,6 +1733,8 @@ function buildAutopilotPromptActivationNote(skillState, options = {}) {
         "The ralplan phase is not complete until Planner output has been reviewed sequentially by Architect and then Critic; do not hand off to Ultragoal or implementation until the ralplan state/artifact records both ralplan_architect_review and ralplan_critic_review with approval or an explicit blocker.",
         "Do not silently fall back to ordinary $plan/ralplan-only handling; keep autopilot-state.json, skill-active-state.json, HUD/statusline, and Codex goal-mode handoff guidance visible while the workflow is active.",
         "When Codex goal tools are available, call get_goal/create_goal only from the active thread handoff and treat the active goal as the completion contract until code-review and ultraqa are clean.",
+        LEADER_CONDUCTOR_BLOCK,
+        LEADER_CONDUCTOR_REUSE_AND_LEDGER_GUIDANCE,
     ].filter(Boolean).join(" ");
 }
 function formatExecutionHandoffList(cwd) {
@@ -1684,6 +1746,9 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
     if (!prompt)
         return null;
     const promptPriorityMessage = buildPromptPriorityMessage(prompt);
+    if (payload && isTypedAgentRolePayload(payload)) {
+        return promptPriorityMessage;
+    }
     const teamMode = readTeamModeConfig(cwd);
     const matches = detectKeywords(prompt).filter((entry) => teamMode.enabled || entry.skill !== "team");
     const match = matches[0] ?? null;
@@ -1845,6 +1910,11 @@ function parseTeamWorkerEnv(rawValue) {
         workerName: match[2] || "",
     };
 }
+function hasTeamWorkerEnvironment() {
+    return parseTeamWorkerEnv(safeString(process.env.OMX_TEAM_INTERNAL_WORKER))
+        !== null
+        || parseTeamWorkerEnv(safeString(process.env.OMX_TEAM_WORKER)) !== null;
+}
 async function resolveTeamStateDirForWorkerContext(cwd, workerContext) {
     const resolved = await resolveWorkerNotifyTeamStateRootPath(cwd, workerContext, process.env).catch(() => null);
     if (resolved)
@@ -2457,6 +2527,47 @@ function readPayloadSessionId(payload) {
 function readPayloadThreadId(payload) {
     return safeString(payload.owner_codex_thread_id ?? payload.thread_id ?? payload.threadId).trim();
 }
+function readPayloadAgentRole(payload) {
+    const directRole = safeString(payload.agent_role
+        ?? payload.agentRole
+        ?? payload.agent_type
+        ?? payload.agentType).trim().toLowerCase();
+    if (directRole)
+        return directRole;
+    const source = safeObject(payload.source);
+    const subagent = safeObject(source?.subagent);
+    const threadSpawn = safeObject(subagent?.thread_spawn);
+    return safeString(threadSpawn?.agent_role
+        ?? threadSpawn?.agentRole
+        ?? threadSpawn?.agent_type
+        ?? threadSpawn?.agentType).trim().toLowerCase();
+}
+function readInstalledTypedAgentRoleNames() {
+    const cacheKey = [codexAgentsDir(), projectCodexAgentsDir()].join("|");
+    if (installedTypedAgentRoleNamesCacheKey === cacheKey)
+        return installedTypedAgentRoleNamesCache;
+    const installedRoleNames = new Set();
+    for (const agentsDir of [codexAgentsDir(), projectCodexAgentsDir()]) {
+        try {
+            for (const entry of readdirSync(agentsDir, { withFileTypes: true })) {
+                if (!entry.isFile() || !entry.name.endsWith(".toml"))
+                    continue;
+                installedRoleNames.add(entry.name.slice(0, -5).trim().toLowerCase());
+            }
+        }
+        catch {
+            // Ignore missing or unreadable agent directories; built-in definitions remain authoritative.
+        }
+    }
+    installedTypedAgentRoleNamesCacheKey = cacheKey;
+    installedTypedAgentRoleNamesCache = installedRoleNames;
+    return installedTypedAgentRoleNamesCache;
+}
+function isTypedAgentRolePayload(payload) {
+    const agentRole = readPayloadAgentRole(payload);
+    return agentRole !== "" && (KNOWN_TYPED_AGENT_ROLES.has(agentRole)
+        || readInstalledTypedAgentRoleNames().has(agentRole));
+}
 function readPayloadTurnId(payload) {
     return safeString(payload.turn_id ?? payload.turnId).trim();
 }
@@ -2598,6 +2709,48 @@ async function resolveInternalSessionIdForPayload(cwd, payloadSessionId, stateDi
         return canonicalSessionId;
     return payloadSessionId;
 }
+async function readRootSessionStateFromStateDir(stateDir) {
+    const sessionPath = join(stateDir, "session.json");
+    if (!existsSync(sessionPath))
+        return null;
+    try {
+        const content = await readFile(sessionPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function payloadMatchesSessionPointer(payloadSessionId, state) {
+    const canonicalSessionId = safeString(state.session_id).trim();
+    const nativeSessionId = safeString(state.native_session_id).trim();
+    const ownerOmxSessionId = safeString(state.owner_omx_session_id).trim();
+    if (!payloadSessionId)
+        return true;
+    return payloadSessionId === canonicalSessionId
+        || (nativeSessionId !== "" && payloadSessionId === nativeSessionId)
+        || (ownerOmxSessionId !== "" && payloadSessionId === ownerOmxSessionId);
+}
+function isRootSessionPointerLive(state) {
+    const hasPidMetadata = Number.isInteger(state.pid) && state.pid > 0;
+    if (!hasPidMetadata)
+        return false;
+    return !isSessionStale(state, {
+        ...(state.platform ? { platform: state.platform } : {}),
+    });
+}
+async function readLiveRootSessionPointerConflict(stateDir, payloadSessionId) {
+    if (!payloadSessionId)
+        return null;
+    const rootState = await readRootSessionStateFromStateDir(stateDir);
+    if (!rootState)
+        return null;
+    if (payloadMatchesSessionPointer(payloadSessionId, rootState))
+        return null;
+    if (!isRootSessionPointerLive(rootState))
+        return null;
+    return rootState;
+}
 async function readUsableSessionStateFromStateDir(cwd, stateDir) {
     const sessionPath = join(stateDir, "session.json");
     if (!existsSync(sessionPath))
@@ -2621,15 +2774,23 @@ const DEEP_INTERVIEW_ALLOWED_WRITE_PREFIXES = [
     ".omx/context",
     ".omx/interviews",
     ".omx/specs",
+    ".omx/tmp",
     ".omx/state",
 ];
 const RALPLAN_ALLOWED_WRITE_PREFIXES = [
     ".omx/context",
     ".omx/plans",
     ".omx/specs",
+    ".omx/tmp",
     ".omx/state",
     ".beads",
 ];
+const PROTECTED_PLANNING_STATE_FILE_NAMES = new Set([
+    "autopilot-state.json",
+    "deep-interview-state.json",
+    "ralplan-state.json",
+    "skill-active-state.json",
+]);
 const PLANNING_MODE_IMPLEMENTATION_TOOL_NAMES = new Set([
     "Write",
     "Edit",
@@ -2684,20 +2845,48 @@ function hasExplicitExecutionHandoffSkill(state, sessionId, threadId) {
     return listActiveSkills(state ?? {}).some((entry) => (RALPLAN_EXECUTION_HANDOFF_SKILLS.has(entry.skill)
         && matchesSkillStopContext(entry, state ?? {}, sessionId, threadId)));
 }
-function isAllowedPlanningArtifactPath(cwd, rawPath, allowedPrefixes) {
+function normalizePlanningArtifactRelativePath(cwd, rawPath) {
     const trimmed = rawPath.trim().replace(/^['"]|['"]$/g, "");
     if (!trimmed || trimmed.includes("\0"))
-        return false;
-    let relativePath;
+        return null;
     try {
         const absolute = resolve(cwd, trimmed);
-        relativePath = relative(cwd, absolute).replace(/\\/g, "/");
+        const relativePath = relative(cwd, absolute).replace(/\\/g, "/");
+        if (!relativePath || relativePath.startsWith("..") || relativePath.startsWith("/"))
+            return null;
+        return relativePath;
     }
     catch {
-        return false;
+        return null;
     }
-    if (!relativePath || relativePath.startsWith("..") || relativePath.startsWith("/"))
+}
+function isProtectedPlanningStatePath(relativePath) {
+    if (relativePath !== ".omx/state" && !relativePath.startsWith(".omx/state/"))
         return false;
+    const fileName = relativePath.split("/").pop() ?? "";
+    return PROTECTED_PLANNING_STATE_FILE_NAMES.has(fileName);
+}
+function isPlanningTmpRelativePath(relativePath) {
+    return relativePath === ".omx/tmp" || relativePath.startsWith(".omx/tmp/");
+}
+function isAllowedPlanningTmpScratchPath(relativePath) {
+    if (!isPlanningTmpRelativePath(relativePath))
+        return true;
+    const fileName = relativePath.split("/").pop() ?? "";
+    if (!fileName || fileName === "tmp")
+        return true;
+    const extension = extname(fileName).toLowerCase();
+    return !PLANNING_TMP_SCRIPT_LIKE_EXTENSIONS.has(extension);
+}
+function isAllowedPlanningArtifactPath(cwd, rawPath, allowedPrefixes) {
+    const relativePath = normalizePlanningArtifactRelativePath(cwd, rawPath);
+    if (!relativePath)
+        return false;
+    if (isProtectedPlanningStatePath(relativePath))
+        return false;
+    if (isPlanningTmpRelativePath(relativePath)) {
+        return allowedPrefixes.includes(".omx/tmp") && isAllowedPlanningTmpScratchPath(relativePath);
+    }
     return allowedPrefixes.some((prefix) => (relativePath === prefix || relativePath.startsWith(`${prefix}/`)));
 }
 function isAllowedDeepInterviewArtifactPath(cwd, rawPath) {
@@ -2914,29 +3103,174 @@ function resolveCommandRedirectTarget(target, assignments) {
 }
 function extractDeepInterviewCommandRedirectTargets(command) {
     const targets = [];
-    for (const match of command.matchAll(/(?:^|[^>])>{1,2}\s*(["']?)([^\s&|;<>]+)\1/g)) {
+    const commandOutsideHeredocBodies = stripHeredocBodiesForCommandScan(command);
+    for (const match of commandOutsideHeredocBodies.matchAll(/(?:^|[^>])>{1,2}\s*(["']?)([^\s&|;<>]+)\1/g)) {
         const candidate = safeString(match[2]).trim();
         if (candidate && !isNullDeviceRedirectTarget(candidate))
             targets.push(candidate);
     }
     return targets;
 }
+function commandHasDestructiveGitSubcommand(command) {
+    const destructiveSubcommands = new Set([
+        "am",
+        "apply",
+        "checkout",
+        "clean",
+        "merge",
+        "rebase",
+        "reset",
+        "restore",
+        "rm",
+        "switch",
+    ]);
+    for (const segment of splitShellCommandSegments(stripHeredocBodiesForCommandScan(command))) {
+        const words = tokenizeShellWords(segment);
+        for (let index = 0; index < words.length; index += 1) {
+            if (shellWordBaseName(words[index] ?? "") !== "git")
+                continue;
+            const subcommandIndex = findGitSubcommandIndex(words, index + 1);
+            if (subcommandIndex === null)
+                continue;
+            const subcommand = words[subcommandIndex] ?? "";
+            if (destructiveSubcommands.has(subcommand))
+                return true;
+            if (subcommand === "worktree") {
+                const worktreeSubcommandIndex = findGitSubcommandIndex(words, subcommandIndex + 1);
+                if (worktreeSubcommandIndex === null)
+                    continue;
+                const worktreeSubcommand = words[worktreeSubcommandIndex] ?? "";
+                if (worktreeSubcommand === "add" || worktreeSubcommand === "move" || worktreeSubcommand === "mv" || worktreeSubcommand === "remove" || worktreeSubcommand === "rm" || worktreeSubcommand === "prune" || worktreeSubcommand === "repair" || worktreeSubcommand === "clean")
+                    return true;
+            }
+            if (subcommand.startsWith("checkout-"))
+                return true;
+            if (subcommand.startsWith("merge-") && subcommand !== "merge-base")
+                return true;
+        }
+    }
+    return false;
+}
+function commandHasPackageInstallIntent(command) {
+    for (const segment of splitShellCommandSegments(stripHeredocBodiesForCommandScan(command))) {
+        const words = tokenizeShellWords(segment);
+        for (let index = 0; index < words.length; index += 1) {
+            const headBase = shellWordBaseName(words[index] ?? "");
+            if (headBase !== "npm" && headBase !== "pnpm" && headBase !== "yarn")
+                continue;
+            const subcommandIndex = findPackageInstallSubcommandIndex(words, index + 1);
+            if (subcommandIndex === null)
+                continue;
+            const subcommand = words[subcommandIndex] ?? "";
+            if (headBase === "npm" && (subcommand === "install" || subcommand === "i" || subcommand === "ci"))
+                return true;
+            if (headBase === "pnpm" && (subcommand === "install" || subcommand === "i" || subcommand === "add"))
+                return true;
+            if (headBase === "yarn" && (subcommand === "install" || subcommand === "add"))
+                return true;
+        }
+    }
+    return false;
+}
+function findPackageInstallSubcommandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--")
+            continue;
+        if (isShellAssignmentWord(word))
+            continue;
+        if (word === "-C" || word === "--prefix" || word === "--dir" || word === "--cwd" || word === "-w" || word === "--workspace") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--prefix=") || word.startsWith("--dir=") || word.startsWith("--cwd=") || word.startsWith("--workspace="))
+            continue;
+        if (/^-C.+/.test(word) || /^-w.+/.test(word))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function commandHasUntargetedPlanningForbiddenIntent(command) {
+    return commandHasDestructiveGitSubcommand(command) || commandHasPackageInstallIntent(command);
+}
+function findGitSubcommandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--")
+            continue;
+        if (isShellAssignmentWord(word))
+            continue;
+        if (word === "-C" || word === "-c" || word === "--git-dir" || word === "--work-tree" || word === "--namespace") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--git-dir=") || word.startsWith("--work-tree=") || word.startsWith("--namespace="))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
 function commandHasDeepInterviewWriteIntent(command) {
     return commandInvokesApplyPatch(command)
         || extractDeepInterviewCommandRedirectTargets(command).length > 0
         || /\btee\s+(?:-a\s+)?[^\s&|;]+/.test(command)
+        || extractConductorEditorWriteTargets(command).length > 0
         || /\bsed\s+(?:[^\n;&|]*\s)?-i(?:\b|['"])/.test(command)
+        || /\bperl\s+(?:[^\n;&|]*\s)?-[^-\s]*i(?:\b|['"])/.test(command)
         || /\b(?:python3?|node|perl|ruby)\b[\s\S]{0,260}\b(?:writeFileSync|writeFile|write_text|open\([^)]*["']w|File\.write|Path\()/.test(command)
-        || /\b(?:git\s+(?:checkout|switch|restore|reset|apply|am|merge|rebase)|npm\s+(?:install|i|ci)|pnpm\s+(?:install|i)|yarn\s+(?:install|add))\b/.test(command);
+        || extractConductorBashMutations(command).length > 0
+        || extractConductorInterpreterWrites(command).length > 0
+        || commandHasDestructiveGitSubcommand(command)
+        || commandHasPackageInstallIntent(command);
 }
 function extractDeepInterviewCommandWriteTargets(command) {
     const assignments = extractCommandLiteralAssignments(command);
     const targets = extractDeepInterviewCommandRedirectTargets(command)
         .map((target) => resolveCommandRedirectTarget(target, assignments));
-    for (const match of command.matchAll(/\btee\s+(?:-a\s+)?(["']?)([^\s&|;<>]+)\1/g)) {
-        const candidate = safeString(match[2]).trim();
-        if (candidate)
-            targets.push(resolveCommandRedirectTarget(candidate, assignments));
+    targets.push(...extractConductorEditorWriteTargets(command));
+    for (const mutation of extractConductorBashMutations(command)) {
+        targets.push(...mutation.targets);
+    }
+    for (const write of extractConductorInterpreterWrites(command)) {
+        targets.push(...write.targets);
+    }
+    for (const segment of splitShellCommandSegments(stripHeredocBodiesForCommandScan(command))) {
+        const words = tokenizeShellWords(segment);
+        for (let index = 0; index < words.length; index += 1) {
+            if (shellWordBaseName(words[index] ?? "") !== "tee")
+                continue;
+            let afterDoubleDash = false;
+            for (let targetIndex = index + 1; targetIndex < words.length; targetIndex += 1) {
+                const word = words[targetIndex] ?? "";
+                if (!word || word === "|" || word === "|&" || word === "&&" || word === "||" || word === ";")
+                    break;
+                if (!afterDoubleDash && word === "--") {
+                    afterDoubleDash = true;
+                    continue;
+                }
+                if (!afterDoubleDash && word.startsWith("-"))
+                    continue;
+                if (word === ">" || word === ">>" || word === ">&" || word === "<" || word === "<<" || word === "<<<") {
+                    targetIndex += 1;
+                    continue;
+                }
+                if (/^(?:>{1,2}|<)\S+/.test(word))
+                    continue;
+                if (!isNullDeviceRedirectTarget(word))
+                    targets.push(resolveCommandRedirectTarget(word, assignments));
+            }
+        }
+    }
+    for (const nestedCommand of extractNestedShellCommandStringsForStateScan(command)) {
+        targets.push(...extractDeepInterviewCommandWriteTargets(nestedCommand));
+    }
+    for (const nestedCommand of extractNestedCommandSubstitutionStringsForStateScan(command)) {
+        targets.push(...extractDeepInterviewCommandWriteTargets(nestedCommand));
     }
     return targets;
 }
@@ -2948,224 +3282,4057 @@ function isUnresolvedVariableTarget(target) {
     const normalized = target.trim().replace(/^['"]|['"]$/g, "");
     return /^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/.test(normalized);
 }
-function describeImplementationToolBlock(toolName, blockedPath, pathCount) {
-    if (pathCount === 0) {
-        const operationClass = isApplyPatchToolName(toolName) ? "apply_patch target extraction failed" : `${toolName} path`;
-        return `${operationClass} target <unresolved>; only planning artifact paths are allowed (${RALPLAN_ALLOWED_WRITE_PREFIXES.join(", ")})`;
-    }
-    const operationClass = isApplyPatchToolName(toolName) ? "apply_patch target" : `${toolName} path`;
-    return formatPlanningWriteBlockDetail(operationClass, blockedPath, RALPLAN_ALLOWED_WRITE_PREFIXES);
-}
-function isAllowedDeepInterviewBashWrite(cwd, command) {
-    if (!commandHasDeepInterviewWriteIntent(command))
-        return true;
-    if (/\bomx\s+(?:state\s+(?:write|read|clear)|question)\b/.test(command))
-        return true;
-    const targets = extractDeepInterviewCommandWriteTargets(command);
-    return targets.length > 0 && targets.every((target) => isAllowedDeepInterviewArtifactPath(cwd, target));
-}
-async function readActiveDeepInterviewStateForPreToolUse(cwd, stateDir, sessionId, threadId) {
-    const canonicalState = sessionId
-        ? await readVisibleSkillActiveStateForStateDir(stateDir, sessionId)
-        : await readSkillActiveState(join(stateDir, SKILL_ACTIVE_STATE_FILE));
-    if (!canonicalState)
+function normalizeSameCommandScriptTarget(cwd, rawPath, assignments) {
+    const trimmed = resolveCommandRedirectTarget(rawPath.trim().replace(/^['"]|['"]$/g, ""), assignments);
+    if (!trimmed || trimmed.includes("\0") || isUnresolvedVariableTarget(trimmed))
         return null;
-    const modeState = sessionId
-        ? await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId, stateDir)
-        : await readJsonIfExists(join(stateDir, "deep-interview-state.json"));
-    if (isActiveDeepInterviewPhase(modeState) && modeState && modeStateMatchesSkillStopContext(modeState, cwd, sessionId)) {
-        const hasActiveDeepInterviewSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "deep-interview"
-            && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
-        if (hasActiveDeepInterviewSkill)
-            return modeState;
+    try {
+        return resolve(cwd, trimmed);
     }
-    const autopilotState = sessionId
-        ? await readStopSessionPinnedState("autopilot-state.json", cwd, sessionId, stateDir)
-        : await readJsonIfExists(join(stateDir, "autopilot-state.json"));
-    if (!autopilotState || autopilotState.active !== true)
-        return null;
-    const autopilotMode = safeString(autopilotState.mode).trim();
-    if (autopilotMode && autopilotMode !== "autopilot")
-        return null;
-    if (!modeStateMatchesSkillStopContext(autopilotState, cwd, sessionId))
-        return null;
-    const terminalAutopilotRunState = await readCanonicalTerminalRunStateForStop(cwd, sessionId, "autopilot");
-    if (terminalAutopilotRunState)
-        return null;
-    const autopilotStatePhase = safeString(autopilotState.current_phase ?? autopilotState.currentPhase).trim().toLowerCase();
-    const autopilotIsDeepInterview = normalizeAutopilotPhase(autopilotStatePhase) === "deep-interview";
-    const hasDeepInterviewScopedAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
-        && normalizeAutopilotPhase(safeString(entry.phase).trim().toLowerCase()) === "deep-interview"
-        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
-    const hasActiveAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
-        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
-    if (!hasActiveAutopilotSkill)
+    catch {
         return null;
-    if (!autopilotIsDeepInterview && !hasDeepInterviewScopedAutopilotSkill)
+    }
+}
+function normalizeCommandDirectoryTarget(rawPath) {
+    const trimmed = rawPath.trim().replace(/^['"]|['"]$/g, "");
+    if (!trimmed
+        || trimmed.includes("\0")
+        || trimmed.startsWith("~")
+        || trimmed.startsWith("-")
+        || isUnresolvedVariableTarget(trimmed)
+        || /[`$]/.test(trimmed)) {
         return null;
-    return autopilotState;
+    }
+    return trimmed;
 }
-async function readActiveRalplanStateForPreToolUse(cwd, stateDir, sessionId, threadId) {
-    const modeState = sessionId
-        ? await readStopSessionPinnedState("ralplan-state.json", cwd, sessionId, stateDir)
-        : await readJsonIfExists(join(stateDir, "ralplan-state.json"));
-    const canonicalState = sessionId
-        ? await readVisibleSkillActiveStateForStateDir(stateDir, sessionId)
-        : await readSkillActiveState(join(stateDir, SKILL_ACTIVE_STATE_FILE));
-    if (isActiveRalplanPhase(modeState) && modeState && modeStateMatchesSkillStopContext(modeState, cwd, sessionId)) {
-        if (hasExplicitExecutionHandoffSkill(canonicalState, sessionId, threadId))
+function resolveSimpleCdCommandCwd(currentCwd, words) {
+    const commandIndex = findWrappedCommandPositionIndex(words, 0);
+    if (commandIndex === null || shellWordBaseName(words[commandIndex] ?? "") !== "cd")
+        return null;
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--")
+            continue;
+        if (word === "-L" || word === "-P" || word === "-e")
+            continue;
+        if (word.startsWith("-"))
             return null;
-        if (!canonicalState)
+        const normalizedTarget = normalizeCommandDirectoryTarget(word);
+        if (normalizedTarget === null)
             return null;
-        const hasActiveRalplanSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "ralplan"
-            && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
-        if (hasActiveRalplanSkill)
-            return modeState;
+        try {
+            return resolve(currentCwd, normalizedTarget);
+        }
+        catch {
+            return null;
+        }
     }
-    const autopilotState = sessionId
-        ? await readStopSessionPinnedState("autopilot-state.json", cwd, sessionId, stateDir)
-        : await readJsonIfExists(join(stateDir, "autopilot-state.json"));
-    if (!autopilotState || autopilotState.active !== true)
-        return null;
-    const autopilotMode = safeString(autopilotState.mode).trim();
-    if (autopilotMode && autopilotMode !== "autopilot")
-        return null;
-    if (!modeStateMatchesSkillStopContext(autopilotState, cwd, sessionId))
-        return null;
-    const terminalAutopilotRunState = await readCanonicalTerminalRunStateForStop(cwd, sessionId, "autopilot");
-    if (terminalAutopilotRunState)
-        return null;
-    if (!canonicalState)
-        return null;
-    const hasActiveAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
-        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
-    if (!hasActiveAutopilotSkill)
-        return null;
-    const autopilotStatePhase = safeString(autopilotState.current_phase ?? autopilotState.currentPhase).trim().toLowerCase();
-    if (isAutopilotReviewReworkPhase(autopilotStatePhase))
-        return null;
-    if (!canAutopilotSkillMirrorSupplyRalplanPhase(autopilotStatePhase))
-        return null;
-    const hasRalplanScopedAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
-        && isAutopilotRalplanLikePhase(safeString(entry.phase).trim().toLowerCase())
-        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
-    if (!isAutopilotRalplanLikePhase(autopilotStatePhase) && !hasRalplanScopedAutopilotSkill)
-        return null;
-    return hasActiveAutopilotSkill ? autopilotState : null;
+    return null;
 }
-function isAllowedRalplanBashWrite(cwd, command) {
-    const beadsCommand = classifyRalplanBeadsMetadataCommand(cwd, command);
-    const targets = extractDeepInterviewCommandWriteTargets(command);
-    const hasAllowedTargets = targets.length > 0
-        && targets.every((target) => isAllowedRalplanArtifactPath(cwd, target));
-    if (beadsCommand.present) {
-        return beadsCommand.allowed && (targets.length === 0 || hasAllowedTargets);
+function isEnvCwdChangingOption(word) {
+    return word === "-C"
+        || word === "--chdir"
+        || word.startsWith("--chdir=")
+        || /^-C.+/.test(word);
+}
+function resolveEnvWrappedCommandCwd(currentCwd, words, envWordIndex, operandIndex) {
+    let effectiveCwd = currentCwd;
+    for (let index = envWordIndex + 1; index < operandIndex; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--" || isShellAssignmentWord(word))
+            continue;
+        if (word === "-S" || word === "--split-string" || word.startsWith("-S") || word.startsWith("--split-string="))
+            return null;
+        if (word === "-u" || word === "--unset" || word === "-a" || word === "--argv0") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--unset=") || word.startsWith("--argv0=") || /^-u.+/.test(word) || /^-a.+/.test(word))
+            continue;
+        if (isEnvCwdChangingOption(word)) {
+            let target = "";
+            if (word === "-C" || word === "--chdir") {
+                target = words[index + 1] ?? "";
+                index += 1;
+            }
+            else if (word.startsWith("--chdir=")) {
+                target = word.slice("--chdir=".length);
+            }
+            else if (word.startsWith("-C") && word.length > 2) {
+                target = word.slice(2);
+            }
+            const normalizedTarget = normalizeCommandDirectoryTarget(target);
+            if (normalizedTarget === null)
+                return null;
+            try {
+                effectiveCwd = resolve(effectiveCwd, normalizedTarget);
+            }
+            catch {
+                return null;
+            }
+        }
     }
-    if (!commandHasDeepInterviewWriteIntent(command))
-        return true;
-    if (/\bomx\s+(?:state\s+(?:write|read|clear)|question)\b/.test(command))
-        return true;
-    return hasAllowedTargets;
+    return effectiveCwd;
 }
-function buildRalplanBashBlockedDetail(cwd, command) {
-    const targets = extractDeepInterviewCommandWriteTargets(command);
-    const blockedTarget = targets.find((target) => !isAllowedRalplanArtifactPath(cwd, target));
-    if (blockedTarget && isUnresolvedVariableTarget(blockedTarget)) {
-        return `unresolved Bash write target ${blockedTarget} is not under allowed planning artifact paths or metadata paths (${RALPLAN_ALLOWED_WRITE_PREFIXES.join(", ")})`;
-    }
-    if (blockedTarget) {
+function resolveWrappedCommandExecutionContext(words, currentCwd, startIndex = 0) {
+    let commandWordIndex = skipShellCommandPositionPrefixWords(words, startIndex);
+    let effectiveCwd = currentCwd;
+    for (let unwrapCount = 0; unwrapCount < 8; unwrapCount += 1) {
+        const commandWord = words[commandWordIndex] ?? "";
+        if (!commandWord)
+            return null;
+        const commandWordBase = shellWordBaseName(commandWord);
+        const operandIndex = commandWordBase === "env"
+            ? findEnvDispatchOperandIndex(words, commandWordIndex + 1)
+            : commandWordBase === "command"
+                ? findCommandDispatchOperandIndex(words, commandWordIndex + 1)
+                : commandWordBase === "exec"
+                    ? findExecDispatchOperandIndex(words, commandWordIndex + 1)
+                    : commandWordBase === "time"
+                        ? findTimeDispatchOperandIndex(words, commandWordIndex + 1)
+                        : commandWordBase === "timeout"
+                            ? findTimeoutDispatchOperandIndex(words, commandWordIndex + 1)
+                            : commandWordBase === "nohup" || commandWordBase === "setsid"
+                                ? findCommandDispatchOperandIndex(words, commandWordIndex + 1)
+                                : commandWordBase === "coproc"
+                                    ? findCoprocDispatchOperandIndex(words, commandWordIndex + 1)
+                                    : commandWordBase === "xargs"
+                                        ? findXargsDispatchOperandIndex(words, commandWordIndex + 1)
+                                        : commandWordBase === "nice"
+                                            ? findNiceDispatchOperandIndex(words, commandWordIndex + 1)
+                                            : commandWordBase === "stdbuf"
+                                                ? findStdbufDispatchOperandIndex(words, commandWordIndex + 1)
+                                                : null;
+        if (operandIndex === null)
+            return { index: commandWordIndex, cwd: effectiveCwd };
+        if (commandWordBase === "env") {
+            const envCwd = resolveEnvWrappedCommandCwd(effectiveCwd, words, commandWordIndex, operandIndex);
+            if (envCwd === null)
+                return null;
+            effectiveCwd = envCwd;
+        }
+        const nextCommandWordIndex = skipShellCommandPositionPrefixWords(words, operandIndex);
+        if (nextCommandWordIndex === commandWordIndex)
+            return { index: commandWordIndex, cwd: effectiveCwd };
+        commandWordIndex = nextCommandWordIndex;
+    }
+    return null;
+}
+function resolveStateWriteInputFileCwd(cwd, commandPrefix) {
+    const words = tokenizeShellWords(stripHeredocBodiesForCommandScan(commandPrefix));
+    let effectiveCwd = cwd;
+    let activeWrapper = null;
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellAssignmentWord(word))
+            continue;
+        const wordBase = shellWordBaseName(word);
+        if (wordBase === "env" || wordBase === "npm" || wordBase === "pnpm" || wordBase === "yarn") {
+            activeWrapper = wordBase;
+            continue;
+        }
+        if (!activeWrapper)
+            continue;
+        const isEnvChdirOption = activeWrapper === "env" && isEnvCwdChangingOption(word);
+        const isPackageManagerCwdOption = activeWrapper !== "env"
+            && (word === "-C"
+                || word === "--prefix"
+                || word === "--dir"
+                || word === "--cwd"
+                || word.startsWith("--prefix=")
+                || word.startsWith("--dir=")
+                || word.startsWith("--cwd=")
+                || /^-C.+/.test(word));
+        if (isEnvChdirOption || isPackageManagerCwdOption) {
+            let target = "";
+            if (word === "-C" || word === "--chdir" || word === "--prefix" || word === "--dir" || word === "--cwd") {
+                target = words[index + 1] ?? "";
+            }
+            else if (word.startsWith("--chdir=")) {
+                target = word.slice("--chdir=".length);
+            }
+            else if (word.startsWith("--prefix=")) {
+                target = word.slice("--prefix=".length);
+            }
+            else if (word.startsWith("--dir=")) {
+                target = word.slice("--dir=".length);
+            }
+            else if (word.startsWith("--cwd=")) {
+                target = word.slice("--cwd=".length);
+            }
+            else if (word.startsWith("-C") && word.length > 2) {
+                target = word.slice(2);
+            }
+            const normalizedTarget = normalizeCommandDirectoryTarget(target);
+            if (normalizedTarget === null)
+                return null;
+            effectiveCwd = resolve(effectiveCwd, normalizedTarget);
+            if (word === "-C" || word === "--chdir" || word === "--prefix" || word === "--dir" || word === "--cwd") {
+                index += 1;
+            }
+        }
+    }
+    return effectiveCwd;
+}
+function findShellFunctionDefinitionAt(command, index) {
+    if (index > 0) {
+        let previous = index - 1;
+        while (previous >= 0 && /\s/.test(command[previous] ?? ""))
+            previous -= 1;
+        if (previous >= 0 && !/[;&|(){}]/.test(command[previous] ?? ""))
+            return null;
+    }
+    let cursor = index;
+    while (/\s/.test(command[cursor] ?? ""))
+        cursor += 1;
+    const candidate = command.slice(cursor);
+    const functionKeywordMatch = candidate.match(/^function\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:\(\s*\))?\s*([\{(])/);
+    if (functionKeywordMatch) {
+        return {
+            name: functionKeywordMatch[1],
+            openBraceIndex: cursor + functionKeywordMatch[0].length - 1,
+            bodyOpenChar: functionKeywordMatch[2] === "(" ? "(" : "{",
+        };
+    }
+    const bareFunctionMatch = candidate.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\(\s*\)\s*([\{(])/);
+    if (bareFunctionMatch) {
+        return {
+            name: bareFunctionMatch[1],
+            openBraceIndex: cursor + bareFunctionMatch[0].length - 1,
+            bodyOpenChar: bareFunctionMatch[2] === "(" ? "(" : "{",
+        };
+    }
+    return null;
+}
+function findShellFunctionBodyEnd(command, openBraceIndex, bodyOpenChar) {
+    let depth = 1;
+    let quote = null;
+    for (let index = openBraceIndex + 1; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote)
+            continue;
+        if (bodyOpenChar === "{" && char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (bodyOpenChar === "{" && char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+        if (bodyOpenChar === "(" && char === "(") {
+            depth += 1;
+            continue;
+        }
+        if (bodyOpenChar === "(" && char === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function isShellFunctionInvokedLater(command, functionName) {
+    for (const segment of splitShellCommandSegments(command)) {
+        const words = tokenizeShellWords(segment);
+        if (isShellFunctionInvokedFromWords(words, 0, functionName))
+            return true;
+    }
+    return false;
+}
+function isShellFunctionInvokedFromWords(words, startIndex, functionName) {
+    const index = skipShellCommandPositionPrefixWords(words, startIndex);
+    const head = words[index] ?? "";
+    if (head === functionName)
+        return true;
+    if (shellWordBaseName(head) === "time") {
+        const timeOperandIndex = findTimeDispatchOperandIndex(words, index + 1);
+        if (timeOperandIndex !== null) {
+            const timeCommandIndex = skipShellCommandPositionPrefixWords(words, timeOperandIndex);
+            if ((words[timeCommandIndex] ?? "") === functionName)
+                return true;
+        }
+    }
+    if (shellWordBaseName(head) === "coproc") {
+        const coprocOperandIndex = findCoprocDispatchOperandIndex(words, index + 1);
+        if (coprocOperandIndex !== null) {
+            return isShellFunctionInvokedFromWords(words, coprocOperandIndex, functionName);
+        }
+    }
+    if (shellWordBaseName(head) === "setsid") {
+        const setsidOperandIndex = findCommandDispatchOperandIndex(words, index + 1);
+        if (setsidOperandIndex !== null) {
+            return isShellFunctionInvokedFromWords(words, setsidOperandIndex, functionName);
+        }
+    }
+    if (shellWordBaseName(head) === "command") {
+        const commandOperandIndex = findCommandDispatchOperandIndex(words, index + 1);
+        if (commandOperandIndex !== null && shellWordBaseName(words[commandOperandIndex] ?? "") === "time") {
+            return isShellFunctionInvokedFromWords(words, commandOperandIndex, functionName);
+        }
+    }
+    return false;
+}
+function firstNonOptionSourceOperand(words, sourceWordIndex) {
+    for (let index = sourceWordIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--")
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return word;
+    }
+    return "";
+}
+function stdinRedirectOperands(words) {
+    const operands = [];
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "<") {
+            const operand = words[index + 1] ?? "";
+            if (operand)
+                operands.push(operand);
+            index += 1;
+            continue;
+        }
+        if (/^\d*<[^<&].+/.test(word)) {
+            operands.push(word.replace(/^\d*</, ""));
+        }
+    }
+    return operands;
+}
+function firstShellScriptOperands(words, shellWordIndex) {
+    const operands = [];
+    for (let index = shellWordIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--")
+            continue;
+        if (isShellCommandStringOption(word))
+            return operands;
+        if (isShellOptionWithSeparateValue(word)) {
+            const value = words[index + 1] ?? "";
+            if (value)
+                operands.push(value);
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--init-file=") || word.startsWith("--rcfile=")) {
+            operands.push(word.slice(word.indexOf("=") + 1));
+            continue;
+        }
+        if (word.startsWith("-"))
+            continue;
+        operands.push(word);
+        return operands;
+    }
+    return operands;
+}
+function firstShellScriptOperand(words, shellWordIndex) {
+    return firstShellScriptOperands(words, shellWordIndex)[0] ?? "";
+}
+function isPythonInterpreterCommandWord(base) {
+    return /^python(?:[0-9]+(?:\.[0-9]+)*)?$/.test(base);
+}
+function isNodeInterpreterCommandWord(base) {
+    return /^(?:node|nodejs)$/.test(base);
+}
+function isPythonRuntimeOptionWithSeparateValue(word) {
+    return word === "-B"
+        || word === "-b"
+        || word === "-d"
+        || word === "-E"
+        || word === "-i"
+        || word === "-I"
+        || word === "-O"
+        || word === "-OO"
+        || word === "-P"
+        || word === "-q"
+        || word === "-R"
+        || word === "-s"
+        || word === "-S"
+        || word === "-u"
+        || word === "-v"
+        || word === "-V"
+        || word === "--check-hash-based-pycs"
+        || word === "-W"
+        || word === "-X";
+}
+function isScriptInterpreterCommandWord(word) {
+    const base = shellWordBaseName(word);
+    return isNestedShellCommandWord(base)
+        || isNodeInterpreterCommandWord(base)
+        || base === "bun"
+        || base === "tsx"
+        || base === "deno"
+        || isPythonInterpreterCommandWord(base)
+        || base === "perl"
+        || base === "ruby"
+        || base === "php"
+        || base === "lua"
+        || base === "go"
+        || base === "npx"
+        || base === "npm"
+        || base === "pnpm"
+        || base === "yarn";
+}
+function isTsxRuntimeOptionWithSeparateValue(word) {
+    return word === "--tsconfig";
+}
+function isTsxRuntimeModeWord(word) {
+    return word === "watch";
+}
+function firstInterpreterScriptOperands(words, interpreterWordIndex) {
+    const base = shellWordBaseName(words[interpreterWordIndex] ?? "");
+    if (isNestedShellCommandWord(base))
+        return firstShellScriptOperands(words, interpreterWordIndex);
+    const operands = [];
+    let sawGoRun = false;
+    let sawPackageRunner = base === "npx";
+    for (let index = interpreterWordIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || word === "--")
+            continue;
+        if (isPythonInterpreterCommandWord(base)) {
+            if (word === "-c" || word === "-m")
+                return operands;
+            if (isPythonRuntimeOptionWithSeparateValue(word)) {
+                index += 1;
+                continue;
+            }
+            if (word.startsWith("-W") || word.startsWith("-X"))
+                continue;
+            if (word.startsWith("-"))
+                continue;
+            operands.push(word);
+            return operands;
+        }
+        if (isNodeInterpreterCommandWord(base) || base === "bun" || base === "tsx") {
+            if (word === "-e" || word === "--eval" || word === "-p" || word === "--print")
+                return operands;
+            if (runtimeOptionConsumesNextWord(word) || (base === "tsx" && isTsxRuntimeOptionWithSeparateValue(word))) {
+                const value = words[index + 1] ?? "";
+                if (value && (word === "-r" || word === "--require" || word === "--import" || word === "--loader" || word === "--experimental-loader")) {
+                    operands.push(value);
+                }
+                index += 1;
+                continue;
+            }
+            if (word.startsWith("--require=") || word.startsWith("--import=") || word.startsWith("--loader=") || word.startsWith("--experimental-loader=")) {
+                operands.push(word.slice(word.indexOf("=") + 1));
+                continue;
+            }
+            if (word.startsWith("--eval=") || word.startsWith("--print="))
+                return operands;
+            if (base === "tsx" && isTsxRuntimeModeWord(word))
+                continue;
+            if (word.startsWith("-"))
+                continue;
+            operands.push(word);
+            return operands;
+        }
+        if (base === "deno") {
+            if (word === "eval" || word === "repl")
+                return operands;
+            if (word === "run")
+                continue;
+            if (word.startsWith("-"))
+                continue;
+            operands.push(word);
+            return operands;
+        }
+        if (base === "go") {
+            if (!sawGoRun) {
+                if (word === "run") {
+                    sawGoRun = true;
+                    continue;
+                }
+                return operands;
+            }
+            if (word.startsWith("-"))
+                continue;
+            operands.push(word);
+            return operands;
+        }
+        if (base === "npm" || base === "pnpm" || base === "yarn" || base === "npx") {
+            if (!sawPackageRunner) {
+                if (word === "exec" || word === "x" || word === "dlx") {
+                    sawPackageRunner = true;
+                    continue;
+                }
+                return operands;
+            }
+            if (word.startsWith("-"))
+                continue;
+            if (word === "tsx" || word === "node" || word === "bun" || word === "deno")
+                continue;
+            operands.push(word);
+            return operands;
+        }
+        if (base === "perl" || base === "ruby" || base === "php" || base === "lua") {
+            if (word === "-e" || word.startsWith("-e"))
+                return operands;
+            if (word.startsWith("-"))
+                continue;
+            operands.push(word);
+            return operands;
+        }
+    }
+    return operands;
+}
+function firstPlanningTmpScriptExecutionTarget(cwd, command) {
+    const scanCommand = (currentCwd, currentCommand, activeCommands) => {
+        const normalizedCommand = stripHeredocBodiesForCommandScan(normalizeShellLineContinuations(currentCommand));
+        const commandKey = `${currentCwd}\0${normalizedCommand.trim()}`;
+        if (!normalizedCommand.trim() || activeCommands.has(commandKey))
+            return null;
+        const assignments = extractCommandLiteralAssignments(normalizedCommand);
+        const nextActiveCommands = new Set(activeCommands);
+        nextActiveCommands.add(commandKey);
+        let effectiveCwd = currentCwd;
+        const normalizeExecutionTarget = (operandCwd, rawPath) => {
+            const absoluteTarget = normalizeSameCommandScriptTarget(operandCwd, rawPath, assignments);
+            if (!absoluteTarget)
+                return null;
+            const relativePath = relative(cwd, absoluteTarget).replace(/\\/g, "/");
+            if (!relativePath || relativePath.startsWith("..") || relativePath.startsWith("/"))
+                return null;
+            return relativePath;
+        };
+        for (const segment of splitShellCommandSegments(normalizedCommand)) {
+            const words = tokenizeShellWords(segment);
+            const cdCwd = resolveSimpleCdCommandCwd(effectiveCwd, words);
+            if (cdCwd !== null) {
+                effectiveCwd = cdCwd;
+                continue;
+            }
+            const wrappedCommandContext = resolveWrappedCommandExecutionContext(words, effectiveCwd);
+            for (let index = 0; index < words.length; index += 1) {
+                const word = words[index] ?? "";
+                const operandCwd = wrappedCommandContext && index >= wrappedCommandContext.index ? wrappedCommandContext.cwd : effectiveCwd;
+                const operands = word === "source" || word === "."
+                    ? [firstNonOptionSourceOperand(words, index)].filter(Boolean)
+                    : isScriptInterpreterCommandWord(word)
+                        ? [...firstInterpreterScriptOperands(words, index), ...stdinRedirectOperands(words)]
+                        : [];
+                for (const operand of operands) {
+                    const relativePath = normalizeExecutionTarget(operandCwd, operand);
+                    if (relativePath && isPlanningTmpRelativePath(relativePath))
+                        return relativePath;
+                }
+            }
+            if (wrappedCommandContext !== null) {
+                const directTarget = words[wrappedCommandContext.index] ?? "";
+                const relativePath = normalizeExecutionTarget(wrappedCommandContext.cwd, directTarget);
+                if (relativePath && isPlanningTmpRelativePath(relativePath))
+                    return relativePath;
+            }
+            for (const nestedCommand of extractNestedShellCommandStringsForStateScan(segment)) {
+                const nestedTarget = scanCommand(effectiveCwd, nestedCommand, nextActiveCommands);
+                if (nestedTarget)
+                    return nestedTarget;
+            }
+            for (const nestedCommand of extractNestedCommandSubstitutionStringsForStateScan(segment)) {
+                const nestedTarget = scanCommand(effectiveCwd, nestedCommand, nextActiveCommands);
+                if (nestedTarget)
+                    return nestedTarget;
+            }
+        }
+        return null;
+    };
+    return scanCommand(cwd, command, new Set());
+}
+function sourcesFileWrittenEarlierInSameCommand(cwd, command) {
+    const scanCommand = (currentCwd, currentCommand, activeCommands, writtenTargets) => {
+        const normalizedCommand = stripHeredocBodiesForCommandScan(normalizeShellLineContinuations(currentCommand));
+        const commandKey = `${currentCwd}\0${normalizedCommand.trim()}`;
+        if (!normalizedCommand.trim() || activeCommands.has(commandKey))
+            return false;
+        const assignments = extractCommandLiteralAssignments(normalizedCommand);
+        const nextActiveCommands = new Set(activeCommands);
+        nextActiveCommands.add(commandKey);
+        for (const write of extractConductorInterpreterWrites(currentCommand)) {
+            for (const target of write.targets) {
+                const normalizedTarget = normalizeSameCommandScriptTarget(currentCwd, target, assignments);
+                if (normalizedTarget)
+                    writtenTargets.add(normalizedTarget);
+            }
+        }
+        let effectiveCwd = currentCwd;
+        for (const segment of splitShellCommandSegments(normalizedCommand)) {
+            const words = tokenizeShellWords(segment);
+            const cdCwd = resolveSimpleCdCommandCwd(effectiveCwd, words);
+            if (cdCwd !== null) {
+                effectiveCwd = cdCwd;
+                continue;
+            }
+            const wrappedCommandContext = resolveWrappedCommandExecutionContext(words, effectiveCwd);
+            for (let index = 0; index < words.length; index += 1) {
+                const word = words[index] ?? "";
+                const operandCwd = wrappedCommandContext && index >= wrappedCommandContext.index ? wrappedCommandContext.cwd : effectiveCwd;
+                const operand = word === "source" || word === "."
+                    ? normalizeSameCommandScriptTarget(operandCwd, firstNonOptionSourceOperand(words, index), assignments)
+                    : isNestedShellCommandWord(word)
+                        ? normalizeSameCommandScriptTarget(operandCwd, firstShellScriptOperand(words, index), assignments)
+                        : null;
+                if (operand && writtenTargets.has(operand))
+                    return true;
+            }
+            const directExecutionTarget = wrappedCommandContext === null
+                ? null
+                : normalizeSameCommandScriptTarget(wrappedCommandContext.cwd, words[wrappedCommandContext.index] ?? "", assignments);
+            if (directExecutionTarget && writtenTargets.has(directExecutionTarget))
+                return true;
+            for (const nestedCommand of extractNestedShellCommandStringsForStateScan(segment)) {
+                if (scanCommand(effectiveCwd, nestedCommand, nextActiveCommands, writtenTargets))
+                    return true;
+            }
+            for (const target of extractDeepInterviewCommandWriteTargets(segment)) {
+                const normalizedTarget = normalizeSameCommandScriptTarget(effectiveCwd, target, assignments);
+                if (normalizedTarget)
+                    writtenTargets.add(normalizedTarget);
+            }
+        }
+        return false;
+    };
+    return scanCommand(cwd, command, new Set(), new Set());
+}
+function describeImplementationToolBlock(toolName, blockedPath, pathCount) {
+    if (pathCount === 0) {
+        const operationClass = isApplyPatchToolName(toolName) ? "apply_patch target extraction failed" : `${toolName} path`;
+        return `${operationClass} target <unresolved>; only planning artifact paths are allowed (${RALPLAN_ALLOWED_WRITE_PREFIXES.join(", ")})`;
+    }
+    const operationClass = isApplyPatchToolName(toolName) ? "apply_patch target" : `${toolName} path`;
+    return formatPlanningWriteBlockDetail(operationClass, blockedPath, RALPLAN_ALLOWED_WRITE_PREFIXES);
+}
+// `omx state` mutations normally route through the gate-enforcing `state_write`
+// backend, so the hook defers to that gate rather than blocking the transport.
+// The backend does NOT gate generic standalone deep-interview/ralplan
+// *deactivation*, and it normalizes non-terminal tracked-workflow writes to
+// `active=true`, so commands that would implicitly activate a tracked workflow
+// while planning is still protected are blocked here. Ralplan terminal closeout
+// is the narrow exception: the backend has a dedicated completeRalplanSession
+// path that coherently terminalizes root and session state when the payload is a
+// complete consensus-approved terminal state.
+function readStateWriteInputPayload(cwd, command, sourceCommand = command) {
+    const stateWriteOperations = collectOmxStateCommandOperations(command, "write");
+    if (stateWriteOperations.length === 0)
+        return null;
+    if (stateWriteOperations.length > 1)
+        return null;
+    const stateWriteOperation = stateWriteOperations[0];
+    if (!stateWriteOperation)
+        return null;
+    const stateWriteArgs = stateWriteOperation.args;
+    const mergeModeFlag = (payload) => {
+        const mode = readStateWriteFlagValue(stateWriteArgs, "--mode");
+        return normalizeStateWriteClassificationPayload(mode ? { ...payload, mode } : payload);
+    };
+    const inlineInput = readStateWriteFlagValue(stateWriteArgs, "--input");
+    const inputFile = readStateWriteFlagValue(stateWriteArgs, "--input-file");
+    if (inlineInput !== undefined && inputFile !== undefined)
+        return null;
+    if (inlineInput !== undefined) {
+        try {
+            const parsed = JSON.parse(inlineInput);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? mergeModeFlag(parsed)
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (inputFile === undefined)
+        return null;
+    if (stateWriteOperation.nested)
+        return null;
+    if (hasPriorExecutableCommand(stateWriteOperation.prefix))
+        return null;
+    const canonicalCommandPrefix = stateWriteOperation.commandPrefix || stateWriteOperation.prefix || "";
+    const rawCommandPrefix = sourceCommand !== command
+        ? (() => {
+            const sourceCommandIndex = sourceCommand.lastIndexOf(command);
+            return sourceCommandIndex >= 0 ? sourceCommand.slice(0, sourceCommandIndex) : "";
+        })()
+        : "";
+    const resolvedInputFileCwd = resolveStateWriteInputFileCwd(cwd, canonicalCommandPrefix || rawCommandPrefix);
+    if (resolvedInputFileCwd === null)
+        return null;
+    try {
+        const raw = readFileSync(resolve(resolvedInputFileCwd, inputFile.trim()), "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? mergeModeFlag(parsed)
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function envCommandHasCwdChangingOption(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token || token === "--")
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        if (isEnvCwdChangingOption(token))
+            return true;
+        if (token === "-S" || token === "--split-string" || token.startsWith("-S") || token.startsWith("--split-string=")) {
+            return false;
+        }
+        if (token === "-u" || token === "--unset" || token === "-a" || token === "--argv0") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--unset=") || token.startsWith("--argv0="))
+            continue;
+        if (/^-u.+/.test(token) || /^-a.+/.test(token))
+            continue;
+        if (token.startsWith("-"))
+            continue;
+        return false;
+    }
+    return false;
+}
+function hasPriorExecutableCommand(commandPrefix) {
+    const words = tokenizeShellWords(stripHeredocBodiesForCommandScan(commandPrefix));
+    let commandStart = true;
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word)
+            continue;
+        if (word === "&&" || word === "||" || word === ";" || word === "&" || word === "|" || word === "|&") {
+            commandStart = true;
+            continue;
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word))
+            continue;
+        if (commandStart)
+            return true;
+        commandStart = false;
+    }
+    return false;
+}
+function tokenizeShellWords(segment) {
+    segment = normalizeShellLineContinuations(segment);
+    const words = [];
+    let current = "";
+    let quote = null;
+    for (let index = 0; index < segment.length; index += 1) {
+        const char = segment[index];
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            current += segment[index] ?? "";
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (!quote && (char === ";" || char === "&")) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            const next = segment[index + 1] ?? "";
+            if (char === "&" && next === "&") {
+                words.push("&&");
+                index += 1;
+            }
+            else {
+                words.push(char);
+            }
+            continue;
+        }
+        if (!quote && /\s/.test(char)) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            continue;
+        }
+        if (!quote && (char === "(" || char === ")" || char === "{" || char === "}")) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            words.push(char);
+            continue;
+        }
+        if (!quote && char === "|") {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            const next = segment[index + 1] ?? "";
+            if (next === "&" || next === "|") {
+                words.push(`${char}${next}`);
+                index += 1;
+            }
+            else {
+                words.push(char);
+            }
+            continue;
+        }
+        if (!quote && (char === "<" || char === ">")) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            const next = segment[index + 1] ?? "";
+            if (next === char) {
+                const third = segment[index + 2] ?? "";
+                if (char === "<" && third === "<") {
+                    words.push("<<<");
+                    index += 2;
+                }
+                else {
+                    words.push(`${char}${next}`);
+                    index += 1;
+                }
+            }
+            else if (char === ">" && next === "&") {
+                words.push(">&");
+                index += 1;
+            }
+            else {
+                words.push(char);
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        words.push(current);
+    return words;
+}
+function isOmxCliEntryPath(token, runtimeWrapper) {
+    const trimmed = token.trim().replace(/^['"]|['"]$/g, "");
+    if (!trimmed || trimmed.includes("\0"))
+        return false;
+    const normalized = trimmed.replace(/\\/g, "/");
+    const entryBasename = normalized.split("/").filter(Boolean).pop() ?? "";
+    if (entryBasename === "omx" || entryBasename === "omx.js")
+        return true;
+    if (normalized.endsWith("/node_modules/.bin/omx") || normalized === "node_modules/.bin/omx")
+        return true;
+    if (normalized.endsWith("/dist/cli/omx.js") || normalized === "dist/cli/omx.js")
+        return true;
+    if (runtimeWrapper === "tsx" && (normalized.endsWith("/src/cli/omx.ts") || normalized === "src/cli/omx.ts"))
+        return true;
+    if (runtimeWrapper === "tsx" && (normalized.endsWith("/dist/cli/omx.js") || normalized === "dist/cli/omx.js"))
+        return true;
+    return false;
+}
+function extractEnvSplitStringCommand(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token)
+            continue;
+        if (token === "-S" || token === "--split-string") {
+            const operand = words[index + 1] ?? "";
+            if (!operand)
+                return "";
+            const tail = words.slice(index + 2).join(" ");
+            return tail ? `env ${operand} ${tail}` : `env ${operand}`;
+        }
+        if (token.startsWith("--split-string=") || (token.startsWith("-S") && token.length > 2)) {
+            const operand = token.startsWith("--split-string=")
+                ? token.slice("--split-string=".length)
+                : token.slice(2);
+            if (!operand)
+                return "";
+            const tail = words.slice(index + 1).join(" ");
+            return tail ? `env ${operand} ${tail}` : `env ${operand}`;
+        }
+        if (isShellAssignmentWord(token))
+            continue;
+        if (token === "-u" || token === "--unset" || token === "-C" || token === "--chdir" || token === "-a" || token === "--argv0") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--unset=") || token.startsWith("--chdir=") || token.startsWith("--argv0="))
+            continue;
+        if (/^-u.+/.test(token) || /^-C.+/.test(token) || /^-a.+/.test(token))
+            continue;
+        if (token.startsWith("-"))
+            continue;
+        break;
+    }
+    return "";
+}
+function extractPackageManagerExecCommand(command, words, startIndex, headBase) {
+    let index = startIndex;
+    if (headBase === "npm" || headBase === "pnpm" || headBase === "yarn") {
+        const subcommandIndex = findPackageManagerExecSubcommandIndex(words, startIndex, headBase);
+        if (subcommandIndex === null)
+            return "";
+        index = subcommandIndex + 1;
+    }
+    else if (headBase !== "npx" && headBase !== "pnpx") {
+        return "";
+    }
+    for (; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token)
+            continue;
+        if (token === "--") {
+            const tail = sliceShellWordsTailPreservingQuoting(command, index + 1);
+            return tail || "";
+        }
+        if (isShellAssignmentWord(token))
+            continue;
+        if (token === "-c" || token === "--call") {
+            return words[index + 1] ?? "";
+        }
+        if (token.startsWith("-c") && token.length > 2)
+            return token.slice(2);
+        if (token.startsWith("--call="))
+            return token.slice("--call=".length);
+        if (token === "--package" || token === "-w" || token === "--workspace" || token === "--allow-scripts") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--package=") || token.startsWith("--workspace=") || token.startsWith("--allow-scripts="))
+            continue;
+        if (token.startsWith("-w") && token.length > 2)
+            continue;
+        if (token.startsWith("-"))
+            continue;
+        const tail = sliceShellWordsTailPreservingQuoting(command, index);
+        return tail || "";
+    }
+    return "";
+}
+function findPackageManagerExecSubcommandIndex(words, startIndex, headBase) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token)
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        if (token === "-C" || token === "--prefix" || token === "--dir" || token === "-w" || token === "--workspace" || token === "--package" || token === "--allow-scripts") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--prefix=") || token.startsWith("--dir=") || token.startsWith("--workspace=") || token.startsWith("--package=") || token.startsWith("--allow-scripts="))
+            continue;
+        if (/^-C.+/.test(token) || /^-w.+/.test(token))
+            continue;
+        if (token.startsWith("-"))
+            continue;
+        if (token === "exec" || (headBase === "npm" && token === "x") || ((headBase === "pnpm" || headBase === "yarn") && token === "dlx")) {
+            return index;
+        }
+        return null;
+    }
+    return null;
+}
+function unwrapOmxStateTransportCommandOnce(command) {
+    const words = tokenizeShellWords(normalizeShellLineContinuations(command).trim());
+    if (words.length === 0)
+        return null;
+    let index = 0;
+    while (index < words.length && isShellAssignmentWord(words[index] ?? ""))
+        index += 1;
+    if (index >= words.length)
+        return null;
+    const head = words[index] ?? "";
+    if (!head)
+        return null;
+    const headBase = shellWordBaseName(head);
+    if (headBase === "command" || headBase === "builtin" || headBase === "exec" || headBase === "nohup" || headBase === "setsid") {
+        let remainderIndex = index + 1;
+        while (remainderIndex < words.length) {
+            const token = words[remainderIndex] ?? "";
+            if (!token) {
+                remainderIndex += 1;
+                continue;
+            }
+            if (token === "--") {
+                remainderIndex += 1;
+                continue;
+            }
+            if (head === "exec" && token === "-a") {
+                remainderIndex += 2;
+                continue;
+            }
+            if (token.startsWith("-")) {
+                remainderIndex += 1;
+                continue;
+            }
+            break;
+        }
+        const remainder = sliceShellWordsTailPreservingQuoting(command, remainderIndex);
+        return remainder || null;
+    }
+    if (headBase === "env") {
+        if (envCommandHasCwdChangingOption(words, index + 1)) {
+            return null;
+        }
+        const splitOperand = extractEnvSplitStringCommand(words, index + 1);
+        if (splitOperand) {
+            return splitOperand;
+        }
+        const envCommandIndex = findEnvDispatchOperandIndex(words, index + 1);
+        if (envCommandIndex !== null) {
+            const remainder = sliceShellWordsTailPreservingQuoting(command, envCommandIndex);
+            return remainder || null;
+        }
+        const remainder = sliceShellWordsTailPreservingQuoting(command, index + 1);
+        return remainder || null;
+    }
+    if (headBase === "time") {
+        const operandIndex = findTimeDispatchOperandIndex(words, index + 1);
+        if (operandIndex !== null) {
+            const remainder = sliceShellWordsTailPreservingQuoting(command, operandIndex);
+            return remainder || null;
+        }
+        return null;
+    }
+    if (headBase === "nice") {
+        const operandIndex = findNiceDispatchOperandIndex(words, index + 1);
+        if (operandIndex !== null) {
+            const remainder = sliceShellWordsTailPreservingQuoting(command, operandIndex);
+            return remainder || null;
+        }
+        return null;
+    }
+    if (headBase === "stdbuf") {
+        const operandIndex = findStdbufDispatchOperandIndex(words, index + 1);
+        if (operandIndex !== null) {
+            const remainder = sliceShellWordsTailPreservingQuoting(command, operandIndex);
+            return remainder || null;
+        }
+        return null;
+    }
+    if (headBase === "npm" || headBase === "pnpm" || headBase === "yarn" || headBase === "npx" || headBase === "pnpx") {
+        const packageManagerCommand = extractPackageManagerExecCommand(command, words, index + 1, headBase);
+        if (packageManagerCommand) {
+            return packageManagerCommand;
+        }
+    }
+    if (isNestedShellCommandWord(headBase)) {
+        const commandStringIndex = findShellCommandStringArgIndex(words, index + 1);
+        if (commandStringIndex !== null) {
+            const nestedCommand = words[commandStringIndex] ?? "";
+            if (nestedCommand && !isDynamicNestedCommandString(nestedCommand)) {
+                const remainder = sliceShellWordsTailPreservingQuoting(command, commandStringIndex + 1);
+                return remainder ? `${nestedCommand} ${remainder}` : nestedCommand;
+            }
+        }
+    }
+    if (headBase === "eval") {
+        const nestedCommand = words.slice(index + 1).join(" ");
+        if (nestedCommand && !isDynamicNestedCommandString(nestedCommand))
+            return nestedCommand;
+    }
+    if (headBase === "node" || headBase === "bun" || headBase === "tsx") {
+        const entryIndex = (() => {
+            for (let candidateIndex = index + 1; candidateIndex < words.length; candidateIndex += 1) {
+                const candidate = words[candidateIndex] ?? "";
+                if (!candidate)
+                    continue;
+                if (candidate.startsWith("-"))
+                    continue;
+                return candidateIndex;
+            }
+            return -1;
+        })();
+        if (entryIndex >= 0) {
+            const entryPath = words[entryIndex] ?? "";
+            if (entryPath && isOmxCliEntryPath(entryPath, headBase)) {
+                const remainder = sliceShellWordsTailPreservingQuoting(command, entryIndex + 1);
+                return remainder ? `omx ${remainder}` : "omx";
+            }
+        }
+        return null;
+    }
+    if (isOmxCliEntryPath(head, null)) {
+        const remainder = sliceShellWordsTailPreservingQuoting(command, index + 1);
+        return remainder ? `omx ${remainder}` : "omx";
+    }
+    return null;
+}
+function canonicalizeOmxStateTransportCommand(command) {
+    let current = normalizeShellLineContinuations(command).trim();
+    for (let passes = 0; passes < 8; passes += 1) {
+        const next = unwrapOmxStateTransportCommandOnce(current);
+        if (!next || next === current)
+            return current;
+        current = next.trim();
+    }
+    return current;
+}
+function sliceShellWordsTailPreservingQuoting(command, startWordIndex) {
+    const normalized = normalizeShellLineContinuations(command);
+    let quote = null;
+    let wordIndex = 0;
+    let currentWordStart = null;
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index] ?? "";
+        if (char === "\\" && quote !== "'") {
+            if (currentWordStart === null)
+                currentWordStart = index;
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+                if (currentWordStart === null)
+                    currentWordStart = index;
+            }
+            else if (currentWordStart === null) {
+                currentWordStart = index;
+            }
+            continue;
+        }
+        if (!quote && /\s/.test(char)) {
+            if (currentWordStart !== null) {
+                if (wordIndex === startWordIndex)
+                    return normalized.slice(currentWordStart);
+                wordIndex += 1;
+                currentWordStart = null;
+            }
+            continue;
+        }
+        if (currentWordStart === null)
+            currentWordStart = index;
+    }
+    if (currentWordStart !== null && wordIndex === startWordIndex) {
+        return normalized.slice(currentWordStart);
+    }
+    return null;
+}
+function normalizeShellLineContinuations(command) {
+    let normalized = "";
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            normalized += char;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            const next = command[index + 1] ?? "";
+            if (next === "\r" && command[index + 2] === "\n") {
+                index += 2;
+                continue;
+            }
+            if (next === "\n") {
+                index += 1;
+                continue;
+            }
+        }
+        normalized += char;
+    }
+    return normalized;
+}
+function readStateWriteFlagValue(args, flagName) {
+    let value;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === flagName) {
+            value = args[index + 1];
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith(`${flagName}=`))
+            value = arg.slice(flagName.length + 1);
+    }
+    return value;
+}
+function shellWordBaseName(word) {
+    return word.replace(/\\/g, "/").split("/").pop() ?? word;
+}
+function isOmxCliWrapperRuntime(word) {
+    const base = shellWordBaseName(word);
+    return base === "node" || base === "bun" || base === "tsx";
+}
+function isOmxCliWrapperScript(word) {
+    const base = shellWordBaseName(word);
+    return base === "omx" || base === "omx.js";
+}
+function runtimeOptionConsumesNextWord(option) {
+    return option === "-r"
+        || option === "--require"
+        || option === "--import"
+        || option === "--loader"
+        || option === "--experimental-loader"
+        || option === "--env-file"
+        || option === "--conditions"
+        || option === "--title"
+        || option === "-C";
+}
+function runtimeOptionIsInlineCode(option) {
+    return option === "-e"
+        || option === "--eval"
+        || option.startsWith("--eval=")
+        || option === "-p"
+        || option === "--print"
+        || option.startsWith("--print=");
+}
+function findOmxCliWrapperRuntimeScriptIndex(words) {
+    if (!isOmxCliWrapperRuntime(words[0] ?? ""))
+        return null;
+    for (let index = 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word)
+            continue;
+        if (word === "--")
+            continue;
+        if (runtimeOptionIsInlineCode(word))
+            return null;
+        if (runtimeOptionConsumesNextWord(word)) {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-r") && word.length > 2)
+            continue;
+        if (word.startsWith("--") && word.includes("="))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return isOmxCliWrapperScript(word) ? index : null;
+    }
+    return null;
+}
+function readOmxStateCommandArgsFromWords(words, operation) {
+    if (isOmxCliWrapperScript(words[0] ?? "") && words[1] === "state" && words[2] === operation) {
+        return words.slice(3);
+    }
+    const runtimeScriptIndex = findOmxCliWrapperRuntimeScriptIndex(words);
+    if (runtimeScriptIndex !== null && words[runtimeScriptIndex + 1] === "state" && words[runtimeScriptIndex + 2] === operation) {
+        return words.slice(runtimeScriptIndex + 3);
+    }
+    return null;
+}
+// Shell compound-command introducers can occupy command position after wrappers
+// such as `time`/`command`; skip them before matching the protected `omx state`
+// operation so wrapper-unwrapping keeps scanning the actual command body.
+function isShellCommandPositionPrefixWord(word) {
+    return word === "("
+        || word === "{"
+        || word === "!"
+        || word === "if"
+        || word === "then"
+        || word === "else"
+        || word === "elif"
+        || word === "do"
+        || word === "while"
+        || word === "until";
+}
+function findEnvDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (!option || option === "--")
+            continue;
+        if (isShellAssignmentWord(option))
+            continue;
+        if (option === "-S" || option === "--split-string" || option.startsWith("-S") || option.startsWith("--split-string=")) {
+            return null;
+        }
+        if (option === "-u" || option === "--unset" || option === "-C" || option === "--chdir" || option === "-a" || option === "--argv0") {
+            index += 1;
+            continue;
+        }
+        if (option.startsWith("--unset=") || option.startsWith("--chdir=") || option.startsWith("--argv0="))
+            continue;
+        if (/^-u.+/.test(option) || /^-C.+/.test(option) || /^-a.+/.test(option))
+            continue;
+        if (option.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findCommandDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (!option || option === "--")
+            continue;
+        if (isShellAssignmentWord(option))
+            continue;
+        if (option.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findExecDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (!option || option === "--")
+            continue;
+        if (isShellAssignmentWord(option))
+            continue;
+        if (option === "-a") {
+            index += 1;
+            continue;
+        }
+        if (option.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findTimeDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (!option || option === "--")
+            continue;
+        if (isShellAssignmentWord(option))
+            continue;
+        if (option === "-f" || option === "--format" || option === "-o" || option === "--output") {
+            index += 1;
+            continue;
+        }
+        if (option.startsWith("--format=") || option.startsWith("--output="))
+            continue;
+        if (/^-[^-]/.test(option)) {
+            const shortOptions = option.slice(1);
+            const lastValueOptionIndex = Math.max(shortOptions.lastIndexOf("f"), shortOptions.lastIndexOf("o"));
+            if (lastValueOptionIndex >= 0 && lastValueOptionIndex === shortOptions.length - 1) {
+                index += 1;
+            }
+            continue;
+        }
+        if (option.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findTimeoutDispatchOperandIndex(words, startIndex) {
+    let durationSeen = false;
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token || token === "--")
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        if (!durationSeen) {
+            if (token === "-k"
+                || token === "--kill-after"
+                || token === "-s"
+                || token === "--signal"
+                || token.startsWith("--kill-after=")
+                || token.startsWith("--signal=")
+                || token.startsWith("-k")
+                || token.startsWith("-s")) {
+                if (token === "-k"
+                    || token === "--kill-after"
+                    || token === "-s"
+                    || token === "--signal") {
+                    index += 1;
+                }
+                continue;
+            }
+            if (token === "-f"
+                || token === "--foreground"
+                || token === "-p"
+                || token === "--preserve-status"
+                || token === "-v"
+                || token === "--verbose") {
+                continue;
+            }
+            if (token.startsWith("-"))
+                continue;
+            durationSeen = true;
+            continue;
+        }
+        return index;
+    }
+    return null;
+}
+function findNiceDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token || token === "--")
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        if (token === "-n" || token === "--adjustment") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--adjustment=") || /^-n.+/.test(token))
+            continue;
+        if (token.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findStdbufDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token || token === "--")
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        if (token === "-i" || token === "-o" || token === "-e" || token === "--input" || token === "--output" || token === "--error") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--input=")
+            || token.startsWith("--output=")
+            || token.startsWith("--error=")
+            || /^-[ioe].+/.test(token)) {
+            continue;
+        }
+        if (token.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function isXargsOptionWithNextValue(option) {
+    return option === "-a"
+        || option === "--arg-file"
+        || option === "-d"
+        || option === "--delimiter"
+        || option === "-E"
+        || option === "--eof"
+        || option === "-I"
+        || option === "--replace"
+        || option === "-J"
+        || option === "-L"
+        || option === "--max-lines"
+        || option === "-n"
+        || option === "--max-args"
+        || option === "-P"
+        || option === "--max-procs"
+        || option === "-s"
+        || option === "--max-chars";
+}
+function isXargsStandaloneOption(option) {
+    return option === "-0"
+        || option === "--null"
+        || option === "-r"
+        || option === "--no-run-if-empty"
+        || option === "-t"
+        || option === "--verbose"
+        || option === "-p"
+        || option === "--interactive"
+        || option === "-x"
+        || option === "--exit"
+        || option === "-o"
+        || option === "--open-tty"
+        || option === "--show-limits";
+}
+function findXargsDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (!option || option === "--")
+            continue;
+        if (isShellAssignmentWord(option))
+            continue;
+        if (isXargsOptionWithNextValue(option)) {
+            index += 1;
+            continue;
+        }
+        if (option.startsWith("--arg-file=")
+            || option.startsWith("--delimiter=")
+            || option.startsWith("--eof=")
+            || option.startsWith("--replace=")
+            || option.startsWith("--max-lines=")
+            || option.startsWith("--max-args=")
+            || option.startsWith("--max-procs=")
+            || option.startsWith("--max-chars=")
+            || /^-[aAdDEIJLnPs][^-\s]*$/.test(option)) {
+            continue;
+        }
+        if (isXargsStandaloneOption(option))
+            continue;
+        if (option.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findCoprocDispatchOperandIndex(words, startIndex) {
+    const firstIndex = findDispatchWordIndex(words, startIndex);
+    if (firstIndex === null)
+        return null;
+    const firstWord = words[firstIndex] ?? "";
+    if (isShellCommandPositionPrefixWord(firstWord))
+        return firstIndex;
+    const secondIndex = findDispatchWordIndex(words, firstIndex + 1);
+    if (secondIndex !== null && isShellCommandPositionPrefixWord(words[secondIndex] ?? "")) {
+        return secondIndex;
+    }
+    return firstIndex;
+}
+function findCaseArmCommandIndex(words, startIndex) {
+    let index = startIndex;
+    while (index < words.length && isShellAssignmentWord(words[index] ?? ""))
+        index += 1;
+    const head = words[index] ?? "";
+    if (!head)
+        return null;
+    if (head === "case") {
+        let inIndex = -1;
+        for (let scanIndex = index + 1; scanIndex < words.length; scanIndex += 1) {
+            const token = words[scanIndex] ?? "";
+            if (!token)
+                continue;
+            if (token === "in") {
+                inIndex = scanIndex;
+                break;
+            }
+            if (token === "esac")
+                return null;
+        }
+        if (inIndex < 0)
+            return null;
+        for (let scanIndex = inIndex + 1; scanIndex < words.length; scanIndex += 1) {
+            const token = words[scanIndex] ?? "";
+            if (!token)
+                continue;
+            if (token === "esac")
+                return null;
+            if (token === ")" || token.endsWith(")"))
+                return scanIndex + 1;
+        }
+        return null;
+    }
+    if (head === ")" || head.endsWith(")")) {
+        return index + 1;
+    }
+    if (words[index + 1] === ")") {
+        return index + 2;
+    }
+    return null;
+}
+function isShellRedirectionWord(word) {
+    return word === ">"
+        || word === ">>"
+        || word === "<"
+        || word === "<<"
+        || word === "<<<"
+        || word === ">&"
+        || word === "<&";
+}
+function skipShellCommandPositionPrefixWords(words, startIndex) {
+    let commandWordIndex = startIndex;
+    while (isShellAssignmentWord(words[commandWordIndex] ?? "")
+        || isShellCommandPositionPrefixWord(words[commandWordIndex] ?? "")) {
+        commandWordIndex += 1;
+    }
+    while (commandWordIndex < words.length) {
+        const word = words[commandWordIndex] ?? "";
+        const nextWord = words[commandWordIndex + 1] ?? "";
+        if (isShellRedirectionWord(word)) {
+            commandWordIndex += 2;
+            continue;
+        }
+        if (/^\d+$/.test(word) && isShellRedirectionWord(nextWord)) {
+            commandWordIndex += 3;
+            continue;
+        }
+        break;
+    }
+    return commandWordIndex;
+}
+function findWrappedCommandPositionIndex(words, startIndex) {
+    let commandWordIndex = skipShellCommandPositionPrefixWords(words, startIndex);
+    for (let unwrapCount = 0; unwrapCount < 8; unwrapCount += 1) {
+        const commandWord = words[commandWordIndex] ?? "";
+        if (!commandWord)
+            return null;
+        const commandWordBase = shellWordBaseName(commandWord);
+        const operandIndex = commandWordBase === "env"
+            ? findEnvDispatchOperandIndex(words, commandWordIndex + 1)
+            : commandWordBase === "command" || commandWordBase === "builtin"
+                ? findCommandDispatchOperandIndex(words, commandWordIndex + 1)
+                : commandWordBase === "exec"
+                    ? findExecDispatchOperandIndex(words, commandWordIndex + 1)
+                    : commandWordBase === "time"
+                        ? findTimeDispatchOperandIndex(words, commandWordIndex + 1)
+                        : commandWordBase === "timeout"
+                            ? findTimeoutDispatchOperandIndex(words, commandWordIndex + 1)
+                            : commandWordBase === "nohup" || commandWordBase === "setsid"
+                                ? findCommandDispatchOperandIndex(words, commandWordIndex + 1)
+                                : commandWordBase === "coproc"
+                                    ? findCoprocDispatchOperandIndex(words, commandWordIndex + 1)
+                                    : commandWordBase === "xargs"
+                                        ? findXargsDispatchOperandIndex(words, commandWordIndex + 1)
+                                        : commandWordBase === "nice"
+                                            ? findNiceDispatchOperandIndex(words, commandWordIndex + 1)
+                                            : commandWordBase === "stdbuf"
+                                                ? findStdbufDispatchOperandIndex(words, commandWordIndex + 1)
+                                                : null;
+        if (operandIndex === null)
+            return commandWordIndex;
+        const nextCommandWordIndex = skipShellCommandPositionPrefixWords(words, operandIndex);
+        if (nextCommandWordIndex === commandWordIndex)
+            return commandWordIndex;
+        commandWordIndex = nextCommandWordIndex;
+    }
+    return null;
+}
+function readOmxStateCommandFromSegmentWords(words, operation) {
+    let commandWordIndex = skipShellCommandPositionPrefixWords(words, 0);
+    for (let unwrapCount = 0; unwrapCount < 8; unwrapCount += 1) {
+        commandWordIndex = skipShellCommandPositionPrefixWords(words, commandWordIndex);
+        const caseArmCommandIndex = findCaseArmCommandIndex(words, commandWordIndex);
+        if (caseArmCommandIndex !== null) {
+            commandWordIndex = skipShellCommandPositionPrefixWords(words, caseArmCommandIndex);
+        }
+        const directArgs = readOmxStateCommandArgsFromWords(words.slice(commandWordIndex), operation);
+        if (directArgs) {
+            return {
+                args: directArgs,
+                commandWords: words.slice(commandWordIndex),
+                prefixWords: words.slice(0, commandWordIndex),
+            };
+        }
+        const commandWord = words[commandWordIndex] ?? "";
+        const operandIndex = shellWordBaseName(commandWord) === "env"
+            ? findEnvDispatchOperandIndex(words, commandWordIndex + 1)
+            : shellWordBaseName(commandWord) === "command"
+                ? findCommandDispatchOperandIndex(words, commandWordIndex + 1)
+                : shellWordBaseName(commandWord) === "exec"
+                    ? findExecDispatchOperandIndex(words, commandWordIndex + 1)
+                    : shellWordBaseName(commandWord) === "nohup"
+                        ? findCommandDispatchOperandIndex(words, commandWordIndex + 1)
+                        : shellWordBaseName(commandWord) === "timeout"
+                            ? findTimeoutDispatchOperandIndex(words, commandWordIndex + 1)
+                            : shellWordBaseName(commandWord) === "coproc"
+                                ? findCoprocDispatchOperandIndex(words, commandWordIndex + 1)
+                                : shellWordBaseName(commandWord) === "xargs"
+                                    ? findXargsDispatchOperandIndex(words, commandWordIndex + 1)
+                                    : shellWordBaseName(commandWord) === "time"
+                                        ? findTimeDispatchOperandIndex(words, commandWordIndex + 1)
+                                        : null;
+        if (operandIndex === null)
+            return null;
+        commandWordIndex = operandIndex;
+    }
+    return null;
+}
+function splitStateScanSegments(command) {
+    const segments = [];
+    let current = "";
+    let segmentStart = 0;
+    let quote = null;
+    const pushSegment = (endIndex) => {
+        if (current.trim()) {
+            segments.push({
+                segment: current,
+                prefix: command.slice(0, segmentStart),
+            });
+        }
+        current = "";
+        segmentStart = endIndex;
+    };
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            current += char;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            current += char;
+            index += 1;
+            current += command[index] ?? "";
+            continue;
+        }
+        if (quote) {
+            current += char;
+            continue;
+        }
+        if (char === ";" || char === "\n" || char === "\r") {
+            pushSegment(index + 1);
+            continue;
+        }
+        if (char === "&" && command[index + 1] === "&") {
+            pushSegment(index + 2);
+            index += 1;
+            continue;
+        }
+        if (char === "&") {
+            const previous = command[index - 1] ?? "";
+            const next = command[index + 1] ?? "";
+            if (previous === ">" || previous === "<" || next === ">") {
+                current += char;
+            }
+            else {
+                pushSegment(index + 1);
+            }
+            continue;
+        }
+        if (char === "|" && command[index + 1] === "|") {
+            pushSegment(index + 2);
+            index += 1;
+            continue;
+        }
+        if (char === "|") {
+            const next = command[index + 1] ?? "";
+            if (next === "&") {
+                pushSegment(index + 2);
+                index += 1;
+            }
+            else {
+                pushSegment(index + 1);
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        segments.push({
+            segment: current,
+            prefix: command.slice(0, segmentStart),
+        });
+    }
+    return segments.length > 0 ? segments : [{ segment: command, prefix: "" }];
+}
+function collectOmxStateCommandOperations(command, operation, nested = false) {
+    command = normalizeShellLineContinuations(stripHeredocBodiesForCommandScan(command));
+    const operations = [];
+    const addOperation = (candidate) => {
+        operations.push(candidate);
+    };
+    const scanNestedSubstitutions = () => {
+        let quote = null;
+        for (let index = 0; index < command.length; index += 1) {
+            const char = command[index];
+            if (char === "\\" && quote !== "'") {
+                index += 1;
+                continue;
+            }
+            if (quote !== "'" && char === "$" && command[index + 1] === "(") {
+                const substitutionEnd = findCommandSubstitutionEnd(command, index + 2);
+                const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                const substitutionBody = command.slice(index + 2, substitutionBodyEnd);
+                for (const nestedOperation of collectOmxStateCommandOperations(substitutionBody, operation, true)) {
+                    addOperation(nestedOperation);
+                }
+                index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                continue;
+            }
+            if (quote !== "'" && char === "<" && command[index + 1] === "(") {
+                const substitutionEnd = findProcessSubstitutionEnd(command, index + 2);
+                const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                const substitutionBody = command.slice(index + 2, substitutionBodyEnd);
+                for (const nestedOperation of collectOmxStateCommandOperations(substitutionBody, operation, true)) {
+                    addOperation(nestedOperation);
+                }
+                index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                continue;
+            }
+            if (quote !== "'" && char === ">" && command[index + 1] === "(") {
+                const substitutionEnd = findProcessSubstitutionEnd(command, index + 2);
+                const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                const substitutionBody = command.slice(index + 2, substitutionBodyEnd);
+                for (const nestedOperation of collectOmxStateCommandOperations(substitutionBody, operation, true)) {
+                    addOperation(nestedOperation);
+                }
+                index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                continue;
+            }
+            if (quote !== "'" && char === "`") {
+                const substitutionEnd = findBacktickCommandSubstitutionEnd(command, index + 1);
+                const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                const substitutionBody = command.slice(index + 1, substitutionBodyEnd);
+                for (const nestedOperation of collectOmxStateCommandOperations(substitutionBody, operation, true)) {
+                    addOperation(nestedOperation);
+                }
+                index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+                continue;
+            }
+            if (char === "'" || char === "\"") {
+                if (quote === char) {
+                    quote = null;
+                }
+                else if (!quote) {
+                    quote = char;
+                }
+            }
+        }
+    };
+    scanNestedSubstitutions();
+    for (const functionBody of extractInvokedShellFunctionBodiesForStateScan(command)) {
+        for (const nestedOperation of collectOmxStateCommandOperations(functionBody, operation, true)) {
+            addOperation(nestedOperation);
+        }
+    }
+    for (const scanSegment of splitStateScanSegments(command)) {
+        const words = tokenizeShellWords(scanSegment.segment);
+        const stateCommand = readOmxStateCommandFromSegmentWords(words, operation);
+        if (stateCommand) {
+            addOperation({
+                args: stateCommand.args,
+                prefix: scanSegment.prefix,
+                commandPrefix: stateCommand.prefixWords.join(" "),
+                nested,
+            });
+        }
+    }
+    for (const nestedCommand of extractNestedShellCommandStringsForStateScan(command)) {
+        for (const nestedOperation of collectOmxStateCommandOperations(nestedCommand, operation, true)) {
+            addOperation(nestedOperation);
+        }
+    }
+    return operations;
+}
+function extractInvokedShellFunctionBodiesForStateScan(command) {
+    const bodies = [];
+    command = stripHeredocBodiesForCommandScan(normalizeShellLineContinuations(command));
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote)
+            continue;
+        const functionDefinition = findShellFunctionDefinitionAt(command, index);
+        if (!functionDefinition)
+            continue;
+        const functionBodyEnd = findShellFunctionBodyEnd(command, functionDefinition.openBraceIndex, functionDefinition.bodyOpenChar);
+        if (functionBodyEnd < 0)
+            continue;
+        if (isShellFunctionInvokedLater(command.slice(functionBodyEnd + 1), functionDefinition.name)) {
+            bodies.push(command.slice(functionDefinition.openBraceIndex + 1, functionBodyEnd));
+        }
+        index = functionBodyEnd;
+    }
+    return bodies;
+}
+function findUnquotedOmxStateCommandIndexes(command, operation) {
+    return collectOmxStateCommandOperations(command, operation).map((_, index) => index);
+}
+function extractNestedShellCommandStringsForStateScan(command) {
+    const words = tokenizeShellWords(stripHeredocBodiesForCommandScan(command));
+    const nested = [];
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (isNestedShellCommandWord(word)) {
+            const commandStringIndex = findShellCommandStringArgIndex(words, index + 1);
+            if (commandStringIndex !== null) {
+                const nestedCommand = words[commandStringIndex];
+                if (nestedCommand) {
+                    nested.push(nestedCommand);
+                    const positionalArgs = words.slice(commandStringIndex + 1);
+                    const expandedNestedCommand = expandShellPositionalParameters(nestedCommand, positionalArgs);
+                    if (expandedNestedCommand !== nestedCommand)
+                        nested.push(expandedNestedCommand);
+                }
+            }
+        }
+        if (word === "eval") {
+            const nestedCommand = words.slice(index + 1).join(" ");
+            if (nestedCommand)
+                nested.push(nestedCommand);
+        }
+        if (shellWordBaseName(word) === "env") {
+            const splitStringCommand = extractEnvSplitStringCommand(words, index + 1);
+            if (splitStringCommand) {
+                nested.push(splitStringCommand);
+            }
+        }
+        else if (isPackageManagerCommandWord(word)) {
+            const packageManagerCommand = extractPackageManagerExecCommand(command, words, index + 1, shellWordBaseName(word));
+            if (packageManagerCommand) {
+                nested.push(packageManagerCommand);
+            }
+        }
+    }
+    return nested;
+}
+function extractNestedCommandSubstitutionStringsForStateScan(command) {
+    const nested = [];
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (quote !== "'" && char === "$" && command[index + 1] === "(") {
+            const substitutionEnd = findCommandSubstitutionEnd(command, index + 2);
+            const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+            const substitutionBody = command.slice(index + 2, substitutionBodyEnd);
+            if (substitutionBody)
+                nested.push(substitutionBody);
+            index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+            continue;
+        }
+        if (quote !== "'" && char === "`") {
+            const substitutionEnd = findBacktickCommandSubstitutionEnd(command, index + 1);
+            const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+            const substitutionBody = command.slice(index + 1, substitutionBodyEnd);
+            if (substitutionBody)
+                nested.push(substitutionBody);
+            index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+        }
+    }
+    return nested;
+}
+function extractNestedProcessSubstitutionStringsForStateScan(command) {
+    const nested = [];
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (quote !== "'" && (char === "<" || char === ">") && command[index + 1] === "(") {
+            const substitutionEnd = findProcessSubstitutionEnd(command, index + 2);
+            const substitutionBodyEnd = substitutionEnd >= 0 ? substitutionEnd : command.length;
+            const substitutionBody = command.slice(index + 2, substitutionBodyEnd);
+            if (substitutionBody)
+                nested.push(substitutionBody);
+            index = substitutionEnd >= 0 ? substitutionEnd : command.length;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+        }
+    }
+    return nested;
+}
+function isPackageManagerCommandWord(word) {
+    const base = shellWordBaseName(word);
+    return base === "npm" || base === "pnpm" || base === "yarn" || base === "npx" || base === "pnpx";
+}
+function hasDynamicNestedShellExecution(command) {
+    const commands = splitShellCommandSegments(stripHeredocBodiesForCommandScan(command));
+    for (const segment of commands) {
+        const words = tokenizeShellWords(segment);
+        let sawCommandWord = false;
+        for (let index = 0; index < words.length; index += 1) {
+            const word = words[index] ?? "";
+            if (!sawCommandWord) {
+                if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word))
+                    continue;
+                sawCommandWord = true;
+                if (isDynamicNestedCommandString(word))
+                    return true;
+            }
+            if (isCommandDispatchBuiltin(word)) {
+                const dispatchedCommand = extractDispatchBuiltinOperand(words, index + 1, word);
+                if (dispatchedCommand && hasDynamicNestedShellExecution(dispatchedCommand))
+                    return true;
+            }
+            if (containsUnquotedProcessSubstitution(segment) && (isNestedShellCommandWord(word) || word === "." || word === "source"))
+                return true;
+            if (isNestedShellCommandWord(word)) {
+                const commandStringIndex = findShellCommandStringArgIndex(words, index + 1);
+                if (commandStringIndex === null && (hasUnquotedShellStdinFlowAroundShellWord(words, index) || segment.includes("<<")))
+                    return true;
+                if (commandStringIndex !== null) {
+                    const nestedCommand = words[commandStringIndex] ?? "";
+                    if (isDynamicNestedCommandString(nestedCommand))
+                        return true;
+                }
+            }
+            if (word === "eval") {
+                const nestedCommand = words.slice(index + 1).join(" ");
+                if (isDynamicNestedCommandString(nestedCommand))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function isCommandDispatchBuiltin(word) {
+    return word === "exec" || word === "command" || word === "." || word === "source" || word === "env" || word === "nohup";
+}
+function extractDispatchBuiltinOperand(words, startIndex, builtin) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (!option)
+            continue;
+        if (option === "--")
+            continue;
+        if (isShellAssignmentWord(option))
+            continue;
+        if (builtin === "exec" && option === "-a") {
+            index += 1;
+            continue;
+        }
+        if (builtin === "env" && (option === "-S" || option === "--split-string")) {
+            const splitOperand = words[index + 1] ?? "";
+            return splitOperand;
+        }
+        if (builtin === "env" && option.startsWith("--split-string=")) {
+            return option.slice("--split-string=".length);
+        }
+        if (builtin === "env" && option.startsWith("-S") && option.length > 2) {
+            return option.slice(2);
+        }
+        if (option.startsWith("-"))
+            continue;
+        return words.slice(index).join(" ");
+    }
+    return "";
+}
+function isNestedShellCommandWord(word) {
+    const base = word.split(/[\\/]/).pop() ?? word;
+    return /^(?:bash|sh|zsh|dash|ksh|mksh|ash)$/.test(base);
+}
+function findShellCommandStringArgIndex(words, optionStartIndex) {
+    for (let index = optionStartIndex; index < words.length; index += 1) {
+        const option = words[index] ?? "";
+        if (option === "--")
+            return null;
+        if (isShellCommandStringOption(option))
+            return index + 1;
+        if (isShellOptionWithSeparateValue(option)) {
+            index += 1;
+            continue;
+        }
+        if (option.startsWith("-"))
+            continue;
+        return null;
+    }
+    return null;
+}
+function isShellCommandStringOption(option) {
+    return /^-[^-]*c[^-]*$/.test(option);
+}
+function isShellOptionWithSeparateValue(option) {
+    return option === "--rcfile" || option === "--init-file" || option === "-o" || option === "-O";
+}
+function isDynamicNestedCommandString(command) {
+    return /(?:^|[^\\])\$(?:[A-Za-z_][A-Za-z0-9_]*|\{[^}]+\}|\()/.test(command)
+        || /(?:^|[^\\])`/.test(command);
+}
+function shellQuoteForStateScan(value) {
+    if (value === "")
+        return "''";
+    return `'${value.replace(/'/g, "'\"'\"'")}'`;
+}
+function expandShellPositionalParameters(command, positionalArgs) {
+    if (!command.includes("$") || positionalArgs.length === 0)
+        return command;
+    let expanded = "";
+    let replaced = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "\\" && index + 1 < command.length) {
+            expanded += char;
+            index += 1;
+            expanded += command[index] ?? "";
+            continue;
+        }
+        if (char !== "$") {
+            expanded += char;
+            continue;
+        }
+        const next = command[index + 1] ?? "";
+        if (next === "{") {
+            let endIndex = index + 2;
+            let digits = "";
+            while (endIndex < command.length) {
+                const bodyChar = command[endIndex] ?? "";
+                if (bodyChar === "}")
+                    break;
+                digits += bodyChar;
+                endIndex += 1;
+            }
+            if (command[endIndex] === "}" && /^\d+$/.test(digits)) {
+                const positionalIndex = Number.parseInt(digits, 10);
+                const replacement = positionalArgs[positionalIndex];
+                if (replacement !== undefined) {
+                    expanded += shellQuoteForStateScan(replacement);
+                    replaced = true;
+                    index = endIndex;
+                    continue;
+                }
+            }
+            if (command[endIndex] === "}" && (digits === "@" || digits === "*")) {
+                const expansionArgs = positionalArgs.slice(1);
+                const replacement = expansionArgs.map((arg) => shellQuoteForStateScan(arg)).join(" ");
+                expanded += replacement;
+                replaced = true;
+                index = endIndex;
+                continue;
+            }
+        }
+        else if (next === "@" || next === "*") {
+            const replacement = positionalArgs.slice(1).map((arg) => shellQuoteForStateScan(arg)).join(" ");
+            if (replacement) {
+                expanded += replacement;
+                replaced = true;
+                index += 1;
+                continue;
+            }
+        }
+        else if (/[0-9]/.test(next)) {
+            let endIndex = index + 1;
+            let digits = "";
+            while (endIndex < command.length && /[0-9]/.test(command[endIndex] ?? "")) {
+                digits += command[endIndex] ?? "";
+                endIndex += 1;
+            }
+            const positionalIndex = Number.parseInt(digits, 10);
+            const replacement = positionalArgs[positionalIndex];
+            if (replacement !== undefined) {
+                expanded += shellQuoteForStateScan(replacement);
+                replaced = true;
+                index = endIndex - 1;
+                continue;
+            }
+        }
+        expanded += char;
+    }
+    return replaced ? expanded : command;
+}
+function splitShellCommandSegments(command) {
+    const segments = [];
+    let current = "";
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            current += char;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            current += char;
+            index += 1;
+            current += command[index] ?? "";
+            continue;
+        }
+        if (quote) {
+            current += char;
+            continue;
+        }
+        if (char === ";" || char === "\n" || char === "\r") {
+            if (current.trim())
+                segments.push(current);
+            current = "";
+            continue;
+        }
+        if (char === "&" && command[index - 1] !== "|") {
+            if (current.trim())
+                segments.push(current);
+            current = "";
+            if (command[index + 1] === "&")
+                index += 1;
+            continue;
+        }
+        if (char === "|" && command[index + 1] === "|") {
+            if (current.trim())
+                segments.push(current);
+            current = "";
+            index += 1;
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim())
+        segments.push(current);
+    return segments.length > 0 ? segments : [command];
+}
+function findDispatchWordIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token || token === "--")
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        return index;
+    }
+    return null;
+}
+function isShellAssignmentWord(word) {
+    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(word);
+}
+function hasUnquotedShellStdinFlowAroundShellWord(words, wordIndex) {
+    for (let index = 0; index < wordIndex; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "|" || word === "|&")
+            return true;
+        if (word === "<" || word === "<<" || word === "<<<" || word.startsWith("<"))
+            return true;
+    }
+    for (let index = wordIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "<" || word === "<<" || word === "<<<" || word.startsWith("<"))
+            return true;
+    }
+    return false;
+}
+function findCommandSubstitutionEnd(command, bodyStartIndex) {
+    let depth = 1;
+    let quote = null;
+    for (let index = bodyStartIndex; index < command.length; index += 1) {
+        const char = command[index];
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote)
+            continue;
+        if (char === "$" && command[index + 1] === "(") {
+            depth += 1;
+            index += 1;
+            continue;
+        }
+        if (char === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function findBacktickCommandSubstitutionEnd(command, bodyStartIndex) {
+    for (let index = bodyStartIndex; index < command.length; index += 1) {
+        const char = command[index];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (char === "`")
+            return index;
+    }
+    return -1;
+}
+function findProcessSubstitutionEnd(command, bodyStartIndex) {
+    let depth = 1;
+    let quote = null;
+    for (let index = bodyStartIndex; index < command.length; index += 1) {
+        const char = command[index];
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote)
+            continue;
+        if (char === "(") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function containsUnquotedProcessSubstitution(command) {
+    command = normalizeShellLineContinuations(command);
+    let quote = null;
+    for (let index = 0; index < command.length - 1; index += 1) {
+        const char = command[index];
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote)
+            continue;
+        if ((char === "<" || char === ">") && command[index + 1] === "(")
+            return true;
+    }
+    return false;
+}
+function parseShellHeredocDelimiter(line, startIndex) {
+    let index = startIndex;
+    while (/\s/.test(line[index] ?? ""))
+        index += 1;
+    let delimiter = "";
+    let quoted = false;
+    let quote = null;
+    for (; index < line.length; index += 1) {
+        const char = line[index] ?? "";
+        if (char === "\\" && quote !== "'") {
+            quoted = true;
+            index += 1;
+            delimiter += line[index] ?? "";
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+                quoted = true;
+            }
+            else {
+                delimiter += char;
+            }
+            continue;
+        }
+        if (!quote && (/\s/.test(char) || char === "|" || char === ";" || char === "&" || char === "<" || char === ">"))
+            break;
+        delimiter += char;
+    }
+    return delimiter ? { delimiter, quoted } : null;
+}
+function extractShellHeredocOpeners(line) {
+    const openers = [];
+    let quote = null;
+    for (let index = 0; index < line.length - 1; index += 1) {
+        const char = line[index] ?? "";
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote)
+            continue;
+        if (char !== "<" || line[index + 1] !== "<" || line[index + 2] === "<")
+            continue;
+        const delimiterStart = line[index + 2] === "-" ? index + 3 : index + 2;
+        const opener = parseShellHeredocDelimiter(line, delimiterStart);
+        if (opener)
+            openers.push(opener);
+        index = delimiterStart;
+    }
+    return openers;
+}
+function stripHeredocBodiesForCommandScan(command) {
+    const lines = command.split("\n");
+    const kept = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        kept.push(line);
+        const openers = extractShellHeredocOpeners(line);
+        for (const { delimiter } of openers) {
+            index += 1;
+            while (index < lines.length && (lines[index] ?? "").trim() !== delimiter) {
+                kept.push("");
+                index += 1;
+            }
+            if (index < lines.length)
+                kept.push(lines[index] ?? "");
+        }
+    }
+    return kept.join("\n");
+}
+function hasUnsafeUnquotedHeredocExpansion(command) {
+    const lines = normalizeShellLineContinuations(command).split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        for (const { delimiter, quoted } of extractShellHeredocOpeners(line)) {
+            index += 1;
+            const bodyLines = [];
+            while (index < lines.length && (lines[index] ?? "").trim() !== delimiter) {
+                bodyLines.push(lines[index] ?? "");
+                index += 1;
+            }
+            if (!quoted && isDynamicNestedCommandString(bodyLines.join("\n")))
+                return true;
+        }
+    }
+    return false;
+}
+function hasUnquotedShellSubstitution(command) {
+    command = normalizeShellLineContinuations(command);
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index] ?? "";
+        if (char === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            if (quote === char) {
+                quote = null;
+            }
+            else if (!quote) {
+                quote = char;
+            }
+            continue;
+        }
+        if (quote === "'")
+            continue;
+        if (char === "$" && command[index + 1] === "(")
+            return true;
+        if (char === "`")
+            return true;
+        if ((char === "<" || char === ">") && command[index + 1] === "(")
+            return true;
+    }
+    return false;
+}
+function normalizeStateWriteClassificationPayload(payload) {
+    const targetMode = safeString(payload.mode).trim();
+    const targetSessionId = safeString(payload.session_id).trim();
+    const { mode: _mode, workingDirectory: _workingDirectory, state, ...fields } = payload;
+    const normalized = {
+        ...fields,
+        ...safeObject(state),
+        ...(targetMode ? { mode: targetMode } : {}),
+        ...(targetSessionId ? { session_id: targetSessionId } : {}),
+    };
+    if (normalized.current_phase === undefined && normalized.currentPhase !== undefined) {
+        normalized.current_phase = normalized.currentPhase;
+    }
+    if (normalized.run_outcome === undefined && normalized.runOutcome !== undefined) {
+        normalized.run_outcome = normalized.runOutcome;
+    }
+    if (normalized.lifecycle_outcome === undefined && normalized.lifecycleOutcome !== undefined) {
+        normalized.lifecycle_outcome = normalized.lifecycleOutcome;
+    }
+    if (normalized.terminal_outcome === undefined && normalized.terminalOutcome !== undefined) {
+        normalized.terminal_outcome = normalized.terminalOutcome;
+    }
+    return {
+        ...normalized,
+    };
+}
+function isPlanningPhaseDeactivationPayload(payload) {
+    const mode = safeString(payload.mode).trim().toLowerCase();
+    if (!mode)
+        return false;
+    if (mode !== "deep-interview" && mode !== "ralplan") {
+        if (!isTrackedWorkflowMode(mode))
+            return false;
+        const currentPhase = safeString(payload.current_phase ?? payload.currentPhase).trim().toLowerCase();
+        const normalizedAutopilotPhase = normalizeAutopilotPhase(currentPhase);
+        if (mode === "autopilot" && (normalizedAutopilotPhase === "deep-interview" || normalizedAutopilotPhase === "ralplan" || normalizedAutopilotPhase === "ultragoal")) {
+            return payload.active === false;
+        }
+        if (payload.active === true)
+            return true;
+        return inferTerminalLifecycleOutcome(payload, { includeQuestionEnforcement: false }) === undefined;
+    }
+    if (payload.active === false)
+        return true;
+    return inferTerminalLifecycleOutcome(payload, { includeQuestionEnforcement: false }) !== undefined;
+}
+function hasCompleteDeepInterviewGateMetadata(state) {
+    const nestedState = safeObject(state.state);
+    const gate = safeObject(state.deep_interview_gate) ?? safeObject(nestedState?.deep_interview_gate);
+    if (!gate)
+        return false;
+    const status = safeString(gate.status).trim().toLowerCase().replace(/_/g, "-");
+    if (status === "complete" || gate.complete === true) {
+        return ["rationale", "completion_rationale", "handoff_summary", "summary", "reason"]
+            .some((key) => safeString(gate[key]).trim().length > 0);
+    }
+    if (status !== "skipped")
+        return false;
+    const reason = safeString(gate.reason).trim() || safeString(gate.skip_reason).trim() || safeString(gate.rationale).trim();
+    const timestamp = safeString(gate.skipped_at).trim() || safeString(gate.timestamp).trim() || safeString(gate.updated_at).trim();
+    const source = safeString(gate.source).trim();
+    return (gate.skip_authorized_by_user === true || gate.authorized_by_user === true)
+        && reason.length > 0
+        && timestamp.length > 0
+        && source.length > 0;
+}
+function isDeepInterviewRalplanHandoffStatePayload(payload) {
+    const mode = safeString(payload.mode).trim().toLowerCase();
+    if (mode !== "autopilot")
+        return false;
+    const phase = normalizeAutopilotPhase(safeString(payload.current_phase ?? payload.currentPhase).trim().toLowerCase());
+    if (phase !== "ralplan" || payload.active === false)
+        return false;
+    return hasCompleteDeepInterviewGateMetadata(payload);
+}
+function hasOnlyAllowedDeepInterviewRalplanHandoffMutations(cwd, command) {
+    for (const mutation of extractConductorBashMutations(command)) {
+        if (mutation.targets.length === 0)
+            return false;
+        if (mutation.targets.some((target) => !isAllowedDeepInterviewArtifactPath(cwd, target)))
+            return false;
+    }
+    for (const write of extractConductorInterpreterWrites(command)) {
+        if (write.unresolved || write.targets.length === 0)
+            return false;
+        if (write.targets.some((target) => !isAllowedDeepInterviewArtifactPath(cwd, target)))
+            return false;
+    }
+    return true;
+}
+function isDurableDeepInterviewHandoffEvidencePath(cwd, rawPath) {
+    const relativePath = normalizePlanningArtifactRelativePath(cwd, rawPath);
+    if (!relativePath)
+        return false;
+    return relativePath === ".omx/context"
+        || relativePath.startsWith(".omx/context/")
+        || relativePath === ".omx/interviews"
+        || relativePath.startsWith(".omx/interviews/")
+        || relativePath === ".omx/specs"
+        || relativePath.startsWith(".omx/specs/");
+}
+function hasExistingDurableDeepInterviewHandoffEvidence(cwd) {
+    const roots = [".omx/context", ".omx/interviews", ".omx/specs"];
+    const maxEntries = 2_000;
+    let visited = 0;
+    for (const root of roots) {
+        const stack = [resolve(cwd, root)];
+        while (stack.length > 0 && visited < maxEntries) {
+            const current = stack.pop();
+            if (!current)
+                continue;
+            visited += 1;
+            try {
+                const stat = statSync(current);
+                if (stat.isFile())
+                    return true;
+                if (!stat.isDirectory())
+                    continue;
+                for (const entry of readdirSync(current)) {
+                    stack.push(join(current, entry));
+                }
+            }
+            catch {
+                // Missing or unreadable roots are not completion evidence.
+            }
+        }
+    }
+    return false;
+}
+function isAllowedDeepInterviewRalplanHandoffCommand(cwd, command) {
+    const canonicalCommand = canonicalizeOmxStateTransportCommand(command);
+    if (hasUnsafeUnquotedHeredocExpansion(canonicalCommand))
+        return false;
+    if (hasUnquotedShellSubstitution(canonicalCommand))
+        return false;
+    if (findUnquotedOmxStateCommandIndexes(canonicalCommand, "clear").length > 0)
+        return false;
+    if (hasDynamicNestedShellExecution(canonicalCommand))
+        return false;
+    if (commandHasUntargetedPlanningForbiddenIntent(canonicalCommand))
+        return false;
+    if (sourcesFileWrittenEarlierInSameCommand(cwd, canonicalCommand))
+        return false;
+    const stateWriteOperations = collectOmxStateCommandOperations(canonicalCommand, "write");
+    if (stateWriteOperations.length !== 1)
+        return false;
+    const stateWriteOperation = stateWriteOperations[0];
+    if (!stateWriteOperation || stateWriteOperation.nested)
+        return false;
+    const payload = readStateWriteInputPayload(cwd, canonicalCommand, command);
+    if (!payload || !isDeepInterviewRalplanHandoffStatePayload(payload))
+        return false;
+    const targets = extractDeepInterviewCommandWriteTargets(command);
+    if (targets.length === 0) {
+        return !hasPriorExecutableCommand(stateWriteOperation.prefix)
+            && hasExistingDurableDeepInterviewHandoffEvidence(cwd);
+    }
+    if (!targets.some((target) => isDurableDeepInterviewHandoffEvidencePath(cwd, target)))
+        return false;
+    if (!hasOnlyAllowedDeepInterviewRalplanHandoffMutations(cwd, command))
+        return false;
+    return targets.every((target) => isAllowedDeepInterviewArtifactPath(cwd, target));
+}
+function hasDeepInterviewRalplanHandoffStateMutation(cwd, command) {
+    const canonicalCommand = canonicalizeOmxStateTransportCommand(command);
+    const stateWriteOperations = collectOmxStateCommandOperations(canonicalCommand, "write");
+    if (stateWriteOperations.length === 0)
+        return false;
+    const payload = readStateWriteInputPayload(cwd, canonicalCommand, command);
+    return payload ? isDeepInterviewRalplanHandoffStatePayload(payload) : false;
+}
+function isCompleteRalplanTerminalWritePayload(payload, activeState, sessionId) {
+    if (!sessionId)
+        return false;
+    const mode = safeString(payload.mode).trim().toLowerCase();
+    if (mode !== "ralplan")
+        return false;
+    const phase = safeString(payload.current_phase ?? payload.currentPhase).trim().toLowerCase();
+    if (payload.active !== false || phase !== "complete")
+        return false;
+    const payloadSessionId = safeString(payload.session_id).trim();
+    const activeSessionId = safeString(activeState.session_id
+        ?? activeState.owner_omx_session_id
+        ?? activeState.codex_session_id
+        ?? activeState.owner_codex_session_id).trim();
+    if (payloadSessionId && sessionId && payloadSessionId !== sessionId)
+        return false;
+    if (payloadSessionId && activeSessionId && payloadSessionId !== activeSessionId)
+        return false;
+    return true;
+}
+function isAllowedRalplanTerminalStateWriteCommand(cwd, command, activeState, sessionId) {
+    const canonicalCommand = canonicalizeOmxStateTransportCommand(command);
+    if (hasUnsafeUnquotedHeredocExpansion(canonicalCommand))
+        return false;
+    if (hasUnquotedShellSubstitution(canonicalCommand))
+        return false;
+    if (splitStateScanSegments(canonicalCommand).length !== 1)
+        return false;
+    if (sourcesFileWrittenEarlierInSameCommand(cwd, canonicalCommand))
+        return false;
+    if (findUnquotedOmxStateCommandIndexes(canonicalCommand, "clear").length > 0)
+        return false;
+    if (hasDynamicNestedShellExecution(canonicalCommand))
+        return false;
+    if (commandHasDeepInterviewWriteIntent(canonicalCommand))
+        return false;
+    const operations = collectOmxStateCommandOperations(canonicalCommand, "write");
+    if (operations.length !== 1)
+        return false;
+    const operation = operations[0];
+    if (!operation || operation.nested || hasPriorExecutableCommand(operation.prefix))
+        return false;
+    const payload = readStateWriteInputPayload(cwd, canonicalCommand, command);
+    return payload ? isCompleteRalplanTerminalWritePayload(payload, activeState, sessionId) : false;
+}
+function commandEndsPlanningPhase(cwd, command) {
+    if (findUnquotedOmxStateCommandIndexes(command, "clear").length > 0)
+        return true;
+    const canonicalCommand = canonicalizeOmxStateTransportCommand(command);
+    if (hasUnsafeUnquotedHeredocExpansion(canonicalCommand))
+        return true;
+    if (sourcesFileWrittenEarlierInSameCommand(cwd, canonicalCommand))
+        return true;
+    if (findUnquotedOmxStateCommandIndexes(canonicalCommand, "clear").length > 0)
+        return true;
+    if (hasDynamicNestedShellExecution(canonicalCommand))
+        return true;
+    const stateWriteCount = findUnquotedOmxStateCommandIndexes(canonicalCommand, "write").length;
+    if (stateWriteCount > 1)
+        return true;
+    if (stateWriteCount === 0)
+        return false;
+    const payload = readStateWriteInputPayload(cwd, canonicalCommand, command);
+    return payload ? isPlanningPhaseDeactivationPayload(payload) : true;
+}
+function isAllowedDeepInterviewBashWrite(cwd, command) {
+    if (isAllowedDeepInterviewRalplanHandoffCommand(cwd, command))
+        return true;
+    if (hasDeepInterviewRalplanHandoffStateMutation(cwd, command))
+        return false;
+    if (commandEndsPlanningPhase(cwd, command))
+        return false;
+    if (commandHasUntargetedPlanningForbiddenIntent(command))
+        return false;
+    if (firstPlanningTmpScriptExecutionTarget(cwd, command))
+        return false;
+    if (!commandHasDeepInterviewWriteIntent(command))
+        return true;
+    if (hasUnresolvedConductorInterpreterWrite(command))
+        return false;
+    const targets = extractDeepInterviewCommandWriteTargets(command);
+    if (targets.some((target) => !isAllowedDeepInterviewArtifactPath(cwd, target)))
+        return false;
+    return targets.length > 0 && targets.every((target) => isAllowedDeepInterviewArtifactPath(cwd, target));
+}
+async function readActiveDeepInterviewStateForPreToolUse(cwd, stateDir, sessionId, threadId) {
+    const canonicalState = sessionId
+        ? await readVisibleSkillActiveStateForStateDir(stateDir, sessionId)
+        : await readSkillActiveState(join(stateDir, SKILL_ACTIVE_STATE_FILE));
+    if (!canonicalState)
+        return null;
+    const modeState = sessionId
+        ? await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId, stateDir)
+        : await readJsonIfExists(join(stateDir, "deep-interview-state.json"));
+    if (isActiveDeepInterviewPhase(modeState) && modeState && modeStateMatchesSkillStopContext(modeState, cwd, sessionId)) {
+        const hasActiveDeepInterviewSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "deep-interview"
+            && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+        if (hasActiveDeepInterviewSkill)
+            return modeState;
+    }
+    const autopilotState = sessionId
+        ? await readStopSessionPinnedState("autopilot-state.json", cwd, sessionId, stateDir)
+        : await readJsonIfExists(join(stateDir, "autopilot-state.json"));
+    if (!autopilotState || autopilotState.active !== true)
+        return null;
+    const autopilotMode = safeString(autopilotState.mode).trim();
+    if (autopilotMode && autopilotMode !== "autopilot")
+        return null;
+    if (!modeStateMatchesSkillStopContext(autopilotState, cwd, sessionId))
+        return null;
+    const autopilotStatePhase = safeString(autopilotState.current_phase ?? autopilotState.currentPhase).trim().toLowerCase();
+    const autopilotIsDeepInterview = normalizeAutopilotPhase(autopilotStatePhase) === "deep-interview";
+    const hasDeepInterviewScopedAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
+        && normalizeAutopilotPhase(safeString(entry.phase).trim().toLowerCase()) === "deep-interview"
+        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+    const hasActiveAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
+        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+    if (!hasActiveAutopilotSkill)
+        return null;
+    if (!autopilotIsDeepInterview && !hasDeepInterviewScopedAutopilotSkill)
+        return null;
+    return autopilotState;
+}
+async function readActiveRalplanStateForPreToolUse(cwd, stateDir, sessionId, threadId) {
+    const modeState = sessionId
+        ? await readStopSessionPinnedState("ralplan-state.json", cwd, sessionId, stateDir)
+        : await readJsonIfExists(join(stateDir, "ralplan-state.json"));
+    const canonicalState = sessionId
+        ? await readVisibleSkillActiveStateForStateDir(stateDir, sessionId)
+        : await readSkillActiveState(join(stateDir, SKILL_ACTIVE_STATE_FILE));
+    if (isActiveRalplanPhase(modeState) && modeState && modeStateMatchesSkillStopContext(modeState, cwd, sessionId)) {
+        if (hasExplicitExecutionHandoffSkill(canonicalState, sessionId, threadId))
+            return null;
+        if (!canonicalState)
+            return null;
+        const hasActiveRalplanSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "ralplan"
+            && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+        if (hasActiveRalplanSkill)
+            return modeState;
+    }
+    const autopilotState = sessionId
+        ? await readStopSessionPinnedState("autopilot-state.json", cwd, sessionId, stateDir)
+        : await readJsonIfExists(join(stateDir, "autopilot-state.json"));
+    if (!autopilotState || autopilotState.active !== true)
+        return null;
+    const autopilotMode = safeString(autopilotState.mode).trim();
+    if (autopilotMode && autopilotMode !== "autopilot")
+        return null;
+    if (!modeStateMatchesSkillStopContext(autopilotState, cwd, sessionId))
+        return null;
+    if (!canonicalState)
+        return null;
+    const hasActiveAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
+        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+    if (!hasActiveAutopilotSkill)
+        return null;
+    const autopilotStatePhase = safeString(autopilotState.current_phase ?? autopilotState.currentPhase).trim().toLowerCase();
+    if (isAutopilotReviewReworkPhase(autopilotStatePhase))
+        return null;
+    if (!canAutopilotSkillMirrorSupplyRalplanPhase(autopilotStatePhase))
+        return null;
+    const hasRalplanScopedAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "autopilot"
+        && isAutopilotRalplanLikePhase(safeString(entry.phase).trim().toLowerCase())
+        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+    if (!isAutopilotRalplanLikePhase(autopilotStatePhase) && !hasRalplanScopedAutopilotSkill)
+        return null;
+    return hasActiveAutopilotSkill ? autopilotState : null;
+}
+function isAllowedRalplanBashWrite(cwd, command, activeState, sessionId) {
+    const beadsCommand = classifyRalplanBeadsMetadataCommand(cwd, command);
+    const targets = extractDeepInterviewCommandWriteTargets(command);
+    const hasAllowedTargets = targets.length > 0
+        && targets.every((target) => isAllowedRalplanArtifactPath(cwd, target));
+    if (beadsCommand.present) {
+        return beadsCommand.allowed && (targets.length === 0 || hasAllowedTargets);
+    }
+    if (commandEndsPlanningPhase(cwd, command)) {
+        return isAllowedRalplanTerminalStateWriteCommand(cwd, command, activeState, sessionId);
+    }
+    if (commandHasUntargetedPlanningForbiddenIntent(command))
+        return false;
+    if (firstPlanningTmpScriptExecutionTarget(cwd, command))
+        return false;
+    if (!commandHasDeepInterviewWriteIntent(command))
+        return true;
+    if (hasUnresolvedConductorInterpreterWrite(command))
+        return false;
+    if (targets.some((target) => !isAllowedRalplanArtifactPath(cwd, target)))
+        return false;
+    return hasAllowedTargets;
+}
+function buildRalplanBashBlockedDetail(cwd, command) {
+    const targets = extractDeepInterviewCommandWriteTargets(command);
+    const blockedTarget = targets.find((target) => !isAllowedRalplanArtifactPath(cwd, target));
+    if (blockedTarget && isUnresolvedVariableTarget(blockedTarget)) {
+        return `unresolved Bash write target ${blockedTarget} is not under allowed planning artifact paths or metadata paths (${RALPLAN_ALLOWED_WRITE_PREFIXES.join(", ")})`;
+    }
+    if (blockedTarget) {
         const operationClass = /\btee\s+(?:-a\s+)?/.test(command) ? "Bash tee write" : "Bash redirect write";
         return `${operationClass} target ${blockedTarget} is not under allowed planning artifact paths or metadata paths (${RALPLAN_ALLOWED_WRITE_PREFIXES.join(", ")})`;
     }
-    const beadsCommand = classifyRalplanBeadsMetadataCommand(cwd, command);
-    if (beadsCommand.present && !beadsCommand.allowed) {
-        return beadsCommand.reason ?? "Beads tracker command is not an allowed planning metadata mutation";
+    const executedTmpTarget = firstPlanningTmpScriptExecutionTarget(cwd, command);
+    if (executedTmpTarget) {
+        return `execution target ${executedTmpTarget} is under .omx/tmp; planning tmp artifacts must not be used as generated-script transport`;
+    }
+    if (commandHasPackageInstallIntent(command)) {
+        return "package installation commands are implementation actions and cannot be combined with allowed planning artifact writes";
+    }
+    if (commandHasDestructiveGitSubcommand(command)) {
+        return "destructive git commands are implementation actions and cannot be combined with allowed planning artifact writes";
+    }
+    const beadsCommand = classifyRalplanBeadsMetadataCommand(cwd, command);
+    if (beadsCommand.present && !beadsCommand.allowed) {
+        return beadsCommand.reason ?? "Beads tracker command is not an allowed planning metadata mutation";
+    }
+    if (beadsCommand.present) {
+        return "Beads tracker command also performs an implementation write outside allowed planning metadata";
+    }
+    return "Bash write intent did not identify an allowed planning artifact path or metadata path";
+}
+function buildDeepInterviewBashBlockedDetail(cwd, command) {
+    const targets = extractDeepInterviewCommandWriteTargets(command);
+    const blockedTarget = targets.find((target) => !isAllowedDeepInterviewArtifactPath(cwd, target));
+    if (blockedTarget && isUnresolvedVariableTarget(blockedTarget)) {
+        return `unresolved Bash write target ${blockedTarget} is not under allowed deep-interview artifact paths or metadata paths (${DEEP_INTERVIEW_ALLOWED_WRITE_PREFIXES.join(", ")})`;
+    }
+    if (blockedTarget) {
+        const operationClass = /\btee\s+(?:-a\s+)?/.test(command) ? "Bash tee write" : "Bash write";
+        return `${operationClass} target ${blockedTarget} is not under allowed deep-interview artifact paths or metadata paths (${DEEP_INTERVIEW_ALLOWED_WRITE_PREFIXES.join(", ")})`;
+    }
+    const executedTmpTarget = firstPlanningTmpScriptExecutionTarget(cwd, command);
+    if (executedTmpTarget) {
+        return `execution target ${executedTmpTarget} is under .omx/tmp; deep-interview tmp artifacts must not be used as generated-script transport`;
+    }
+    if (commandHasPackageInstallIntent(command)) {
+        return "package installation commands are implementation actions and cannot be combined with allowed deep-interview artifact writes";
+    }
+    if (commandHasDestructiveGitSubcommand(command)) {
+        return "destructive git commands are implementation actions and cannot be combined with allowed deep-interview artifact writes";
+    }
+    return "Bash write intent did not identify an allowed deep-interview artifact path or metadata path";
+}
+async function buildRalplanPreToolUseBoundaryOutput(payload, cwd, stateDir, resolvedSessionId) {
+    const sessionId = safeString(resolvedSessionId ?? readPayloadSessionId(payload)).trim();
+    if (await hasTrustedTypedSubagentThreadSpawnProvenanceForPreToolUse(payload, cwd, sessionId))
+        return null;
+    const threadId = readPayloadThreadId(payload);
+    const activeState = await readActiveRalplanStateForPreToolUse(cwd, stateDir, sessionId, threadId);
+    if (!activeState)
+        return null;
+    const toolName = safeString(payload.tool_name).trim();
+    const command = readPreToolUseCommand(payload);
+    const pathCandidates = readPreToolUsePathCandidates(payload);
+    let blocked = false;
+    let blockedDetail = "implementation/write tools are blocked until an explicit execution handoff workflow is activated";
+    if (toolName === "Bash") {
+        blocked = !isAllowedRalplanBashWrite(cwd, command, activeState, sessionId);
+        if (blocked) {
+            blockedDetail = buildRalplanBashBlockedDetail(cwd, command);
+        }
+    }
+    else if (toolName === "mcp__omx_state__state_clear"
+        || (toolName === "mcp__omx_state__state_write"
+            && isPlanningPhaseDeactivationPayload(normalizeStateWriteClassificationPayload(safeObject(payload.tool_input))))) {
+        blocked = true;
+        blockedDetail = `${toolName} would deactivate protected planning state`;
+    }
+    else if (PLANNING_MODE_IMPLEMENTATION_TOOL_NAMES.has(toolName)) {
+        const toolPathCandidates = collectImplementationToolPathCandidates(payload, toolName, pathCandidates);
+        if (toolPathCandidates.length === 0) {
+            blocked = true;
+            blockedDetail = describeImplementationToolBlock(toolName, undefined, toolPathCandidates.length);
+        }
+        else {
+            const blockedPath = toolPathCandidates.find((candidate) => !isAllowedRalplanArtifactPath(cwd, candidate));
+            blocked = blockedPath !== undefined;
+            if (blockedPath !== undefined) {
+                blockedDetail = describeImplementationToolBlock(toolName, blockedPath, toolPathCandidates.length);
+            }
+        }
+    }
+    if (!blocked)
+        return null;
+    const phase = formatPhase(activeState.current_phase ?? activeState.currentPhase, "planning");
+    const activeMode = safeString(activeState.mode).trim().toLowerCase();
+    const planningModeLabel = activeMode === "autopilot" ? "Autopilot planning" : "Ralplan";
+    const planningModeDescription = activeMode === "autopilot"
+        ? "Autopilot is supervising a planning phase"
+        : "Ralplan is consensus-planning mode";
+    return {
+        decision: "block",
+        reason: `${planningModeLabel} is active (phase: ${phase}); implementation/write tools are blocked until an explicit execution handoff workflow is activated; ${blockedDetail}.`,
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: `${planningModeDescription}. `
+                + "Write only planning artifacts under `.omx/context/`, `.omx/plans/`, `.omx/specs/`, `.omx/tmp/`, required `.omx/state/` files, or tracker metadata under `.beads/`. "
+                + "Do not edit implementation files or run implementation-focused writes from planning phases. "
+                + `To execute, first process an explicit handoff such as ${formatExecutionHandoffList(cwd)}, which must emit terminal planning state before implementation begins.`,
+        },
+    };
+}
+async function buildDeepInterviewPreToolUseBoundaryOutput(payload, cwd, stateDir, resolvedSessionId) {
+    const sessionId = safeString(resolvedSessionId ?? readPayloadSessionId(payload)).trim();
+    if (await hasTrustedTypedSubagentThreadSpawnProvenanceForPreToolUse(payload, cwd, sessionId))
+        return null;
+    const threadId = readPayloadThreadId(payload);
+    const activeState = await readActiveDeepInterviewStateForPreToolUse(cwd, stateDir, sessionId, threadId);
+    if (!activeState)
+        return null;
+    const toolName = safeString(payload.tool_name).trim();
+    const command = readPreToolUseCommand(payload);
+    const pathCandidates = readPreToolUsePathCandidates(payload);
+    let blocked = false;
+    let blockedDetail = "implementation/write tools are blocked until an explicit handoff workflow is activated";
+    if (toolName === "Bash") {
+        blocked = !isAllowedDeepInterviewBashWrite(cwd, command);
+        if (blocked) {
+            blockedDetail = buildDeepInterviewBashBlockedDetail(cwd, command);
+        }
+    }
+    else if (toolName === "mcp__omx_state__state_clear"
+        || (toolName === "mcp__omx_state__state_write"
+            && isPlanningPhaseDeactivationPayload(normalizeStateWriteClassificationPayload(safeObject(payload.tool_input))))) {
+        blocked = true;
+        blockedDetail = `${toolName} would deactivate protected deep-interview planning state`;
+    }
+    else if (DEEP_INTERVIEW_IMPLEMENTATION_TOOL_NAMES.has(toolName)) {
+        const candidates = collectImplementationToolPathCandidates(payload, toolName, pathCandidates);
+        blocked = candidates.length === 0
+            || !candidates.every((candidate) => isAllowedDeepInterviewArtifactPath(cwd, candidate));
+        if (blocked) {
+            const blockedPath = candidates.find((candidate) => !isAllowedDeepInterviewArtifactPath(cwd, candidate));
+            blockedDetail = describeImplementationToolBlock(toolName, blockedPath, candidates.length);
+        }
+    }
+    if (!blocked)
+        return null;
+    const phase = formatPhase(activeState.current_phase ?? activeState.currentPhase, "planning");
+    return {
+        decision: "block",
+        reason: `Deep-interview is active (phase: ${phase}); implementation/write tools are blocked until an explicit handoff workflow is activated; ${blockedDetail}.`,
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: `Deep-interview is requirements/spec mode. Treat detailed user answers as interview/spec material, not implicit implementation authorization. You may write only deep-interview artifacts under \`.omx/context/\`, \`.omx/interviews/\`, \`.omx/specs/\`, \`.omx/tmp/\`, or required \`.omx/state/\` files. To implement, first ask for or process an explicit transition such as \`$ralplan\`, \`$autopilot\`, ${formatExecutionHandoffList(cwd)}.`,
+        },
+    };
+}
+function blocksDeepInterviewImplementationWrite(payload, cwd) {
+    const toolName = safeString(payload.tool_name).trim();
+    if (toolName === "Bash") {
+        return !isAllowedDeepInterviewBashWrite(cwd, readPreToolUseCommand(payload));
+    }
+    if (!DEEP_INTERVIEW_IMPLEMENTATION_TOOL_NAMES.has(toolName))
+        return false;
+    const candidates = collectImplementationToolPathCandidates(payload, toolName, readPreToolUsePathCandidates(payload));
+    return candidates.length === 0
+        || !candidates.every((candidate) => isAllowedDeepInterviewArtifactPath(cwd, candidate));
+}
+// Shared builder for the "live root session pointer owned by another session"
+// fail-closed block. Deep-interview and ralplan/autopilot only differ in the
+// human-readable mode label and phase-description fragment; the decision,
+// structure, and guidance are identical.
+function buildRootPointerConflictBlock(activeState, planningModeLabel, planningPhaseDescription) {
+    const phase = formatPhase(activeState.current_phase ?? activeState.currentPhase, "planning");
+    return {
+        decision: "block",
+        reason: `${planningModeLabel} is active in the live root session pointer (phase: ${phase}), but the current native session could not be authoritatively resolved to that owner; failing closed for planning-write protection.`,
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: `OMX detected a live root session pointer owned by another session while a ${planningPhaseDescription} is active. `
+                + "This indicates collapsed session-root isolation. Do not perform implementation writes from this unresolved session; use the owning OMX session or restart with an isolated OMX_ROOT.",
+        },
+    };
+}
+function buildDeepInterviewRootPointerConflictBlock(activeState) {
+    return buildRootPointerConflictBlock(activeState, "Deep-interview", "deep-interview planning phase");
+}
+function buildRalplanRootPointerConflictBlock(activeState) {
+    const activeMode = safeString(activeState.mode).trim().toLowerCase();
+    const planningModeLabel = activeMode === "autopilot" ? "Autopilot planning" : "Ralplan";
+    return buildRootPointerConflictBlock(activeState, planningModeLabel, "ralplan/autopilot planning phase");
+}
+async function buildPlanningRootPointerConflictPreToolUseOutput(payload, cwd, stateDir, rootState) {
+    const rootSessionId = safeString(rootState?.session_id).trim();
+    if (!rootSessionId)
+        return null;
+    const ownerCwd = safeString(rootState?.cwd).trim() || cwd;
+    const deepInterviewState = await readActiveDeepInterviewStateForPreToolUse(ownerCwd, stateDir, rootSessionId, "");
+    if (deepInterviewState) {
+        const conflictToolName = safeString(payload.tool_name).trim();
+        if (conflictToolName === "mcp__omx_state__state_clear"
+            || (conflictToolName === "mcp__omx_state__state_write"
+                && isPlanningPhaseDeactivationPayload(normalizeStateWriteClassificationPayload(safeObject(payload.tool_input))))) {
+            return buildDeepInterviewRootPointerConflictBlock(deepInterviewState);
+        }
+        if (blocksDeepInterviewImplementationWrite(payload, cwd)) {
+            return buildDeepInterviewRootPointerConflictBlock(deepInterviewState);
+        }
+    }
+    const ralplanState = await readActiveRalplanStateForPreToolUse(ownerCwd, stateDir, rootSessionId, "");
+    if (!ralplanState)
+        return null;
+    const toolName = safeString(payload.tool_name).trim();
+    let blocked = false;
+    if (toolName === "Bash") {
+        const command = readPreToolUseCommand(payload);
+        blocked = commandEndsPlanningPhase(cwd, command)
+            || !isAllowedRalplanBashWrite(cwd, command, ralplanState, rootSessionId);
+    }
+    else if (toolName === "mcp__omx_state__state_clear"
+        || (toolName === "mcp__omx_state__state_write"
+            && isPlanningPhaseDeactivationPayload(normalizeStateWriteClassificationPayload(safeObject(payload.tool_input))))) {
+        blocked = true;
+    }
+    else if (PLANNING_MODE_IMPLEMENTATION_TOOL_NAMES.has(toolName)) {
+        const toolPathCandidates = collectImplementationToolPathCandidates(payload, toolName, readPreToolUsePathCandidates(payload));
+        blocked = toolPathCandidates.length === 0
+            || toolPathCandidates.some((candidate) => !isAllowedRalplanArtifactPath(cwd, candidate));
+    }
+    return blocked ? buildRalplanRootPointerConflictBlock(ralplanState) : null;
+}
+async function hasTrustedTypedSubagentThreadSpawnProvenanceForPreToolUse(payload, cwd, sessionId) {
+    if (hasTeamWorkerEnvironment())
+        return true;
+    const source = safeObject(payload.source);
+    const subagent = safeObject(source.subagent);
+    const threadSpawn = safeObject(subagent.thread_spawn);
+    const parentThreadId = safeString(threadSpawn.parent_thread_id
+        ?? threadSpawn.parentThreadId
+        ?? threadSpawn.leader_thread_id
+        ?? threadSpawn.leaderThreadId).trim();
+    if (!parentThreadId)
+        return false;
+    if (!isTypedAgentRolePayload(payload))
+        return false;
+    const trackingState = await readSubagentTrackingState(cwd).catch(() => null);
+    const session = trackingState?.sessions?.[sessionId];
+    if (!session)
+        return false;
+    return session.leader_thread_id === parentThreadId || parentThreadId in session.threads;
+}
+function isActiveConductorModeState(state, mode, sessionId) {
+    if (!state || state.active !== true)
+        return false;
+    const stateMode = safeString(state.mode).trim();
+    if (stateMode && stateMode !== mode)
+        return false;
+    const stateSessionId = safeString(state.session_id).trim();
+    if (sessionId && stateSessionId && stateSessionId !== sessionId)
+        return false;
+    return isNonTerminalPhase(state.current_phase ?? state.currentPhase);
+}
+async function readActiveMainRootConductorStateForPreToolUse(payload, cwd, stateDir, resolvedSessionId) {
+    const sessionId = safeString(resolvedSessionId ?? readPayloadSessionId(payload)).trim();
+    const payloadSessionId = readPayloadSessionId(payload);
+    if (payloadSessionId && sessionId && payloadSessionId !== sessionId) {
+        const currentSession = await readUsableSessionStateFromStateDir(cwd, stateDir).catch(() => null);
+        const payloadMatchesMappedSession = payloadSessionId === safeString(currentSession?.native_session_id).trim()
+            || payloadSessionId === safeString(currentSession?.owner_omx_session_id).trim()
+            || payloadSessionId === safeString(currentSession?.owner_codex_session_id).trim();
+        if (!payloadMatchesMappedSession)
+            return null;
+    }
+    const threadId = readPayloadThreadId(payload);
+    if (!sessionId)
+        return null;
+    if (await hasTrustedTypedSubagentThreadSpawnProvenanceForPreToolUse(payload, cwd, sessionId))
+        return null;
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
+    if (!canonicalState)
+        return null;
+    const activeEntries = listActiveSkills(canonicalState).filter((entry) => (matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+    const hasActiveSkill = (skill) => activeEntries.some((entry) => entry.skill === skill);
+    if (hasActiveSkill("autopilot")) {
+        const state = await readStopSessionPinnedState("autopilot-state.json", cwd, sessionId, stateDir);
+        const childPhase = deriveAutopilotChildPhase(state);
+        const hasMatchingAutopilotEntry = activeEntries.some((entry) => (entry.skill === "autopilot"
+            && normalizeAutopilotPhase(safeString(entry.phase).trim().toLowerCase()) === childPhase));
+        if (state
+            && childPhase
+            && childPhase !== "deep-interview"
+            && childPhase !== "ralplan"
+            && childPhase !== "rework"
+            && hasMatchingAutopilotEntry
+            && isActiveConductorModeState(state, "autopilot", sessionId)) {
+            return { mode: "autopilot", phase: childPhase };
+        }
+    }
+    if (hasActiveSkill("ralph")) {
+        const state = await readStopSessionPinnedState("ralph-state.json", cwd, sessionId, stateDir);
+        if (isActiveConductorModeState(state, "ralph", sessionId)) {
+            const phase = safeString(state?.current_phase ?? state?.currentPhase) || "active";
+            if (phase.toLowerCase() !== "starting")
+                return { mode: "ralph", phase };
+        }
+    }
+    if (hasActiveSkill("ultragoal")) {
+        const state = await readStopSessionPinnedState("ultragoal-state.json", cwd, sessionId, stateDir);
+        if (isActiveConductorModeState(state, "ultragoal", sessionId)) {
+            return { mode: "ultragoal", phase: safeString(state?.current_phase ?? state?.currentPhase) || "active" };
+        }
+    }
+    if (hasActiveSkill("team") && !hasTeamWorkerEnvironment()) {
+        const teamStateForStop = await readTeamModeStateForStop(cwd, stateDir, sessionId, threadId);
+        const state = teamStateForStop?.state ?? null;
+        if (isActiveConductorModeState(state, "team", sessionId)) {
+            const teamName = safeString(state?.team_name).trim();
+            const phase = teamName ? (await readTeamPhase(teamName, cwd).catch(() => null))?.current_phase ?? state?.current_phase : state?.current_phase;
+            if (isNonTerminalPhase(phase))
+                return { mode: "team", phase: safeString(phase) || "active" };
+        }
+    }
+    return null;
+}
+function normalizeRepoRelativePath(cwd, rawPath) {
+    const candidate = rawPath.trim().replace(/^['"]|['"]$/g, "");
+    if (!candidate || isUnresolvedVariableTarget(candidate))
+        return null;
+    const absolute = isAbsolute(candidate) ? resolve(candidate) : resolve(cwd, candidate);
+    let relativePath = relative(cwd, absolute).replace(/\\/g, "/");
+    if (!relativePath || relativePath === ".")
+        return null;
+    if (relativePath.startsWith("../") || relativePath === "..") {
+        relativePath = candidate.replace(/\\/g, "/");
+    }
+    return relativePath.replace(/^\.\//, "");
+}
+function isAllowedConductorMetadataPath(cwd, rawPath) {
+    const relativePath = normalizeRepoRelativePath(cwd, rawPath);
+    if (!relativePath)
+        return false;
+    if (isProtectedPlanningStatePath(relativePath))
+        return false;
+    const artifactKind = classifyConductorArtifactKind(relativePath);
+    const actionKind = actionKindForConductorArtifact(artifactKind);
+    return authorizeConductorAction({
+        phase: "autopilot-supervision",
+        laneKind: "main-conductor",
+        actionKind,
+        artifactKind,
+    }).allowed;
+}
+function describeConductorBlockedWrite(toolName, blockedPath, pathCount) {
+    if (pathCount === 0) {
+        const operationClass = isApplyPatchToolName(toolName) ? "apply_patch target extraction failed" : `${toolName} path`;
+        return `${operationClass} target <unresolved>; Main-root Conductor may write only workflow state/ledger/mailbox/handoff metadata`;
+    }
+    const operationClass = isApplyPatchToolName(toolName) ? "apply_patch target" : `${toolName} path`;
+    return `${operationClass} target ${blockedPath ?? "<unresolved>"} is not workflow state/ledger/mailbox/handoff metadata`;
+}
+const CONDUCTOR_BASH_MUTATION_COMMANDS = new Set([
+    "cp",
+    "mv",
+    "rm",
+    "touch",
+    "mkdir",
+    "rmdir",
+    "install",
+    "ln",
+    "chmod",
+    "chown",
+    "chgrp",
+    "truncate",
+    "sed",
+    "perl",
+    "dd",
+    "rsync",
+]);
+const CONDUCTOR_BASH_TRANSPARENT_WRAPPERS = new Set([
+    "builtin",
+    "noglob",
+]);
+const CONDUCTOR_BASH_DOWNLOADER_COMMANDS = new Set([
+    "curl",
+    "wget",
+]);
+const CONDUCTOR_BASH_COMPOUND_SYNTAX_WORDS = new Set([
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "until",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "in",
+    "{",
+    "}",
+    "(",
+    ")",
+]);
+const CONDUCTOR_BASH_OPTIONS_WITH_VALUES = new Set([
+    "-S",
+    "--suffix",
+    "-t",
+    "--target-directory",
+    "-m",
+    "--mode",
+    "-o",
+    "--owner",
+    "-g",
+    "--group",
+    "--reference",
+    "--preserve",
+    "--size",
+    "-if",
+    "if",
+    "-of",
+    "of",
+]);
+function extractConductorInterpreterWrites(command) {
+    const writes = [];
+    const scanCommand = normalizeShellLineContinuations(command);
+    let recognizedPythonOpenWrites = 0;
+    let recognizedPythonPathMutations = 0;
+    let recognizedPythonShutilMutations = 0;
+    for (const match of scanCommand.matchAll(/\bnode\b[\s\S]{0,520}\b(?:appendFileSync|writeFileSync|appendFile|writeFile|createWriteStream)\s*\(\s*(["'])([^"']+)\1/g)) {
+        const target = safeString(match[2]).trim();
+        writes.push({ runtime: "node", targets: target ? [target] : [], unresolved: !target });
+    }
+    if (/\bnode\b[\s\S]{0,520}\b(?:appendFileSync|writeFileSync|appendFile|writeFile|createWriteStream)\s*\(/.test(scanCommand)
+        && !writes.some((write) => write.runtime === "node")) {
+        writes.push({ runtime: "node", targets: [], unresolved: true });
+    }
+    for (const match of scanCommand.matchAll(/\bpython3?\b[\s\S]{0,520}\bopen\s*\(\s*(["'])([^"']+)\1\s*,\s*(["'])([^"']*[wax+][^"']*)\3/g)) {
+        const target = safeString(match[2]).trim();
+        writes.push({ runtime: "python", targets: target ? [target] : [], unresolved: !target });
+        recognizedPythonOpenWrites += 1;
+    }
+    for (const match of scanCommand.matchAll(/\bpython3?\b[\s\S]{0,520}\bPath\s*\(\s*(["'])([^"']+)\1\s*\)\s*\.\s*(?:write_text|write_bytes)\s*\(/g)) {
+        const target = safeString(match[2]).trim();
+        writes.push({ runtime: "python", targets: target ? [target] : [], unresolved: !target });
+        recognizedPythonPathMutations += 1;
+    }
+    for (const match of scanCommand.matchAll(/\bpython3?\b[\s\S]{0,520}\bPath\s*\(\s*(["'])([^"']+)\1\s*\)\s*\.\s*mkdir\s*\(/g)) {
+        const target = safeString(match[2]).trim();
+        writes.push({ runtime: "python", targets: target ? [target] : [], unresolved: !target });
+        recognizedPythonPathMutations += 1;
+    }
+    for (const match of scanCommand.matchAll(/\bpython3?\b[\s\S]{0,520}\bshutil\s*\.\s*(?:copyfile|copy|copy2|copytree|move)\s*\(\s*(["'])([^"']+)\1\s*,\s*(["'])([^"']+)\3/g)) {
+        const target = safeString(match[4]).trim();
+        writes.push({ runtime: "python", targets: target ? [target] : [], unresolved: !target });
+        recognizedPythonShutilMutations += 1;
+    }
+    const hasPythonRuntime = /\bpython3?\b/.test(scanCommand);
+    const pythonOpenWriteCalls = hasPythonRuntime
+        ? [...scanCommand.matchAll(/\bopen\s*\([^\n;)]*,\s*["'][^"']*[wax+][^"']*["']/g)].length
+        : 0;
+    const pythonPathMutationCalls = hasPythonRuntime
+        ? [...scanCommand.matchAll(/(?:^|[\n;])\s*(?:\([^\n;#]*\bPath\s*\([^\n;#]*\)[^\n;#]*\)|\bPath\s*\([^\n;#]*\))\s*\.\s*(?:write_text|write_bytes|mkdir)\s*\(/g)].length
+        : 0;
+    const pythonShutilMutationCalls = hasPythonRuntime
+        ? [...scanCommand.matchAll(/\bshutil\s*\.\s*(?:copyfile|copy|copy2|copytree|move)\s*\(/g)].length
+        : 0;
+    if (pythonOpenWriteCalls > recognizedPythonOpenWrites
+        || pythonPathMutationCalls > recognizedPythonPathMutations
+        || pythonShutilMutationCalls > recognizedPythonShutilMutations) {
+        writes.push({ runtime: "python", targets: [], unresolved: true });
+    }
+    return writes;
+}
+function hasUnresolvedConductorInterpreterWrite(command) {
+    return extractConductorInterpreterWrites(command).some((write) => write.unresolved || write.targets.length === 0);
+}
+function commandNameFromShellWord(word) {
+    const base = word.trim().split(/[\\/]/).pop() ?? word.trim();
+    return base.toLowerCase();
+}
+function isShellCommandSeparator(word) {
+    return word === "&&" || word === "||" || word === ";" || word === "&" || word === "|" || word === "|&";
+}
+function isShellGroupingSyntaxWord(word) {
+    return word === "(" || word === ")" || word === "{" || word === "}";
+}
+function isShellCommandTerminatorOrGroupClose(word) {
+    return isShellCommandSeparator(word) || word === ")" || word === "}";
+}
+function commandUsesTargetDirectoryOption(commandName) {
+    return commandName === "cp" || commandName === "mv" || commandName === "install" || commandName === "ln";
+}
+function isEnvironmentAssignmentWord(word) {
+    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(word);
+}
+function findSudoDispatchOperandIndex(words, startIndex) {
+    for (let index = startIndex; index < words.length; index += 1) {
+        const token = words[index] ?? "";
+        if (!token || token === "--")
+            continue;
+        if (isShellAssignmentWord(token))
+            continue;
+        if (token === "-u"
+            || token === "--user"
+            || token === "-g"
+            || token === "--group"
+            || token === "-h"
+            || token === "--host"
+            || token === "-p"
+            || token === "--prompt"
+            || token === "-C"
+            || token === "--close-from") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--user=")
+            || token.startsWith("--group=")
+            || token.startsWith("--host=")
+            || token.startsWith("--prompt=")
+            || token.startsWith("--close-from=")
+            || /^-[ughpC].+/.test(token)) {
+            continue;
+        }
+        if (token.startsWith("-"))
+            continue;
+        return index;
+    }
+    return null;
+}
+function findConductorWrapperOperandIndex(commandName, words, startIndex) {
+    switch (commandName) {
+        case "env":
+            return findEnvDispatchOperandIndex(words, startIndex);
+        case "command":
+            return findCommandDispatchOperandIndex(words, startIndex);
+        case "exec":
+            return findExecDispatchOperandIndex(words, startIndex);
+        case "sudo":
+            return findSudoDispatchOperandIndex(words, startIndex);
+        case "nohup":
+            return findCommandDispatchOperandIndex(words, startIndex);
+        case "time":
+            return findTimeDispatchOperandIndex(words, startIndex);
+        case "timeout":
+            return findTimeoutDispatchOperandIndex(words, startIndex);
+        case "nice":
+            return findNiceDispatchOperandIndex(words, startIndex);
+        case "stdbuf":
+            return findStdbufDispatchOperandIndex(words, startIndex);
+        default:
+            return undefined;
+    }
+}
+function isConductorDestinationOnlyMutationCommand(commandName) {
+    return commandName === "cp" || commandName === "install" || commandName === "ln" || commandName === "rsync";
+}
+function isConductorInstallDirectoryMode(words, commandIndex) {
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandTerminatorOrGroupClose(word))
+            break;
+        if (word === "-d" || word === "--directory")
+            return true;
+        if (word.startsWith("-") && !word.startsWith("--") && word.includes("d"))
+            return true;
+    }
+    return false;
+}
+function collectConductorDownloaderOutputTargets(commandName, words, commandIndex) {
+    const targets = [];
+    const explicitCurlTargets = [];
+    let sawOutputFlag = false;
+    let sawCurlRemoteName = false;
+    const curlOutputDirs = [];
+    const curlShortOptionsWithArgument = new Set("AbcCdDeEFHhKmMoPQrTuwxXyYz");
+    const isCurlRemoteNameWord = (word) => {
+        if (word === "--remote-name" || word === "--remote-name-all")
+            return true;
+        if (!word.startsWith("-") || word.startsWith("--"))
+            return false;
+        for (const option of word.slice(1)) {
+            if (option === "O")
+                return true;
+            if (curlShortOptionsWithArgument.has(option))
+                return false;
+        }
+        return false;
+    };
+    const pushTarget = (rawTarget) => {
+        const target = safeString(rawTarget).trim();
+        if (!target)
+            return;
+        if (commandName === "curl")
+            explicitCurlTargets.push(target);
+        else
+            targets.push(target);
+    };
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandTerminatorOrGroupClose(word))
+            break;
+        if (isEnvironmentAssignmentWord(word))
+            continue;
+        if (word === "--")
+            continue;
+        const inlineCurlOutput = commandName === "curl" ? word.match(/^--output=(.+)$/) : null;
+        const inlineWgetOutput = commandName === "wget" ? word.match(/^--(?:output-document|output-file|append-output)=(.+)$/) : null;
+        const inlineWgetDirectoryPrefix = commandName === "wget" ? word.match(/^--directory-prefix=(.+)$/) : null;
+        const inlineCurlOutputDir = commandName === "curl" ? word.match(/^--output-dir=(.+)$/) : null;
+        const inlineTarget = inlineCurlOutput?.[1] ?? inlineWgetOutput?.[1] ?? inlineWgetDirectoryPrefix?.[1];
+        if (inlineTarget !== undefined) {
+            sawOutputFlag = true;
+            pushTarget(inlineTarget);
+            continue;
+        }
+        if (inlineCurlOutputDir?.[1] !== undefined) {
+            curlOutputDirs.push(inlineCurlOutputDir[1]);
+            continue;
+        }
+        if (commandName === "curl" && isCurlRemoteNameWord(word)) {
+            sawCurlRemoteName = true;
+            continue;
+        }
+        if (commandName === "curl" && word.startsWith("-o") && word.length > 2) {
+            sawOutputFlag = true;
+            pushTarget(word.slice(2));
+            continue;
+        }
+        if (commandName === "wget" && (word.startsWith("-O") || word.startsWith("-o") || word.startsWith("-a")) && word.length > 2) {
+            sawOutputFlag = true;
+            pushTarget(word.slice(2));
+            continue;
+        }
+        const separateOutputFlag = (commandName === "curl" && (word === "-o" || word === "--output" || word === "--append-output"))
+            || (commandName === "wget" && (word === "-O" || word === "-o" || word === "-a" || word === "--output-document" || word === "--output-file" || word === "--append-output" || word === "-P" || word === "--directory-prefix"));
+        if (!separateOutputFlag) {
+            if (commandName === "curl" && word === "--output-dir") {
+                const nextWord = words[index + 1] ?? "";
+                if (nextWord && !isShellCommandTerminatorOrGroupClose(nextWord)) {
+                    curlOutputDirs.push(nextWord);
+                    index += 1;
+                }
+            }
+            continue;
+        }
+        sawOutputFlag = true;
+        const nextWord = words[index + 1] ?? "";
+        if (nextWord && !isShellCommandTerminatorOrGroupClose(nextWord)) {
+            pushTarget(nextWord);
+            index += 1;
+        }
+    }
+    if (commandName === "curl" && sawCurlRemoteName) {
+        sawOutputFlag = true;
+        targets.push(...(curlOutputDirs.length > 0 ? curlOutputDirs : ["."]));
     }
-    if (beadsCommand.present) {
-        return "Beads tracker command also performs an implementation write outside allowed planning metadata";
+    if (commandName === "curl" && explicitCurlTargets.length > 0) {
+        const outputDir = curlOutputDirs[curlOutputDirs.length - 1];
+        const effectiveTargets = outputDir
+            ? explicitCurlTargets.map((target) => (isAbsolute(target) ? target : join(outputDir, target)))
+            : explicitCurlTargets;
+        targets.push(...effectiveTargets);
     }
-    return "Bash write intent did not identify an allowed planning artifact path or metadata path";
+    return { sawOutputFlag, targets };
 }
-async function buildRalplanPreToolUseBoundaryOutput(payload, cwd, stateDir, resolvedSessionId) {
-    const sessionId = safeString(resolvedSessionId ?? readPayloadSessionId(payload)).trim();
-    const threadId = readPayloadThreadId(payload);
-    const activeState = await readActiveRalplanStateForPreToolUse(cwd, stateDir, sessionId, threadId);
+function isConductorSedInPlaceOption(word) {
+    return word === "-i" || word === "--in-place" || word.startsWith("-i") || word.startsWith("--in-place=") || /^-[^-]*i/.test(word);
+}
+function collectConductorSedTargets(words, commandIndex) {
+    const targets = [];
+    let sawInPlace = false;
+    let sawExplicitScript = false;
+    let consumedImplicitScript = false;
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandTerminatorOrGroupClose(word))
+            break;
+        if (isEnvironmentAssignmentWord(word))
+            continue;
+        if (word === "--") {
+            consumedImplicitScript = true;
+            continue;
+        }
+        if (isConductorSedInPlaceOption(word)) {
+            sawInPlace = true;
+            continue;
+        }
+        if (word === "-e" || word === "--expression" || word === "-f" || word === "--file") {
+            sawExplicitScript = true;
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-e") || word.startsWith("--expression=") || word.startsWith("-f") || word.startsWith("--file=")) {
+            sawExplicitScript = true;
+            continue;
+        }
+        if (word.startsWith("-"))
+            continue;
+        if (!sawExplicitScript && !consumedImplicitScript) {
+            consumedImplicitScript = true;
+            continue;
+        }
+        targets.push(word);
+    }
+    return sawInPlace ? targets : null;
+}
+function collectConductorPerlTargets(words, commandIndex) {
+    const targets = [];
+    let sawInPlace = false;
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandTerminatorOrGroupClose(word))
+            break;
+        if (isEnvironmentAssignmentWord(word))
+            continue;
+        if (word === "--")
+            continue;
+        if (word === "-i" || word.startsWith("-i") || /^-[^-]*i/.test(word)) {
+            sawInPlace = true;
+            continue;
+        }
+        if (word === "-e") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-e") || /^-[^-]*e/.test(word))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        targets.push(word);
+    }
+    return sawInPlace ? targets : null;
+}
+const CONDUCTOR_XARGS_LONG_OPTIONS_WITH_REQUIRED_VALUES = new Set([
+    "--arg-file",
+    "--delimiter",
+    "--max-args",
+    "--max-chars",
+    "--max-lines",
+    "--max-procs",
+    "--process-slot-var",
+]);
+const CONDUCTOR_XARGS_SHORT_OPTIONS_WITH_REQUIRED_VALUES = new Set(["a", "d", "E", "I", "L", "n", "P", "s"]);
+const CONDUCTOR_XARGS_SHORT_OPTIONS_WITH_OPTIONAL_ATTACHED_VALUES = new Set(["e", "i", "l"]);
+function conductorXargsOptionValueWordCount(words, optionIndex) {
+    const word = words[optionIndex] ?? "";
+    if (!word.startsWith("-") || word === "-")
+        return 0;
+    if (word.startsWith("--")) {
+        const [option, inlineValue] = word.split("=", 2);
+        return CONDUCTOR_XARGS_LONG_OPTIONS_WITH_REQUIRED_VALUES.has(option) && inlineValue === undefined ? 1 : 0;
+    }
+    const shortOptions = word.slice(1);
+    for (let offset = 0; offset < shortOptions.length; offset += 1) {
+        const option = shortOptions[offset] ?? "";
+        if (CONDUCTOR_XARGS_SHORT_OPTIONS_WITH_REQUIRED_VALUES.has(option)) {
+            if (offset < shortOptions.length - 1)
+                return 0;
+            return option === "I" && (words[optionIndex + 1] ?? "") === "{" && (words[optionIndex + 2] ?? "") === "}" ? 2 : 1;
+        }
+        if (CONDUCTOR_XARGS_SHORT_OPTIONS_WITH_OPTIONAL_ATTACHED_VALUES.has(option))
+            return 0;
+    }
+    return 0;
+}
+function collectConductorXargsMutationTargets(words, commandIndex) {
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandTerminatorOrGroupClose(word))
+            break;
+        if (word === "--")
+            continue;
+        if (word.startsWith("-")) {
+            index += conductorXargsOptionValueWordCount(words, index);
+            continue;
+        }
+        let commandWordIndex = index;
+        for (let unwrapCount = 0; unwrapCount < 8; unwrapCount += 1) {
+            const commandName = commandNameFromShellWord(words[commandWordIndex] ?? "");
+            if (CONDUCTOR_BASH_DOWNLOADER_COMMANDS.has(commandName) || CONDUCTOR_BASH_MUTATION_COMMANDS.has(commandName))
+                return [];
+            const wrapperOperandIndex = findConductorWrapperOperandIndex(commandName, words, commandWordIndex + 1);
+            if (wrapperOperandIndex === undefined)
+                return null;
+            if (wrapperOperandIndex === null)
+                return [];
+            commandWordIndex = wrapperOperandIndex;
+        }
+        return [];
+    }
+    return null;
+}
+function collectConductorMutationCommandTargets(commandName, words, commandIndex) {
+    const targets = [];
+    const positionalTargets = [];
+    const targetDirectoryTargets = [];
+    let sawTargetDirectory = false;
+    let positionalCount = 0;
+    let rsyncRemovesSourceFiles = false;
+    if (commandName === "sed")
+        return collectConductorSedTargets(words, commandIndex);
+    if (commandName === "perl")
+        return collectConductorPerlTargets(words, commandIndex);
+    const installDirectoryMode = commandName === "install" && isConductorInstallDirectoryMode(words, commandIndex);
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandTerminatorOrGroupClose(word))
+            break;
+        if (CONDUCTOR_BASH_COMPOUND_SYNTAX_WORDS.has(word))
+            continue;
+        if (isEnvironmentAssignmentWord(word))
+            continue;
+        if (commandName === "dd") {
+            const ofMatch = word.match(/^of=(.+)$/);
+            if (ofMatch)
+                targets.push(safeString(ofMatch[1]).trim());
+            continue;
+        }
+        if (word === "--")
+            continue;
+        if (commandName === "rsync" && word === "--remove-source-files") {
+            rsyncRemovesSourceFiles = true;
+            continue;
+        }
+        if (word.startsWith("--")) {
+            const [option, inlineValue] = word.split("=", 2);
+            if (option === "--target-directory" && commandUsesTargetDirectoryOption(commandName)) {
+                sawTargetDirectory = true;
+                if (inlineValue !== undefined) {
+                    const target = safeString(inlineValue).trim();
+                    if (target)
+                        targetDirectoryTargets.push(target);
+                }
+                else {
+                    const target = words[index + 1] ?? "";
+                    if (target && !isShellCommandTerminatorOrGroupClose(target))
+                        targetDirectoryTargets.push(target);
+                    index += 1;
+                }
+                continue;
+            }
+            if (CONDUCTOR_BASH_OPTIONS_WITH_VALUES.has(option) && inlineValue === undefined)
+                index += 1;
+            if ((option === "--backup" || option === "--suffix" || option === "--reference") && inlineValue) {
+                targets.push(inlineValue);
+            }
+            continue;
+        }
+        if (word === "-t" && commandUsesTargetDirectoryOption(commandName)) {
+            sawTargetDirectory = true;
+            const target = words[index + 1] ?? "";
+            if (target && !isShellCommandTerminatorOrGroupClose(target))
+                targetDirectoryTargets.push(target);
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-t") && word.length > 2 && commandUsesTargetDirectoryOption(commandName)) {
+            sawTargetDirectory = true;
+            targetDirectoryTargets.push(word.slice(2));
+            continue;
+        }
+        if (word.startsWith("-") && word.length > 1) {
+            if (CONDUCTOR_BASH_OPTIONS_WITH_VALUES.has(word))
+                index += 1;
+            continue;
+        }
+        positionalCount += 1;
+        if ((commandName === "chmod" || commandName === "chown" || commandName === "chgrp")
+            && positionalCount === 1) {
+            continue;
+        }
+        positionalTargets.push(word);
+    }
+    if (installDirectoryMode)
+        return [...targets, ...positionalTargets];
+    if (sawTargetDirectory) {
+        return commandName === "mv"
+            ? [...targets, ...targetDirectoryTargets, ...positionalTargets]
+            : [...targets, ...targetDirectoryTargets];
+    }
+    if (commandName === "rsync" && rsyncRemovesSourceFiles)
+        return [...targets, ...positionalTargets];
+    if (isConductorDestinationOnlyMutationCommand(commandName))
+        return [...targets, ...positionalTargets.slice(-1)];
+    return [...targets, ...positionalTargets];
+}
+function extractConductorBashMutations(command) {
+    const mutations = [];
+    for (const segment of splitShellCommandSegments(stripHeredocBodiesForCommandScan(command))) {
+        const words = tokenizeShellWords(segment);
+        let commandStart = true;
+        for (let index = 0; index < words.length; index += 1) {
+            const word = words[index] ?? "";
+            if (!word)
+                continue;
+            if (isShellCommandSeparator(word)) {
+                commandStart = true;
+                continue;
+            }
+            if (isShellGroupingSyntaxWord(word)) {
+                continue;
+            }
+            if (commandStart && isEnvironmentAssignmentWord(word))
+                continue;
+            if (commandStart && CONDUCTOR_BASH_COMPOUND_SYNTAX_WORDS.has(word))
+                continue;
+            if (commandStart && word.startsWith("-"))
+                continue;
+            if (!commandStart)
+                continue;
+            const commandName = commandNameFromShellWord(word);
+            if (CONDUCTOR_BASH_TRANSPARENT_WRAPPERS.has(commandName)) {
+                continue;
+            }
+            const wrapperOperandIndex = findConductorWrapperOperandIndex(commandName, words, index + 1);
+            if (wrapperOperandIndex !== undefined) {
+                if (wrapperOperandIndex === null) {
+                    mutations.push({ command: commandName, targets: [] });
+                    commandStart = false;
+                }
+                else {
+                    index = wrapperOperandIndex - 1;
+                }
+                continue;
+            }
+            if (CONDUCTOR_BASH_DOWNLOADER_COMMANDS.has(commandName)) {
+                const downloaderTargets = collectConductorDownloaderOutputTargets(commandName, words, index);
+                if (downloaderTargets.sawOutputFlag) {
+                    mutations.push({
+                        command: commandName,
+                        targets: downloaderTargets.targets,
+                    });
+                }
+            }
+            else if (commandName === "xargs") {
+                const xargsTargets = collectConductorXargsMutationTargets(words, index);
+                if (xargsTargets !== null)
+                    mutations.push({ command: commandName, targets: xargsTargets });
+            }
+            else if (CONDUCTOR_BASH_MUTATION_COMMANDS.has(commandName)) {
+                const mutationTargets = collectConductorMutationCommandTargets(commandName, words, index);
+                if (mutationTargets !== null)
+                    mutations.push({ command: commandName, targets: mutationTargets });
+            }
+            commandStart = false;
+        }
+    }
+    return mutations;
+}
+const CONDUCTOR_BASH_MAX_NESTING_DEPTH = 5;
+function evaluateConductorBashWrite(cwd, command, depth = 0) {
+    const commandWithHeredocBodies = normalizeShellLineContinuations(command);
+    const normalizedCommand = stripHeredocBodiesForCommandScan(commandWithHeredocBodies);
+    if (depth > CONDUCTOR_BASH_MAX_NESTING_DEPTH) {
+        return {
+            allowed: false,
+            blockedDetail: "Bash nested shell depth exceeded Main-root Conductor validation limits",
+        };
+    }
+    if (hasDynamicNestedShellExecution(normalizedCommand)) {
+        return {
+            allowed: false,
+            blockedDetail: "Bash nested shell execution is dynamic and cannot be validated for Main-root Conductor writes",
+        };
+    }
+    if (hasUnsafeUnquotedHeredocExpansion(commandWithHeredocBodies)) {
+        return {
+            allowed: false,
+            blockedDetail: "Bash unquoted heredoc expansion is not workflow state/ledger/mailbox/handoff metadata",
+        };
+    }
+    const shellMutations = extractConductorBashMutations(normalizedCommand);
+    if (shellMutations.length > 0) {
+        for (const mutation of shellMutations) {
+            if (mutation.targets.length === 0) {
+                return {
+                    allowed: false,
+                    blockedDetail: `Bash ${mutation.command} mutation target <unresolved>; Main-root Conductor may write only workflow state/ledger/mailbox/handoff metadata`,
+                };
+            }
+            const blockedTarget = mutation.targets.find((target) => !isAllowedConductorMetadataPath(cwd, target));
+            if (blockedTarget) {
+                return {
+                    allowed: false,
+                    blockedDetail: `Bash ${mutation.command} mutation target ${blockedTarget} is not workflow state/ledger/mailbox/handoff metadata`,
+                };
+            }
+        }
+    }
+    for (const functionBody of extractInvokedShellFunctionBodiesForStateScan(normalizedCommand)) {
+        const nestedDecision = evaluateConductorBashWrite(cwd, functionBody, depth + 1);
+        if (!nestedDecision.allowed)
+            return nestedDecision;
+    }
+    for (const nestedCommand of extractNestedShellCommandStringsForStateScan(normalizedCommand)) {
+        const nestedDecision = evaluateConductorBashWrite(cwd, nestedCommand, depth + 1);
+        if (!nestedDecision.allowed)
+            return nestedDecision;
+    }
+    for (const nestedCommand of extractNestedCommandSubstitutionStringsForStateScan(normalizedCommand)) {
+        const nestedDecision = evaluateConductorBashWrite(cwd, nestedCommand, depth + 1);
+        if (!nestedDecision.allowed)
+            return nestedDecision;
+    }
+    for (const nestedCommand of extractNestedProcessSubstitutionStringsForStateScan(normalizedCommand)) {
+        const nestedDecision = evaluateConductorBashWrite(cwd, nestedCommand, depth + 1);
+        if (!nestedDecision.allowed)
+            return nestedDecision;
+    }
+    const editorTargets = extractConductorEditorWriteTargets(commandWithHeredocBodies);
+    if (editorTargets.length > 0) {
+        const blockedTarget = editorTargets.find((target) => !isAllowedConductorMetadataPath(cwd, target));
+        if (blockedTarget) {
+            return {
+                allowed: false,
+                blockedDetail: `Bash editor mutation target ${blockedTarget} is not workflow state/ledger/mailbox/handoff metadata`,
+            };
+        }
+    }
+    if (commandHasDestructiveGitSubcommand(normalizedCommand)) {
+        return {
+            allowed: false,
+            blockedDetail: "Bash git worktree mutation is not workflow state/ledger/mailbox/handoff metadata",
+        };
+    }
+    if (commandHasPackageInstallIntent(normalizedCommand)) {
+        return {
+            allowed: false,
+            blockedDetail: "Bash package manager install is not workflow state/ledger/mailbox/handoff metadata",
+        };
+    }
+    const interpreterWrites = extractConductorInterpreterWrites(commandWithHeredocBodies);
+    for (const write of interpreterWrites) {
+        if (write.unresolved || write.targets.length === 0) {
+            return {
+                allowed: false,
+                blockedDetail: `Bash ${write.runtime} write target <unresolved>; Main-root Conductor may write only workflow state/ledger/mailbox/handoff metadata`,
+            };
+        }
+        const blockedTarget = write.targets.find((target) => !isAllowedConductorMetadataPath(cwd, target));
+        if (blockedTarget) {
+            return {
+                allowed: false,
+                blockedDetail: `Bash ${write.runtime} write target ${blockedTarget} is not workflow state/ledger/mailbox/handoff metadata`,
+            };
+        }
+    }
+    const hasGenericWriteIntent = commandHasDeepInterviewWriteIntent(commandWithHeredocBodies);
+    if (!hasGenericWriteIntent)
+        return { allowed: true };
+    const targets = extractDeepInterviewCommandWriteTargets(commandWithHeredocBodies);
+    const accountedShellOnlyWriteIntent = shellMutations.length > 0
+        && targets.length === 0
+        && shellMutations.every((mutation) => mutation.command === "sed" || mutation.command === "perl");
+    if (accountedShellOnlyWriteIntent)
+        return { allowed: true };
+    if (commandInvokesApplyPatch(normalizedCommand) && targets.length === 0) {
+        return {
+            allowed: false,
+            blockedDetail: "apply_patch target extraction failed for Main-root Conductor write",
+        };
+    }
+    if (targets.length === 0) {
+        return {
+            allowed: false,
+            blockedDetail: "Bash write intent target <unresolved>; Main-root Conductor may write only workflow state/ledger/mailbox/handoff metadata",
+        };
+    }
+    const blockedTarget = targets.find((target) => !isAllowedConductorMetadataPath(cwd, target));
+    if (blockedTarget) {
+        const operationClass = /\btee\s+(?:-a\s+)?/.test(commandWithHeredocBodies) ? "Bash tee write" : "Bash write";
+        return {
+            allowed: false,
+            blockedDetail: `${operationClass} target ${blockedTarget} is not workflow state/ledger/mailbox/handoff metadata`,
+        };
+    }
+    return { allowed: true };
+}
+function isAllowedConductorBashWrite(cwd, command) {
+    return evaluateConductorBashWrite(cwd, command).allowed;
+}
+function buildConductorBashBlockedDetail(cwd, command) {
+    return evaluateConductorBashWrite(cwd, command).blockedDetail
+        ?? "Bash write intent target <unresolved>; Main-root Conductor may write only workflow state/ledger/mailbox/handoff metadata";
+}
+export async function buildConductorPreToolUseWriteGuardOutput(payload, cwd, stateDir, resolvedSessionId) {
+    const activeState = await readActiveMainRootConductorStateForPreToolUse(payload, cwd, stateDir, resolvedSessionId);
     if (!activeState)
         return null;
     const toolName = safeString(payload.tool_name).trim();
     const command = readPreToolUseCommand(payload);
     const pathCandidates = readPreToolUsePathCandidates(payload);
     let blocked = false;
-    let blockedDetail = "implementation/write tools are blocked until an explicit execution handoff workflow is activated";
+    let blockedDetail = "Main-root Conductor write is not delegated";
     if (toolName === "Bash") {
-        blocked = !isAllowedRalplanBashWrite(cwd, command);
-        if (blocked) {
-            blockedDetail = buildRalplanBashBlockedDetail(cwd, command);
-        }
+        blocked = !isAllowedConductorBashWrite(cwd, command);
+        if (blocked)
+            blockedDetail = buildConductorBashBlockedDetail(cwd, command);
     }
     else if (PLANNING_MODE_IMPLEMENTATION_TOOL_NAMES.has(toolName)) {
         const toolPathCandidates = collectImplementationToolPathCandidates(payload, toolName, pathCandidates);
         if (toolPathCandidates.length === 0) {
             blocked = true;
-            blockedDetail = describeImplementationToolBlock(toolName, undefined, toolPathCandidates.length);
+            blockedDetail = describeConductorBlockedWrite(toolName, undefined, toolPathCandidates.length);
         }
         else {
-            const blockedPath = toolPathCandidates.find((candidate) => !isAllowedRalplanArtifactPath(cwd, candidate));
+            const blockedPath = toolPathCandidates.find((candidate) => !isAllowedConductorMetadataPath(cwd, candidate));
             blocked = blockedPath !== undefined;
             if (blockedPath !== undefined) {
-                blockedDetail = describeImplementationToolBlock(toolName, blockedPath, toolPathCandidates.length);
+                blockedDetail = describeConductorBlockedWrite(toolName, blockedPath, toolPathCandidates.length);
             }
         }
     }
     if (!blocked)
         return null;
-    const phase = formatPhase(activeState.current_phase ?? activeState.currentPhase, "planning");
-    const activeMode = safeString(activeState.mode).trim().toLowerCase();
-    const planningModeLabel = activeMode === "autopilot" ? "Autopilot planning" : "Ralplan";
-    const planningModeDescription = activeMode === "autopilot"
-        ? "Autopilot is supervising a planning phase"
-        : "Ralplan is consensus-planning mode";
     return {
         decision: "block",
-        reason: `${planningModeLabel} is active (phase: ${phase}); implementation/write tools are blocked until an explicit execution handoff workflow is activated; ${blockedDetail}.`,
+        reason: `Main-root Conductor mode is active (${activeState.mode} phase: ${formatPhase(activeState.phase, "active")}); direct plan/code writes are blocked and must be delegated; ${blockedDetail}.`,
         hookSpecificOutput: {
             hookEventName: "PreToolUse",
-            additionalContext: `${planningModeDescription}. `
-                + "Write only planning artifacts under `.omx/context/`, `.omx/plans/`, `.omx/specs/`, required `.omx/state/` files, or tracker metadata under `.beads/`. "
-                + "Do not edit implementation files or run implementation-focused writes from planning phases. "
-                + `To execute, first process an explicit handoff such as ${formatExecutionHandoffList(cwd)}, which must emit terminal planning state before implementation begins.`,
+            additionalContext: `${LEADER_CONDUCTOR_GOLDEN_RULE} `
+                + "Use specialized agents for source edits and plan/spec authorship. "
+                + `Main-root Conductor may write only orchestration metadata/transport/ledger artifacts under ${CONDUCTOR_ORCHESTRATION_METADATA_PREFIXES.join(", ")}; path location alone is not authorization for substantive deliverables. `
+                + "Autopilot rework and typed subagent/worker lanes are exempt from this guard.",
         },
     };
 }
-async function buildDeepInterviewPreToolUseBoundaryOutput(payload, cwd, stateDir, resolvedSessionId) {
-    const sessionId = safeString(resolvedSessionId ?? readPayloadSessionId(payload)).trim();
-    const threadId = readPayloadThreadId(payload);
-    const activeState = await readActiveDeepInterviewStateForPreToolUse(cwd, stateDir, sessionId, threadId);
-    if (!activeState)
-        return null;
-    const toolName = safeString(payload.tool_name).trim();
-    const command = readPreToolUseCommand(payload);
-    const pathCandidates = readPreToolUsePathCandidates(payload);
-    let blocked = false;
-    if (toolName === "Bash") {
-        blocked = !isAllowedDeepInterviewBashWrite(cwd, command);
+function isInPlaceEditorCommand(word, commandName) {
+    if (commandName === "sed")
+        return word === "--in-place" || /^--in-place(?:=.+)?$/.test(word) || /^-[^-\s]*i(?:.*)?$/.test(word);
+    if (commandName === "perl")
+        return word === "-i" || word === "-pi" || /^-pi(?:\..+)?$/.test(word) || /^-p.*i(?:\..+)?$/.test(word);
+    return false;
+}
+function collectInPlaceEditorWriteTargets(commandName, words, commandIndex) {
+    const targets = [];
+    let sawInPlaceEdit = false;
+    let awaitingOptionValue = false;
+    let consumedImplicitSedScript = commandName !== "sed";
+    for (let index = commandIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (!word || isShellCommandSeparator(word))
+            break;
+        if (CONDUCTOR_BASH_COMPOUND_SYNTAX_WORDS.has(word))
+            continue;
+        if (isEnvironmentAssignmentWord(word))
+            continue;
+        if (awaitingOptionValue) {
+            awaitingOptionValue = false;
+            continue;
+        }
+        if (word === "--") {
+            consumedImplicitSedScript = true;
+            continue;
+        }
+        if (word === "-e" || word === "-f" || word === "--expression" || word === "--file") {
+            awaitingOptionValue = true;
+            consumedImplicitSedScript = true;
+            continue;
+        }
+        if (word.startsWith("-e") || word.startsWith("-f") || word.startsWith("--expression=") || word.startsWith("--file=")) {
+            consumedImplicitSedScript = true;
+            continue;
+        }
+        if (isInPlaceEditorCommand(word, commandName)) {
+            sawInPlaceEdit = true;
+            continue;
+        }
+        if (word.startsWith("-"))
+            continue;
+        if (sawInPlaceEdit) {
+            if (commandName === "sed" && !consumedImplicitSedScript) {
+                consumedImplicitSedScript = true;
+                continue;
+            }
+            targets.push(word);
+        }
     }
-    else if (DEEP_INTERVIEW_IMPLEMENTATION_TOOL_NAMES.has(toolName)) {
-        const candidates = collectImplementationToolPathCandidates(payload, toolName, pathCandidates);
-        blocked = candidates.length === 0
-            || !candidates.every((candidate) => isAllowedDeepInterviewArtifactPath(cwd, candidate));
+    return targets;
+}
+function extractConductorEditorWriteTargets(command) {
+    const targets = [];
+    for (const segment of splitShellCommandSegments(stripHeredocBodiesForCommandScan(command))) {
+        const words = tokenizeShellWords(segment);
+        let commandStart = true;
+        for (let index = 0; index < words.length; index += 1) {
+            const word = words[index] ?? "";
+            if (!word)
+                continue;
+            if (isShellCommandSeparator(word)) {
+                commandStart = true;
+                continue;
+            }
+            if (isShellGroupingSyntaxWord(word))
+                continue;
+            if (commandStart && isEnvironmentAssignmentWord(word))
+                continue;
+            if (commandStart && CONDUCTOR_BASH_COMPOUND_SYNTAX_WORDS.has(word))
+                continue;
+            if (commandStart && word.startsWith("-"))
+                continue;
+            if (!commandStart)
+                continue;
+            const commandName = commandNameFromShellWord(word);
+            if (commandName === "sed" || commandName === "perl") {
+                targets.push(...collectInPlaceEditorWriteTargets(commandName, words, index));
+            }
+            commandStart = false;
+        }
     }
-    if (!blocked)
-        return null;
-    const phase = formatPhase(activeState.current_phase ?? activeState.currentPhase, "planning");
-    return {
-        decision: "block",
-        reason: `Deep-interview is active (phase: ${phase}); implementation/write tools are blocked until an explicit handoff workflow is activated.`,
-        hookSpecificOutput: {
-            hookEventName: "PreToolUse",
-            additionalContext: `Deep-interview is requirements/spec mode. Treat detailed user answers as interview/spec material, not implicit implementation authorization. You may write only deep-interview artifacts under \`.omx/context/\`, \`.omx/interviews/\`, \`.omx/specs/\`, or required \`.omx/state/\` files. To implement, first ask for or process an explicit transition such as \`$ralplan\`, \`$autopilot\`, ${formatExecutionHandoffList(cwd)}.`,
-        },
-    };
+    return targets;
 }
 function matchesSkillStopContext(entry, state, sessionId, threadId) {
     const entrySessionId = safeString(entry.session_id ?? state.session_id).trim();
@@ -4102,8 +8269,9 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     const eventSessionId = canonicalSessionId || nativeSessionId || undefined;
     const sessionIdForState = canonicalSessionId || nativeSessionId;
     let outputJson = null;
+    const typedAgentRolePayload = isTypedAgentRolePayload(payload);
     const isSubagentPromptSubmit = hookEventName === "UserPromptSubmit"
-        ? await isNativeSubagentHook(cwd, canonicalSessionId, nativeSessionId, threadId, safeString(currentSessionState?.native_session_id).trim())
+        ? typedAgentRolePayload || await isNativeSubagentHook(cwd, canonicalSessionId, nativeSessionId, threadId, safeString(currentSessionState?.native_session_id).trim())
         : false;
     const isSubagentStop = hookEventName === "Stop"
         ? (await Promise.all([...new Set([
@@ -4272,12 +8440,16 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     }
     else if (hookEventName === "PreToolUse") {
         const payloadSessionId = readPayloadSessionId(payload);
+        const rootPointerConflict = await readLiveRootSessionPointerConflict(stateDir, payloadSessionId);
         const preToolUseSessionId = payloadSessionId
             ? await resolveInternalSessionIdForPayload(cwd, payloadSessionId, stateDir)
             : "";
         outputJson = await buildDeepInterviewPreToolUseBoundaryOutput(payload, cwd, stateDir, preToolUseSessionId)
             ?? await buildRalplanPreToolUseBoundaryOutput(payload, cwd, stateDir, preToolUseSessionId)
+            ?? await buildPlanningRootPointerConflictPreToolUseOutput(payload, cwd, stateDir, rootPointerConflict)
+            ?? await buildConductorPreToolUseWriteGuardOutput(payload, cwd, stateDir, preToolUseSessionId)
             ?? await buildNativeSubagentCapacityCloseGuardOutput(payload, cwd, stateDir)
+            ?? buildMalformedPreToolUseBlockTestOutput(payload)
             ?? buildNativePreToolUseOutput(payload);
     }
     else if (hookEventName === "PostToolUse") {
@@ -4425,13 +8597,16 @@ async function buildOversizedStopActiveWorkflowOutput(cwd) {
         systemMessage: "OMX native Stop rejected oversized stdin before parsing; active current-session workflow state is present, so Stop is blocked instead of silently allowing termination.",
     };
 }
+function buildOversizedStopInactiveWorkflowOutput() {
+    return {};
+}
 async function buildOversizedStdinHookOutput(rawHookEventName, cwd) {
     const systemMessage = `OMX native hook rejected oversized stdin JSON before parsing; maxBytes=${MAX_NATIVE_STDIN_JSON_BYTES}.`;
     if (rawHookEventName === "PreToolUse") {
         return { systemMessage };
     }
     if (rawHookEventName === "Stop") {
-        return await buildOversizedStopActiveWorkflowOutput(cwd) ?? {};
+        return await buildOversizedStopActiveWorkflowOutput(cwd) ?? buildOversizedStopInactiveWorkflowOutput();
     }
     return {
         continue: false,
@@ -4482,6 +8657,28 @@ function isDispatchFailureTestTrigger() {
     return process.env.NODE_ENV === "test"
         && process.env.OMX_NATIVE_HOOK_TEST_THROW_DISPATCH === "1";
 }
+function buildMalformedPreToolUseBlockTestOutput(payload) {
+    if (process.env.NODE_ENV !== "test" || readHookEventName(payload) !== "PreToolUse")
+        return null;
+    switch (process.env.OMX_NATIVE_HOOK_TEST_MALFORMED_PRETOOL_BLOCK) {
+        case "legacy":
+            return {
+                decision: "block",
+                systemMessage: "This advisory text must not validate a malformed legacy PreToolUse block.",
+            };
+        case "deny":
+            return {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: "   ",
+                },
+                systemMessage: "This advisory text must not validate a malformed deny PreToolUse block.",
+            };
+        default:
+            return null;
+    }
+}
 function buildStopDispatchFailureOutput(error) {
     const detail = error instanceof Error ? error.message : String(error);
     const reason = "OMX native Stop hook failed before normal continuation handling. Continue once more, preserve runtime state, inspect the hook logs, and retry with a valid Stop JSON response.";