oh-my-codex 0.18.0 → 0.18.2

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

@@ -3,9 +3,9 @@ import { closeSync, existsSync, openSync, readFileSync, readSync } from "fs";
 import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
 import { extname, join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
-import { readModeState, readModeStateForActiveDecision, readModeStateForSession, updateModeState } from "../modes/base.js";
-import { extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, readVisibleSkillActiveStateForStateDir, } from "../state/skill-active.js";
-import { readSubagentSessionSummary, recordSubagentTurnForSession, } from "../subagents/tracker.js";
+import { readModeStateForActiveDecision, readModeStateForSession, updateModeState } from "../modes/base.js";
+import { SKILL_ACTIVE_STATE_FILE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, readVisibleSkillActiveStateForStateDir, } from "../state/skill-active.js";
+import { 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 { appendTeamEvent, readTeamLeaderAttention, readTeamManifestV2, readTeamPhase, writeTeamLeaderAttention, writeTeamPhase, } from "../team/state.js";
@@ -20,12 +20,14 @@ import { maybeNudgeLeaderForAllowedWorkerStop } from "./notify-hook/team-worker-
 import { resolveCodexExecutionSurface, } from "./codex-execution-surface.js";
 import { buildNativeHookEvent, } from "../hooks/extensibility/events.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 { readRunState } from "../runtime/run-state.js";
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { getRunContinuationSnapshot, shouldContinueRun } from "../runtime/run-loop.js";
+import { parseUltragoalSteeringDirective, steerUltragoal, } from "../ultragoal/artifacts.js";
 import { triagePrompt } from "../hooks/triage-heuristic.js";
 import { readTriageConfig } from "../hooks/triage-config.js";
 import { readTriageState, writeTriageState, shouldSuppressFollowup, promptSignature, } from "../hooks/triage-state.js";
@@ -173,18 +175,36 @@ async function nativeSubagentSessionStartBelongsToCanonicalSession(cwd, canonica
     return summary.allThreadIds.includes(parentThreadId);
 }
 async function isNativeSubagentHook(cwd, canonicalSessionId, nativeSessionId, threadId) {
-    const sessionId = canonicalSessionId.trim();
-    if (!sessionId)
-        return false;
-    const summary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
-    if (!summary)
-        return false;
     const candidateIds = [nativeSessionId, threadId]
         .map((value) => value.trim())
         .filter(Boolean);
     if (candidateIds.length === 0)
         return false;
-    return candidateIds.some((id) => summary.allSubagentThreadIds.includes(id));
+    const sessionId = canonicalSessionId.trim();
+    if (sessionId) {
+        const summary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
+        if (summary && candidateIds.some((id) => summary.allSubagentThreadIds.includes(id))) {
+            return true;
+        }
+    }
+    // Native Codex resume can report the child native session as the canonical
+    // session id before OMX reconciles it back to the owning session.  In that
+    // window the per-session summary lookup above misses the child and a
+    // subagent UserPromptSubmit can accidentally activate workflow keywords from
+    // quoted review context.  Fall back to the global tracking index so any known
+    // subagent thread is treated as subagent-scoped, regardless of the current
+    // hook payload's session-id mapping.
+    const trackingState = await readSubagentTrackingState(cwd).catch(() => null);
+    if (!trackingState)
+        return false;
+    return Object.values(trackingState.sessions).some((session) => (candidateIds.some((id) => session.threads[id]?.kind === "subagent")));
+}
+function shouldSuppressSubagentLifecycleHookDispatch() {
+    const config = getNotificationConfig();
+    if (config?.includeChildAgents === true)
+        return false;
+    const verbosity = getVerbosity(config);
+    return verbosity !== "agent" && verbosity !== "verbose";
 }
 async function recordIgnoredNativeSubagentSessionStart(cwd, canonicalSessionId, childSessionId, metadata, transcriptPath) {
     await appendToLog(cwd, {
@@ -286,6 +306,110 @@ function readPromptText(payload) {
     }
     return "";
 }
+function extractBalancedJsonObject(text, startIndex) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = startIndex; index < text.length; index++) {
+        const char = text[index];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "{")
+            depth += 1;
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(startIndex, index + 1);
+        }
+    }
+    return null;
+}
+function normalizePromptSteeringProposal(raw, prompt) {
+    const candidate = safeObject(raw);
+    const nested = candidate.omx_ultragoal_steer ?? candidate.ultragoal_steer ?? candidate.steering ?? candidate;
+    const proposal = parseUltragoalSteeringDirective(JSON.stringify(nested));
+    if (!proposal)
+        return null;
+    if (proposal.source !== "user_prompt_submit")
+        return null;
+    const normalized = prompt.trim().toLowerCase();
+    return {
+        ...proposal,
+        directiveText: proposal.directiveText ?? safeContextSnippet(prompt, 600),
+        promptSignature: proposal.promptSignature ?? promptSignature(normalized),
+        idempotencyKey: proposal.idempotencyKey ?? `user_prompt_submit:${promptSignature(normalized)}`,
+    };
+}
+function parseUserPromptUltragoalSteeringDirective(prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed)
+        return null;
+    const fenced = trimmed.match(/```(?:omx-ultragoal-steer|ultragoal-steer)\s*([\s\S]*?)```/i);
+    if (fenced?.[1]) {
+        try {
+            return normalizePromptSteeringProposal(JSON.parse(fenced[1]), prompt);
+        }
+        catch {
+            return null;
+        }
+    }
+    const label = trimmed.match(/(?:^|\n)\s*(?:OMX_ULTRAGOAL_STEER|omx\.ultragoal\.steer|omx ultragoal steer)\s*:\s*{/i);
+    if (label?.index !== undefined) {
+        const brace = trimmed.indexOf("{", label.index);
+        const json = brace >= 0 ? extractBalancedJsonObject(trimmed, brace) : null;
+        if (json) {
+            try {
+                return normalizePromptSteeringProposal(JSON.parse(json), prompt);
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const object = safeObject(parsed);
+            if ("omx_ultragoal_steer" in object || "ultragoal_steer" in object) {
+                return normalizePromptSteeringProposal(parsed, prompt);
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+async function applyUserPromptUltragoalSteering(cwd, prompt) {
+    const proposal = parseUserPromptUltragoalSteeringDirective(prompt);
+    if (!proposal)
+        return null;
+    try {
+        const result = await steerUltragoal(cwd, proposal);
+        const status = result.deduped ? "deduped" : result.accepted ? "accepted" : "rejected";
+        const reasons = result.rejectedReasons.length > 0 ? ` rejectedReasons=${result.rejectedReasons.join("; ")}` : "";
+        return [
+            `OMX native UserPromptSubmit applied bounded .omx/ultragoal steering for G002-cli-and-prompt-submit-bridge: ${status}.`,
+            `mutation=${result.audit.kind}; source=${result.audit.source}; targets=${result.audit.targetGoalIds.join(",") || "none"}; idempotencyKey=${result.audit.idempotencyKey ?? "none"}.${reasons}`,
+            "Only explicit structured steering directives are parsed; normal prose is ignored and cannot mutate .omx/ultragoal.",
+        ].join(" ");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `OMX native UserPromptSubmit rejected bounded .omx/ultragoal steering for G002-cli-and-prompt-submit-bridge: ${message}`;
+    }
+}
 function sanitizePayloadForHookContext(payload, hookEventName, canonicalSessionId = "") {
     const sanitized = { ...payload };
     if (hookEventName === "UserPromptSubmit") {
@@ -582,13 +706,12 @@ async function reopenRalphCompletionAuditBlock(block) {
     const nowIso = new Date().toISOString();
     const next = {
         ...block.state,
-        active: true,
-        current_phase: "verifying",
+        active: false,
+        current_phase: "complete",
         completion_audit_gate: "blocked",
         completion_audit_missing_reason: block.reason,
         completion_audit_blocked_at: nowIso,
     };
-    delete next.completed_at;
     await writeFile(block.path, JSON.stringify(next, null, 2));
 }
 async function readActiveRalphState(cwd, stateDir, preferredSessionId, ownerContext) {
@@ -1249,6 +1372,17 @@ function buildNativeOutsideTmuxTeamPromptBlockState(prompt, cwd, payload, sessio
 function buildSkillStateCliInstruction(mode, statePath) {
     return `skill: ${mode} activated and initial state initialized at ${statePath}; use CLI-first state updates via \`omx state write/read/clear --input '<json>' --json\`; use omx_state MCP only when explicit MCP compatibility is enabled.`;
 }
+function buildAutopilotPromptActivationNote(skillState) {
+    if (skillState?.initialized_mode !== "autopilot")
+        return null;
+    return [
+        "Autopilot protocol: the durable default chain is $deep-interview -> $ralplan -> $ultragoal (+ $team if needed) -> $code-review -> $ultraqa (deep-interview -> ralplan -> ultragoal -> code-review -> ultraqa).",
+        "Start/resume at current_phase=deep-interview unless the task is clear and bounded; if deep-interview is intentionally skipped, persist and state an explicit deep_interview_gate.skip_reason before moving to ralplan.",
+        "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.",
+    ].join(" ");
+}
 function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(), payload) {
     if (!prompt)
         return null;
@@ -1277,8 +1411,9 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
         ? "Ultrawork protocol: ground the task before editing, define pass/fail acceptance criteria, keep shared-file work local, and use direct-tool plus background evidence lanes only for truly independent work. Direct ultrawork provides lightweight verification only; Ralph owns persistence and the full verified-completion promise."
         : null;
     const ultragoalPromptActivationNote = match.skill === "ultragoal"
-        ? "Ultragoal protocol: use `omx ultragoal create-goals` / `complete-goals` / `checkpoint` for `.omx/ultragoal` artifacts, then use Codex goal model tools only from the active agent handoff (`get_goal`, `create_goal`, `update_goal`) and never overwrite a different active Codex goal."
+        ? "Ultragoal protocol: use `omx ultragoal create-goals` / `complete-goals` / `checkpoint` for `.omx/ultragoal` artifacts, then use Codex goal model tools only from the active agent handoff (`get_goal`, `create_goal`, `update_goal`) and never overwrite a different active Codex goal. Ultragoal does not call `/goal clear`; for multiple sequential ultragoal runs in one Codex session/thread, manually clear the completed Codex goal in the UI before creating the next aggregate goal."
         : null;
+    const autopilotPromptActivationNote = buildAutopilotPromptActivationNote(skillState);
     const combinedTransitionMessage = (() => {
         if (!skillState?.transition_message)
             return null;
@@ -1307,6 +1442,7 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
                 : null,
             promptPriorityMessage,
             ultragoalPromptActivationNote,
+            autopilotPromptActivationNote,
             skillState.initialized_mode && skillState.initialized_state_path
                 ? buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path)
                 : null,
@@ -1332,6 +1468,7 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
             deepInterviewPromptActivationNote,
             ultraworkPromptActivationNote,
             ultragoalPromptActivationNote,
+            autopilotPromptActivationNote,
             buildTeamRuntimeInstruction(cwd, payload),
             buildTeamHelpInstruction(cwd, payload),
             "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
@@ -1349,11 +1486,12 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
             deepInterviewPromptActivationNote,
             ultraworkPromptActivationNote,
             ultragoalPromptActivationNote,
+            autopilotPromptActivationNote,
             ralphPromptActivationNote,
             "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
         ].join(" ");
     }
-    return [detectedKeywordMessage, promptPriorityMessage, ultragoalPromptActivationNote, "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules."].filter(Boolean).join(" ");
+    return [detectedKeywordMessage, promptPriorityMessage, ultragoalPromptActivationNote, autopilotPromptActivationNote, "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules."].filter(Boolean).join(" ");
 }
 function parseTeamWorkerEnv(rawValue) {
     const match = /^([a-z0-9][a-z0-9-]{0,29})\/(worker-\d+)$/.exec(rawValue.trim());
@@ -1489,6 +1627,9 @@ function isStopExempt(payload) {
         || value.includes("limit"));
 }
 async function buildModeBasedStopOutput(mode, cwd, sessionId) {
+    if (await readCanonicalTerminalRunStateForStop(cwd, sessionId, mode)) {
+        return null;
+    }
     const state = await readModeStateForActiveDecision(mode, sessionId?.trim() || undefined, cwd);
     if (!state || !shouldContinueRun(state))
         return null;
@@ -1515,6 +1656,23 @@ function reportsAutoresearchGoalObjectiveMismatch(text) {
         && /\b(?:complete|completion|reconciliation)\b/i.test(text)
         && /objective mismatch/i.test(text);
 }
+function reportsBlockedPerformanceGoalObjectiveMismatch(state) {
+    const performanceState = safeObject(state);
+    const lastValidation = safeObject(performanceState.lastValidation);
+    if (safeString(performanceState.workflow) !== "performance-goal")
+        return false;
+    if (safeString(performanceState.status) !== "blocked")
+        return false;
+    if (safeString(lastValidation.status) !== "blocked")
+        return false;
+    const evidence = [
+        safeString(lastValidation.evidence),
+        safeString(lastValidation.message),
+        safeString(performanceState.evidence),
+        safeString(performanceState.message),
+    ].join(" ");
+    return /objective mismatch/i.test(evidence);
+}
 async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
     const ultragoal = await readJsonIfExists(join(cwd, ".omx", "ultragoal", "goals.json"));
     const aggregateCompletion = safeObject(ultragoal?.aggregateCompletion);
@@ -1532,7 +1690,8 @@ async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
                 `If get_goal returns a completed task-scoped objective for the same aggregate ultragoal plan, checkpoint ${goalId} with evidence naming ${goalId} plus .omx/ultragoal/goals.json or ledger.jsonl and pass final quality-gate JSON; OMX will reconcile the completed planned scope without mutating Codex goal state.`,
                 `If get_goal instead returns a different completed legacy objective and complete checkpointing fails, do not repeat --status complete in this thread.`,
                 `Record the non-terminal blocker with: omx ultragoal checkpoint --goal-id ${goalId} --status blocked --codex-goal-json '<different completed get_goal JSON or path>' --evidence '<completed legacy Codex goal blocks create_goal in this thread>'.`,
-                "Then continue this ultragoal from a fresh Codex thread in the same repo/worktree and create the intended goal there.",
+                `If get_goal itself is unavailable with a Codex DB/schema/context error such as "no such table: thread_goals", record an auditable safe-recovery blocker instead: omx ultragoal checkpoint --goal-id ${goalId} --status blocked --codex-goal-json '<unavailable get_goal error JSON or path>' --evidence '<get_goal unavailable due to Codex DB/schema/context error; safe recovery requires a working Codex goal context>'.`,
+                "Then continue only from a Codex goal context with no active/completed conflicting goal in the same repo/worktree and create the intended goal there.",
             ].join(" "),
         };
     }
@@ -1542,6 +1701,9 @@ async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
             continue;
         const state = await readJsonIfExists(join(performanceRoot, entry.name, "state.json"));
         const status = safeString(state?.status);
+        if (reportsBlockedPerformanceGoalObjectiveMismatch(state)) {
+            continue;
+        }
         if (state?.workflow === "performance-goal" && status && status !== "complete") {
             return {
                 workflow: "performance-goal",
@@ -1566,8 +1728,8 @@ async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
                 workflow: "autoresearch-goal",
                 command: `omx autoresearch-goal complete --slug ${safeString(mission.slug) || entry.name} --codex-goal-json '<get_goal JSON or path>'`,
                 remediation: [
-                    "If that command fails with a Codex goal objective mismatch after a fresh get_goal snapshot, do not repeat the same complete command blindly in this thread.",
-                    "Either retry with a correct fresh snapshot or record an explicit blocked verdict for this autoresearch-goal and continue it from a fresh Codex thread.",
+                    "If that command fails with a Codex goal objective mismatch after a refreshed get_goal snapshot, do not repeat the same complete command blindly in this thread.",
+                    "Either retry with a correct refreshed snapshot or record an explicit blocked verdict for this autoresearch-goal and continue from the explicit blocker path.",
                 ].join(" "),
             };
         }
@@ -1609,30 +1771,46 @@ async function buildGoalWorkflowReconciliationStopOutput(payload, cwd) {
         systemMessage,
     };
 }
-async function readTeamModeStateForStop(cwd, stateDir, sessionId) {
+function teamStateMatchesThreadForStop(state, threadId, options = {}) {
+    const normalizedThreadId = safeString(threadId).trim();
+    if (!normalizedThreadId)
+        return true;
+    const ownerThreadId = safeString(state.owner_codex_thread_id ?? state.thread_id).trim();
+    if (!ownerThreadId)
+        return options.requireOwnerThread !== true;
+    return ownerThreadId === normalizedThreadId;
+}
+async function readTeamModeStateForStop(cwd, stateDir, sessionId, threadId) {
     const normalizedSessionId = safeString(sessionId).trim();
-    if (!normalizedSessionId) {
-        return await readModeState("team", cwd);
-    }
+    if (!normalizedSessionId)
+        return null;
     const scopedState = await readStopSessionPinnedState("team-state.json", cwd, normalizedSessionId, stateDir);
-    if (scopedState)
-        return scopedState;
+    if (scopedState) {
+        return teamStateMatchesThreadForStop(scopedState, threadId)
+            ? { state: scopedState, scope: "session" }
+            : null;
+    }
     const rootState = await readJsonIfExists(join(stateDir, "team-state.json"));
     if (rootState?.active !== true)
         return null;
+    const teamName = safeString(rootState.team_name).trim();
+    if (!teamName)
+        return null;
     const ownerSessionId = safeString(rootState.session_id).trim();
-    if (ownerSessionId && ownerSessionId !== normalizedSessionId) {
+    if (!ownerSessionId || ownerSessionId !== normalizedSessionId)
         return null;
-    }
-    return rootState;
+    if (!teamStateMatchesThreadForStop(rootState, threadId, { requireOwnerThread: true }))
+        return null;
+    return { state: rootState, scope: "root" };
 }
-async function buildTeamStopOutput(cwd, sessionId) {
+async function buildTeamStopOutput(cwd, sessionId, threadId) {
     if (await readCanonicalTerminalRunStateForStop(cwd, sessionId, "team")) {
         return null;
     }
-    const teamState = await readTeamModeStateForStop(cwd, getBaseStateDir(cwd), sessionId);
-    if (teamState?.active !== true)
+    const teamStateForStop = await readTeamModeStateForStop(cwd, getBaseStateDir(cwd), sessionId, threadId);
+    if (!teamStateForStop || teamStateForStop.state.active !== true)
         return null;
+    const teamState = teamStateForStop.state;
     const teamName = safeString(teamState.team_name).trim();
     if (teamName) {
         const canonicalTeamDir = join(resolveCanonicalTeamStateRoot(cwd), "team", teamName);
@@ -1641,7 +1819,10 @@ async function buildTeamStopOutput(cwd, sessionId) {
         }
     }
     const coarsePhase = teamState.current_phase;
-    const canonicalPhase = teamName ? (await readTeamPhase(teamName, cwd))?.current_phase ?? coarsePhase : coarsePhase;
+    const canonicalPhaseState = teamName ? await readTeamPhase(teamName, cwd) : null;
+    if (teamStateForStop.scope === "root" && !canonicalPhaseState)
+        return null;
+    const canonicalPhase = canonicalPhaseState?.current_phase ?? coarsePhase;
     if (!isNonTerminalPhase(canonicalPhase))
         return null;
     return buildTeamStopOutputForPhase(teamName, formatPhase(canonicalPhase));
@@ -1724,6 +1905,137 @@ async function readStopSessionPinnedState(fileName, cwd, sessionId, stateDir) {
         : getStateFilePath(fileName, cwd, sessionId || undefined);
     return readJsonIfExists(statePath);
 }
+const DEEP_INTERVIEW_ALLOWED_WRITE_PREFIXES = [
+    ".omx/context",
+    ".omx/interviews",
+    ".omx/specs",
+    ".omx/state",
+];
+const DEEP_INTERVIEW_IMPLEMENTATION_TOOL_NAMES = new Set([
+    "Write",
+    "Edit",
+    "MultiEdit",
+    "apply_patch",
+    "ApplyPatch",
+]);
+function isActiveDeepInterviewPhase(state) {
+    if (!state || state.active !== true)
+        return false;
+    const mode = safeString(state.mode).trim();
+    if (mode && mode !== "deep-interview")
+        return false;
+    const phase = safeString(state.current_phase ?? state.currentPhase).trim().toLowerCase();
+    if (phase && (TERMINAL_MODE_PHASES.has(phase) || phase === "completing"))
+        return false;
+    return true;
+}
+function isAllowedDeepInterviewArtifactPath(cwd, rawPath) {
+    const trimmed = rawPath.trim().replace(/^['"]|['"]$/g, "");
+    if (!trimmed || trimmed.includes("\0"))
+        return false;
+    let relativePath;
+    try {
+        const absolute = resolve(cwd, trimmed);
+        relativePath = relative(cwd, absolute).replace(/\\/g, "/");
+    }
+    catch {
+        return false;
+    }
+    if (!relativePath || relativePath.startsWith("..") || relativePath.startsWith("/"))
+        return false;
+    return DEEP_INTERVIEW_ALLOWED_WRITE_PREFIXES.some((prefix) => (relativePath === prefix || relativePath.startsWith(`${prefix}/`)));
+}
+function readPreToolUseCommand(payload) {
+    const toolInput = safeObject(payload.tool_input);
+    return safeString(toolInput.command).trim();
+}
+function readPreToolUsePathCandidates(payload) {
+    const input = safeObject(payload.tool_input);
+    const candidates = [
+        input.file_path,
+        input.filePath,
+        input.path,
+        input.target_path,
+        input.targetPath,
+    ];
+    return candidates.map((candidate) => safeString(candidate).trim()).filter(Boolean);
+}
+function commandHasDeepInterviewWriteIntent(command) {
+    return /\bapply_patch\b/.test(command)
+        || /(?:^|[;&|]\s*)(?:cat|printf|echo)\b[\s\S]{0,240}>\s*[^\s&|;]+/.test(command)
+        || /\btee\s+(?:-a\s+)?[^\s&|;]+/.test(command)
+        || /\bsed\s+(?:[^\n;&|]*\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);
+}
+function extractDeepInterviewCommandWriteTargets(command) {
+    const targets = [];
+    for (const match of command.matchAll(/(?:^|[^>])>{1,2}\s*(["']?)([^\s&|;<>]+)\1/g)) {
+        const candidate = safeString(match[2]).trim();
+        if (candidate)
+            targets.push(candidate);
+    }
+    for (const match of command.matchAll(/\btee\s+(?:-a\s+)?(["']?)([^\s&|;<>]+)\1/g)) {
+        const candidate = safeString(match[2]).trim();
+        if (candidate)
+            targets.push(candidate);
+    }
+    return targets;
+}
+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 modeState = sessionId
+        ? await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId, stateDir)
+        : await readJsonIfExists(join(stateDir, "deep-interview-state.json"));
+    if (!isActiveDeepInterviewPhase(modeState) || !modeState)
+        return null;
+    if (!modeStateMatchesSkillStopContext(modeState, cwd, sessionId))
+        return null;
+    const canonicalState = sessionId
+        ? await readVisibleSkillActiveStateForStateDir(stateDir, sessionId)
+        : await readSkillActiveState(join(stateDir, SKILL_ACTIVE_STATE_FILE));
+    if (!canonicalState)
+        return modeState;
+    const hasActiveDeepInterviewSkill = listActiveSkills(canonicalState).some((entry) => (entry.skill === "deep-interview"
+        && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+    return hasActiveDeepInterviewSkill ? modeState : null;
+}
+async function buildDeepInterviewPreToolUseBoundaryOutput(payload, cwd, stateDir) {
+    const sessionId = readPayloadSessionId(payload);
+    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);
+    }
+    else if (DEEP_INTERVIEW_IMPLEMENTATION_TOOL_NAMES.has(toolName)) {
+        blocked = pathCandidates.length === 0
+            || !pathCandidates.every((candidate) => isAllowedDeepInterviewArtifactPath(cwd, candidate));
+    }
+    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`, `$ralph`, `$team`, or `$ultragoal`.",
+        },
+    };
+}
 function matchesSkillStopContext(entry, state, sessionId, threadId) {
     const entrySessionId = safeString(entry.session_id ?? state.session_id).trim();
     const entryThreadId = safeString(entry.thread_id ?? state.thread_id).trim();
@@ -2175,7 +2487,7 @@ async function maybeReturnRepeatableStopOutput(payload, stateDir, signature, out
 async function returnPersistentStopBlock(payload, stateDir, signatureKind, signatureValue, output, canonicalSessionId, options = { allowRepeatDuringStopHook: true }) {
     return await maybeReturnRepeatableStopOutput(payload, stateDir, buildRepeatableStopSignature(payload, signatureKind, signatureValue, canonicalSessionId), output, canonicalSessionId, options);
 }
-async function findCanonicalActiveTeamForSession(cwd, sessionId) {
+async function findCanonicalActiveTeamForSession(cwd, sessionId, threadId) {
     if (!sessionId.trim())
         return null;
     const teamsRoot = join(resolveCanonicalTeamStateRoot(cwd), "team");
@@ -2197,6 +2509,8 @@ async function findCanonicalActiveTeamForSession(cwd, sessionId) {
         const ownerSessionId = (manifest.leader?.session_id ?? "").trim();
         if (ownerSessionId && ownerSessionId !== sessionId.trim())
             continue;
+        if (!teamStateMatchesThreadForStop(manifest.leader, threadId))
+            continue;
         if (!isNonTerminalPhase(phaseState.current_phase))
             continue;
         return {
@@ -2206,18 +2520,18 @@ async function findCanonicalActiveTeamForSession(cwd, sessionId) {
     }
     return null;
 }
-async function resolveActiveTeamNameForStop(cwd, stateDir, sessionId) {
-    const directState = await readTeamModeStateForStop(cwd, stateDir, sessionId);
-    const directTeamName = safeString(directState?.team_name).trim();
-    if (directState?.active === true && directTeamName)
+async function resolveActiveTeamNameForStop(cwd, stateDir, sessionId, threadId) {
+    const directState = await readTeamModeStateForStop(cwd, stateDir, sessionId, threadId);
+    const directTeamName = safeString(directState?.state.team_name).trim();
+    if (directState?.state.active === true && directTeamName)
         return directTeamName;
-    const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, sessionId);
+    const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, sessionId, threadId);
     return canonicalTeam?.teamName ?? "";
 }
 async function maybeBuildReleaseReadinessFinalizeStopOutput(payload, cwd, stateDir, sessionId) {
     if (!sessionId)
         return { matched: false, output: null };
-    const teamName = await resolveActiveTeamNameForStop(cwd, stateDir, sessionId);
+    const teamName = await resolveActiveTeamNameForStop(cwd, stateDir, sessionId, readPayloadThreadId(payload));
     if (!teamName)
         return { matched: false, output: null };
     const explicitReleaseReadinessContext = hasReleaseReadinessMode(payload)
@@ -2373,7 +2687,7 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
             `OMX Ralph completion audit is missing required evidence (${ralphCompletionAuditBlock.reason}; state: ${blockingPath}).`,
             "Continue verification and do not report complete yet.",
             "Record machine-readable completion evidence before stopping:",
-            "- either set state.completion_audit = { passed: true, prompt_to_artifact_checklist: [...], verification_evidence: [...] }",
+            '- either set "completion_audit" on the Ralph state object, for example: omx state write --input \'{"mode":"ralph","active":false,"current_phase":"complete","completion_audit":{"passed":true,"prompt_to_artifact_checklist":["..."],"verification_evidence":["..."]}}\' --json',
             "- or set completion_audit_path / completion_audit_evidence_path to a repo-relative JSON file with those same fields.",
             "Markdown artifacts and flat top-level checklist/evidence fields are not accepted by the Ralph Stop gate.",
         ].join(" ");
@@ -2434,7 +2748,7 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
         const releaseReadinessFinalizeResult = await maybeBuildReleaseReadinessFinalizeStopOutput(payload, cwd, stateDir, canonicalSessionId);
         if (releaseReadinessFinalizeResult.matched)
             return releaseReadinessFinalizeResult.output;
-        const teamOutput = await buildTeamStopOutput(cwd, canonicalSessionId);
+        const teamOutput = await buildTeamStopOutput(cwd, canonicalSessionId, threadId);
         if (teamOutput) {
             return await returnPersistentStopBlock(payload, stateDir, "team-stop", safeString(teamOutput.stopReason), teamOutput, canonicalSessionId);
         }
@@ -2445,7 +2759,7 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
             }
             const canonicalTeam = await readCanonicalTerminalRunStateForStop(cwd, canonicalSessionId, "team")
                 ? null
-                : await findCanonicalActiveTeamForSession(cwd, canonicalSessionId);
+                : await findCanonicalActiveTeamForSession(cwd, canonicalSessionId, threadId);
             if (canonicalTeam) {
                 const canonicalTeamOutput = buildTeamStopOutputForPhase(canonicalTeam.teamName, canonicalTeam.phase);
                 const repeatedCanonicalTeamOutput = await returnPersistentStopBlock(payload, stateDir, "team-stop", `${canonicalTeam.teamName}|${canonicalTeam.phase}`, canonicalTeamOutput, canonicalSessionId);
@@ -2512,6 +2826,7 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     let skillState = null;
     let triageAdditionalContext = null;
     let goalWorkflowAdditionalContext = null;
+    let ultragoalSteeringAdditionalContext = null;
     const nativeSessionId = safeString(payload.session_id ?? payload.sessionId).trim();
     const threadId = safeString(payload.thread_id ?? payload.threadId).trim();
     const turnId = safeString(payload.turn_id ?? payload.turnId).trim();
@@ -2519,10 +2834,12 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     let canonicalSessionId = safeString(currentSessionState?.session_id).trim();
     let resolvedNativeSessionId = nativeSessionId;
     let skipCanonicalSessionStartContext = false;
+    let isSubagentSessionStart = false;
     if (hookEventName === "SessionStart" && nativeSessionId) {
         const transcriptPath = safeString(payload.transcript_path ?? payload.transcriptPath).trim();
         const subagentSessionStart = readNativeSubagentSessionStartMetadata(transcriptPath);
         if (subagentSessionStart && canonicalSessionId) {
+            isSubagentSessionStart = true;
             const belongsToCanonicalSession = await nativeSubagentSessionStartBelongsToCanonicalSession(cwd, canonicalSessionId, currentSessionState, subagentSessionStart);
             if (belongsToCanonicalSession) {
                 resolvedNativeSessionId = nativeSessionId;
@@ -2570,9 +2887,14 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
             ].filter(Boolean))]
             .map((candidateSessionId) => isNativeSubagentHook(cwd, candidateSessionId, nativeSessionId, threadId)))).some(Boolean)
         : false;
+    const suppressNoisySubagentLifecycleDispatch = (isSubagentSessionStart || isSubagentStop)
+        && shouldSuppressSubagentLifecycleHookDispatch();
     if (hookEventName === "UserPromptSubmit") {
         const prompt = readPromptText(payload);
         goalWorkflowAdditionalContext = await buildGoalWorkflowReconciliationPromptWarning(cwd, prompt).catch(() => null);
+        ultragoalSteeringAdditionalContext = prompt && !isSubagentPromptSubmit
+            ? await applyUserPromptUltragoalSteering(cwd, prompt).catch((error) => `OMX native UserPromptSubmit rejected bounded .omx/ultragoal steering for G002-cli-and-prompt-submit-bridge: ${error instanceof Error ? error.message : String(error)}`)
+            : null;
         if (prompt && !isSubagentPromptSubmit) {
             skillState = buildNativeOutsideTmuxTeamPromptBlockState(prompt, cwd, payload, sessionIdForState, threadId || undefined, turnId || undefined) ?? await recordSkillActivation({
                 stateDir,
@@ -2661,7 +2983,7 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         const reconcileHudForPromptSubmitFn = options.reconcileHudForPromptSubmitFn ?? reconcileHudForPromptSubmit;
         await reconcileHudForPromptSubmitFn(cwd, { sessionId: canonicalSessionId || sessionIdForState || undefined }).catch(() => { });
     }
-    if (omxEventName && !skipCanonicalSessionStartContext) {
+    if (omxEventName && !skipCanonicalSessionStartContext && !suppressNoisySubagentLifecycleDispatch) {
         const baseContext = buildBaseContext(cwd, payload, hookEventName, canonicalSessionId);
         if (resolvedNativeSessionId) {
             baseContext.native_session_id = resolvedNativeSessionId;
@@ -2698,7 +3020,12 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
             })
             : isSubagentPromptSubmit
                 ? null
-                : (buildAdditionalContextMessage(readPromptText(payload), skillState, cwd, payload) ?? goalWorkflowAdditionalContext ?? triageAdditionalContext);
+                : [
+                    buildAdditionalContextMessage(readPromptText(payload), skillState, cwd, payload),
+                    ultragoalSteeringAdditionalContext,
+                    goalWorkflowAdditionalContext,
+                    triageAdditionalContext,
+                ].filter((entry) => Boolean(entry)).join("\n\n") || null;
         if (additionalContext) {
             outputJson = {
                 hookSpecificOutput: {
@@ -2709,7 +3036,8 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         }
     }
     else if (hookEventName === "PreToolUse") {
-        outputJson = buildNativePreToolUseOutput(payload);
+        outputJson = await buildDeepInterviewPreToolUseBoundaryOutput(payload, cwd, stateDir)
+            ?? buildNativePreToolUseOutput(payload);
     }
     else if (hookEventName === "PostToolUse") {
         if (detectMcpTransportFailure(payload)) {