oh-my-codex 0.17.3 → 0.18.1

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

@@ -1,6 +1,6 @@
 import { execFileSync } from "child_process";
 import { closeSync, existsSync, openSync, readFileSync, readSync } from "fs";
-import { appendFile, mkdir, readFile, readdir, writeFile } from "fs/promises";
+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";
@@ -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";
@@ -38,6 +40,7 @@ const TEAM_STOP_BLOCKING_TASK_STATUSES = new Set(["pending", "in_progress", "blo
 const TEAM_WORKER_TERMINAL_RUN_STATES = new Set(["done", "complete", "completed", "failed", "stopped", "cancelled"]);
 const NATIVE_STOP_STATE_FILE = "native-stop-state.json";
 const ORDINARY_STOP_NO_PROGRESS_DEFAULT_MAX_REPEATS = 8;
+const RALPH_ORPHANED_STARTING_STALE_MS = 15 * 60_000;
 const ORDINARY_STOP_NO_PROGRESS_DEFAULT_IDLE_MS = 10 * 60_000;
 const ORDINARY_STOP_NO_PROGRESS_MAX_MESSAGE_LENGTH = 240;
 const STABLE_FINAL_RECOMMENDATION_PATTERNS = [
@@ -185,6 +188,13 @@ async function isNativeSubagentHook(cwd, canonicalSessionId, nativeSessionId, th
         return false;
     return candidateIds.some((id) => summary.allSubagentThreadIds.includes(id));
 }
+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, {
         event: "subagent_session_start_ignored",
@@ -285,6 +295,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") {
@@ -344,6 +458,47 @@ async function readActiveAutoresearchState(cwd, sessionId) {
 function isRalphStartingPhase(state) {
     return safeString(state.current_phase ?? state.currentPhase).trim().toLowerCase() === "starting";
 }
+function parseTimestampMs(value) {
+    const text = safeString(value).trim();
+    if (!text)
+        return null;
+    const ms = Date.parse(text);
+    return Number.isFinite(ms) ? ms : null;
+}
+function numericValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function hasRalphOwnerHint(state) {
+    return [
+        state.owner_omx_session_id,
+        state.owner_codex_session_id,
+        state.owner_codex_thread_id,
+        state.thread_id,
+        state.tmux_pane_id,
+        state.task_slug,
+    ].some((value) => safeString(value).trim() !== "");
+}
+async function isStaleOrphanedRalphStartingState(state, path, nowMs = Date.now()) {
+    if (!isRalphStartingPhase(state))
+        return false;
+    if (numericValue(state.iteration) !== 0)
+        return false;
+    if (hasRalphOwnerHint(state))
+        return false;
+    const timestampMs = parseTimestampMs(state.updated_at)
+        ?? parseTimestampMs(state.started_at)
+        ?? parseTimestampMs(state.created_at)
+        ?? await stat(path).then((info) => info.mtimeMs, () => null);
+    if (timestampMs === null)
+        return false;
+    return nowMs - timestampMs > RALPH_ORPHANED_STARTING_STALE_MS;
+}
 function hasValue(values, value) {
     return value !== "" && values.some((candidate) => candidate === value);
 }
@@ -410,6 +565,89 @@ async function hasConsistentRalphSkillActivation(stateDir, sessionId) {
         return false;
     return true;
 }
+function isShadowableRalphStartingSeed(state) {
+    if (state.active !== true)
+        return false;
+    if (!isRalphStartingPhase(state))
+        return false;
+    if (state.completion_audit || state.completionAudit)
+        return false;
+    const iteration = numericValue(state.iteration);
+    return iteration === null || iteration <= 0;
+}
+function hasPassingCompletedRalphAudit(state, cwd) {
+    if (!state)
+        return false;
+    if (state.mode && safeString(state.mode) !== "ralph")
+        return false;
+    if (!isRalphCompletePhase(state.current_phase ?? state.currentPhase))
+        return false;
+    if (state.active === true)
+        return false;
+    return evaluateRalphCompletionAuditEvidence(state, cwd).complete === true;
+}
+function shouldRetireShadowedRalphStartingSeed(seedState, completedState, cwd, ownerContext) {
+    if (!isShadowableRalphStartingSeed(seedState))
+        return false;
+    if (!hasPassingCompletedRalphAudit(completedState, cwd))
+        return false;
+    if (!completedState)
+        return false;
+    const completedSessionId = safeString(ownerContext?.completedSessionId ?? completedState.session_id).trim();
+    if (completedSessionId
+        && !activeRalphStateMatchesStopOwner(completedState, {
+            sessionId: completedSessionId,
+            payloadSessionId: safeString(ownerContext?.payloadSessionId).trim(),
+            threadId: safeString(ownerContext?.threadId).trim(),
+            currentNativeSessionId: safeString(ownerContext?.currentNativeSessionId).trim(),
+            tmuxPaneId: safeString(ownerContext?.tmuxPaneId).trim(),
+        })) {
+        return false;
+    }
+    const seedThreadId = safeString(seedState.owner_codex_thread_id ?? seedState.thread_id).trim();
+    const completedThreadId = safeString(completedState?.owner_codex_thread_id ?? completedState?.thread_id).trim();
+    const stopThreadId = safeString(ownerContext?.threadId).trim();
+    if (seedThreadId && completedThreadId && seedThreadId !== completedThreadId)
+        return false;
+    if (seedThreadId && stopThreadId && seedThreadId !== stopThreadId)
+        return false;
+    if (completedThreadId && stopThreadId && completedThreadId !== stopThreadId)
+        return false;
+    const seedPaneId = safeString(seedState.tmux_pane_id).trim();
+    const completedPaneId = safeString(completedState?.tmux_pane_id).trim();
+    const stopPaneId = safeString(ownerContext?.tmuxPaneId).trim();
+    if (seedPaneId && completedPaneId && seedPaneId !== completedPaneId)
+        return false;
+    if (seedPaneId && stopPaneId && seedPaneId !== stopPaneId)
+        return false;
+    if (completedPaneId && stopPaneId && completedPaneId !== stopPaneId)
+        return false;
+    const seedStartedAt = parseTimestampMs(seedState.started_at ?? seedState.startedAt);
+    const completedAt = parseTimestampMs(completedState?.completed_at ?? completedState?.completedAt);
+    if (completedAt === null)
+        return false;
+    if (seedStartedAt !== null && seedStartedAt > completedAt)
+        return false;
+    return true;
+}
+async function retireShadowedRalphStartingSeed(path, seedState, completedSessionId, completedPath, completedState) {
+    const nowIso = new Date().toISOString();
+    const completedAt = safeString(completedState.completed_at ?? completedState.completedAt).trim() || nowIso;
+    const next = {
+        ...seedState,
+        active: false,
+        current_phase: "complete",
+        completed_at: completedAt,
+        stop_reason: "shadowed_by_completed_canonical_ralph",
+        shadowed_by_completed_canonical_ralph: {
+            session_id: completedSessionId,
+            state_path: completedPath,
+            completed_at: completedAt,
+            reconciled_at: nowIso,
+        },
+    };
+    await writeFile(path, JSON.stringify(next, null, 2));
+}
 async function readRalphCompletionAuditBlockState(cwd, stateDir, preferredSessionId, ownerContext) {
     const [rawSessionInfo, usableSessionInfo] = await Promise.all([
         readSessionState(cwd),
@@ -457,13 +695,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) {
@@ -480,6 +717,12 @@ async function readActiveRalphState(cwd, stateDir, preferredSessionId, ownerCont
             safeString(preferredSessionId).trim(),
             currentOmxSessionId,
         ].filter(Boolean))];
+    const completedCanonicalPath = currentOmxSessionId
+        ? getStateFilePath("ralph-state.json", cwd, currentOmxSessionId)
+        : "";
+    const completedCanonicalState = completedCanonicalPath
+        ? await readJsonIfExists(completedCanonicalPath)
+        : null;
     // Ralph Stop stays authoritative-scope-only once the Stop payload is session-bound.
     // That is intentionally stricter than generic state MCP reads: do not scan sibling
     // session scopes or fall back to root when a current/explicit session is in play.
@@ -492,10 +735,27 @@ async function readActiveRalphState(cwd, stateDir, preferredSessionId, ownerCont
         }
         const sessionScopedPath = getStateFilePath("ralph-state.json", cwd, sessionId);
         const sessionScoped = await readJsonIfExists(sessionScopedPath);
-        if (sessionScoped?.active === true
-            && isRalphStartingPhase(sessionScoped)
-            && !(await isVisibleRalphActiveForSession(stateDir, sessionId))) {
-            continue;
+        if (sessionScoped?.active === true) {
+            if (currentOmxSessionId
+                && sessionId !== currentOmxSessionId
+                && completedCanonicalState
+                && shouldRetireShadowedRalphStartingSeed(sessionScoped, completedCanonicalState, cwd, {
+                    completedSessionId: currentOmxSessionId,
+                    payloadSessionId: safeString(ownerContext?.payloadSessionId).trim(),
+                    threadId: safeString(ownerContext?.threadId).trim(),
+                    currentNativeSessionId,
+                    tmuxPaneId: safeString(ownerContext?.tmuxPaneId).trim(),
+                })) {
+                await retireShadowedRalphStartingSeed(sessionScopedPath, sessionScoped, currentOmxSessionId, completedCanonicalPath, completedCanonicalState);
+                continue;
+            }
+            if (await isStaleOrphanedRalphStartingState(sessionScoped, sessionScopedPath)) {
+                continue;
+            }
+            if (isRalphStartingPhase(sessionScoped)
+                && !(await isVisibleRalphActiveForSession(stateDir, sessionId))) {
+                continue;
+            }
         }
         if (sessionScoped?.active === true
             && shouldContinueRun(sessionScoped)
@@ -1129,7 +1389,7 @@ 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 combinedTransitionMessage = (() => {
         if (!skillState?.transition_message)
@@ -1341,15 +1601,21 @@ 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;
     const phase = formatPhase(state.current_phase);
+    const systemMessage = mode === "autopilot" && phase.toLowerCase().replace(/_/g, "-") === "code-review"
+        ? "OMX autopilot is still active (phase: code-review). Run the required $code-review step before completing or clearing Autopilot state."
+        : `OMX ${mode} is still active (phase: ${phase}).`;
     return {
         decision: "block",
         reason: `OMX ${mode} is still active (phase: ${phase}); continue the task and gather fresh verification evidence before stopping.`,
         stopReason: `${mode}_${phase}`,
-        systemMessage: `OMX ${mode} is still active (phase: ${phase}).`,
+        systemMessage,
     };
 }
 export function looksLikeGoalCompletionPrompt(text) {
@@ -1359,6 +1625,28 @@ export function looksLikeGoalCompletionPrompt(text) {
         || /\b(?:ultragoal|performance[-\s]goal|autoresearch[-\s]goal)\b.{0,80}\b(?:complete|checkpoint|finish|close|mark)\b/i.test(text)
         || /(?:^|[.!?]\s+)(?:the\s+)?goal\s+(?:is\s+|now\s+|has\s+been\s+)?(?:complete|completed|finished|closed)(?:\s*(?:[.!?]|$)|\s*[:;]\s*\S|\s*[—–-]\s*\S)/i.test(text);
 }
+function reportsAutoresearchGoalObjectiveMismatch(text) {
+    return /\bautoresearch[-\s]goal\b/i.test(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);
@@ -1376,7 +1664,7 @@ 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.",
+                "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(" "),
         };
     }
@@ -1386,6 +1674,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",
@@ -1402,10 +1693,17 @@ async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
         const completion = await readJsonIfExists(join(autoresearchRoot, entry.name, "completion.json"));
         const completionVerdict = safeString(completion?.verdict);
         const completionPassed = completion?.passed === true || completionVerdict === "pass";
-        if (mission?.workflow === "autoresearch-goal" && status && status !== "complete" && completionPassed) {
+        if (mission?.workflow === "autoresearch-goal"
+            && status
+            && status !== "complete"
+            && completionPassed) {
             return {
                 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 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(" "),
             };
         }
     }
@@ -1431,6 +1729,9 @@ async function buildGoalWorkflowReconciliationStopOutput(payload, cwd) {
     const requirement = await findActiveGoalWorkflowReconciliationRequirement(cwd);
     if (!requirement)
         return null;
+    if (requirement.workflow === "autoresearch-goal" && reportsAutoresearchGoalObjectiveMismatch(lastAssistantMessage)) {
+        return null;
+    }
     const systemMessage = [
         `OMX ${requirement.workflow} requires get_goal snapshot reconciliation before completion; call get_goal and pass --codex-goal-json to ${requirement.command}.`,
         requirement.remediation,
@@ -1533,7 +1834,7 @@ function readPayloadSessionId(payload) {
     return safeString(payload.session_id ?? payload.sessionId).trim();
 }
 function readPayloadThreadId(payload) {
-    return safeString(payload.thread_id ?? payload.threadId).trim();
+    return safeString(payload.owner_codex_thread_id ?? payload.thread_id ?? payload.threadId).trim();
 }
 function readPayloadTurnId(payload) {
     return safeString(payload.turn_id ?? payload.turnId).trim();
@@ -1608,6 +1909,8 @@ async function readBlockingSkillForStop(cwd, stateDir, sessionId, threadId, requ
         const modeSnapshot = getRunContinuationSnapshot(modeState);
         if (modeSnapshot?.terminal === true)
             continue;
+        if (await shouldIgnoreSessionSkillBlockerForCanonicalInactiveRoot(cwd, stateDir, skill, sessionId, threadId))
+            continue;
         const phase = formatPhase(modeState.current_phase, formatPhase(visibleEntries.find((entry) => entry.skill === skill)?.phase, "planning"));
         if (TERMINAL_MODE_PHASES.has(phase.toLowerCase()) || phase === "completing") {
             continue;
@@ -1648,6 +1951,38 @@ function isTerminalOrInactiveModeState(state) {
     const phase = safeString(state.current_phase ?? state.currentPhase).trim().toLowerCase();
     return phase !== "" && TERMINAL_MODE_PHASES.has(phase);
 }
+function rootSkillStateHasNoActiveSkillForStopContext(rootState, skill, sessionId, threadId) {
+    if (!rootState)
+        return false;
+    return !listActiveSkills(rootState).some((entry) => (entry.skill === skill
+        && matchesSkillStopContext(entry, rootState, sessionId, threadId)));
+}
+function rootModeStateIsCanonicalForStopContext(state, cwd, sessionId, threadId) {
+    if (!modeStateMatchesSkillStopContext(state, cwd, sessionId))
+        return false;
+    const stateSessionId = safeString(state.owner_omx_session_id
+        ?? state.session_id
+        ?? state.codex_session_id
+        ?? state.owner_codex_session_id).trim();
+    if (sessionId && stateSessionId !== sessionId)
+        return false;
+    const stateThreadId = safeString(state.owner_codex_thread_id ?? state.thread_id).trim();
+    if (threadId && stateThreadId && stateThreadId !== threadId)
+        return false;
+    return true;
+}
+async function shouldIgnoreSessionSkillBlockerForCanonicalInactiveRoot(cwd, stateDir, skill, sessionId, threadId) {
+    const rootModeState = await readJsonIfExists(join(stateDir, `${skill}-state.json`));
+    if (!rootModeState)
+        return false;
+    if (!rootModeStateIsCanonicalForStopContext(rootModeState, cwd, sessionId, threadId))
+        return false;
+    if (!isTerminalOrInactiveModeState(rootModeState))
+        return false;
+    const { rootPath } = getSkillActiveStatePathsForStateDir(stateDir);
+    const rootSkillState = await readSkillActiveState(rootPath);
+    return rootSkillStateHasNoActiveSkillForStopContext(rootSkillState, skill, sessionId, threadId);
+}
 async function readSessionScopedModeStateForRootSkill(cwd, stateDir, skill, sessionIds) {
     for (const sessionId of sessionIds) {
         const state = await readStopSessionPinnedState(`${skill}-state.json`, cwd, sessionId, stateDir);
@@ -2173,7 +2508,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(" ");
@@ -2312,6 +2647,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();
@@ -2319,10 +2655,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;
@@ -2370,9 +2708,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,
@@ -2461,7 +2804,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;
@@ -2498,7 +2841,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: {