oh-my-codex 0.13.2 → 0.14.1

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

@@ -2,11 +2,12 @@ import { execFileSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, readdir, writeFile } from "fs/promises";
 import { join, resolve } from "path";
+import { pathToFileURL } from "url";
 import { readModeState, readModeStateForSession, updateModeState } from "../modes/base.js";
 import { listActiveSkills, readVisibleSkillActiveState, } from "../state/skill-active.js";
 import { readSubagentSessionSummary } from "../subagents/tracker.js";
 import { resolveCanonicalTeamStateRoot } from "../team/state-root.js";
-import { readUsableSessionState, reconcileNativeSessionStart } from "../hooks/session.js";
+import { isSessionStateUsable, readSessionState, readUsableSessionState, reconcileNativeSessionStart, } from "../hooks/session.js";
 import { appendTeamEvent, readTeamLeaderAttention, readTeamManifestV2, readTeamPhase, writeTeamLeaderAttention, writeTeamPhase, } from "../team/state.js";
 import { omxNotepadPath, omxProjectMemoryPath } from "../utils/paths.js";
 import { getStateFilePath, getStatePath } from "../mcp/state-paths.js";
@@ -16,8 +17,15 @@ import { buildNativePostToolUseOutput, buildNativePreToolUseOutput, detectMcpTra
 import { buildNativeHookEvent, } from "../hooks/extensibility/events.js";
 import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
 import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
+import { shellEscapeSingle } from "../hud/tmux.js";
 import { onSessionStart as buildWikiSessionStartContext } from "../wiki/lifecycle.js";
-const TERMINAL_RALPH_PHASES = new Set(["complete", "failed", "cancelled"]);
+import { readAutoresearchCompletionStatus, readAutoresearchModeState } from "../autoresearch/skill-validation.js";
+import { shouldContinueRun } from "../runtime/run-loop.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";
+import { isPendingDeepInterviewQuestionEnforcement } from "../question/deep-interview.js";
+import { resolveOmxCliEntryPath } from "../utils/paths.js";
 const TERMINAL_MODE_PHASES = new Set(["complete", "failed", "cancelled"]);
 const SKILL_STOP_BLOCKERS = new Set(["ralplan"]);
 const TEAM_TERMINAL_TASK_STATUSES = new Set(["completed", "failed"]);
@@ -29,6 +37,18 @@ const STABLE_FINAL_RECOMMENDATION_PATTERNS = [
     /^\s*decision\s*:\s*(?:yes|no|ship|hold|release|do not release|proceed|do not proceed)\b[^\n\r]*/im,
 ];
 const RELEASE_READINESS_FINALIZE_SYSTEM_MESSAGE = "OMX release-readiness detected a stable final recommendation with no active worker tasks; emit one concise final decision summary and finalize.";
+const EXECUTION_HANDOFF_PATTERNS = [
+    /^(?:好|好的|行|可以|那就|那现在)?[，,\s]*(?:开始|继续|直接)\s*(?:执行|优化|实现|修改|修复)(?=$|\s|[，,。.!！?？])/u,
+    /(?:按照|按|基于)(?:这个|上述|当前)?\s*(?:plan|计划|方案).{0,16}(?:开始|继续|直接)?\s*(?:执行|优化|实现|修改|修复)/u,
+    /(?:不用|别|不要).{0,6}讨论/u,
+    /\b(?:start|begin|go ahead(?: and)?|proceed(?: now)?)\s+(?:to\s+)?(?:implement|execute|apply|fix)\b/i,
+    /\b(?:according to|based on)\s+(?:the|this|that)\s+plan\b.{0,20}\b(?:start|begin|proceed(?: now)?|go ahead(?: and)?)\b/i,
+];
+const SHORT_FOLLOWUP_PRIORITY_PATTERNS = [
+    /^(?:继续|接着|然后|那就|那现在|还有(?:一个)?问题|这些优化都做了么|这些都做了么|现在呢|本轮|当前轮|这一轮)/u,
+    /(?:按照|按|基于)(?:这个|上述|当前)?(?:plan|计划|方案)/u,
+    /\b(?:follow up|latest request|this turn|current turn|newest request)\b/i,
+];
 function safeString(value) {
     return typeof value === "string" ? value : "";
 }
@@ -45,6 +65,34 @@ function safePositiveInteger(value) {
     }
     return null;
 }
+function normalizePromptSignalText(text) {
+    return text.trim().replace(/\s+/g, " ");
+}
+function looksLikeExecutionHandoffPrompt(prompt) {
+    const normalized = normalizePromptSignalText(prompt);
+    if (!normalized)
+        return false;
+    return EXECUTION_HANDOFF_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function looksLikeShortFollowupPrompt(prompt) {
+    const normalized = normalizePromptSignalText(prompt);
+    if (!normalized)
+        return false;
+    if (looksLikeExecutionHandoffPrompt(normalized))
+        return true;
+    if (normalized.length > 240)
+        return false;
+    return SHORT_FOLLOWUP_PRIORITY_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function buildPromptPriorityMessage(prompt) {
+    if (looksLikeExecutionHandoffPrompt(prompt)) {
+        return "Newest user input is an execution handoff for the current task. Treat it as authorization to act now against the latest approved plan/request. Do not restate the prior plan unless the user explicitly asks for a recap or status update.";
+    }
+    if (looksLikeShortFollowupPrompt(prompt)) {
+        return "Newest user input is a same-thread follow-up. Answer that latest follow-up directly and prefer it over older unresolved prompts when choosing what to do next.";
+    }
+    return null;
+}
 function readHookEventName(payload) {
     const raw = safeString(payload.hook_event_name
         ?? payload.hookEventName
@@ -88,24 +136,31 @@ function readPromptText(payload) {
     }
     return "";
 }
-function sanitizePayloadForHookContext(payload, hookEventName) {
-    if (hookEventName !== "UserPromptSubmit")
-        return payload;
+function sanitizePayloadForHookContext(payload, hookEventName, canonicalSessionId = "") {
     const sanitized = { ...payload };
-    delete sanitized.prompt;
-    delete sanitized.input;
-    delete sanitized.user_prompt;
-    delete sanitized.userPrompt;
-    delete sanitized.text;
+    if (hookEventName === "UserPromptSubmit") {
+        delete sanitized.prompt;
+        delete sanitized.input;
+        delete sanitized.user_prompt;
+        delete sanitized.userPrompt;
+        delete sanitized.text;
+        return sanitized;
+    }
+    if (hookEventName === "Stop") {
+        delete sanitized.stop_hook_active;
+        delete sanitized.stopHookActive;
+        delete sanitized.sessionId;
+        sanitized.session_id = canonicalSessionId.trim() || safeString(payload.session_id ?? payload.sessionId).trim();
+    }
     return sanitized;
 }
-function buildBaseContext(cwd, payload, hookEventName) {
+function buildBaseContext(cwd, payload, hookEventName, canonicalSessionId = "") {
     return {
         cwd,
         project_path: cwd,
         transcript_path: safeString(payload.transcript_path ?? payload.transcriptPath) || null,
         source: safeString(payload.source),
-        payload: sanitizePayloadForHookContext(payload, hookEventName),
+        payload: sanitizePayloadForHookContext(payload, hookEventName, canonicalSessionId),
     };
 }
 async function readJsonIfExists(path) {
@@ -126,39 +181,49 @@ function formatPhase(value, fallback = "active") {
     const phase = safeString(value).trim();
     return phase || fallback;
 }
+async function readActiveAutoresearchState(cwd, sessionId) {
+    const normalizedSessionId = sessionId?.trim() || undefined;
+    if (!normalizedSessionId)
+        return null;
+    const state = await readAutoresearchModeState(cwd, normalizedSessionId);
+    if (state?.active !== true)
+        return null;
+    if (!isNonTerminalPhase(state.current_phase ?? state.currentPhase ?? 'executing'))
+        return null;
+    return state;
+}
 async function readActiveRalphState(stateDir, preferredSessionId) {
-    const sessionInfo = await readUsableSessionState(resolve(stateDir, "..", ".."));
-    const currentOmxSessionId = safeString(sessionInfo?.session_id).trim();
+    const cwd = resolve(stateDir, "..", "..");
+    const [rawSessionInfo, usableSessionInfo] = await Promise.all([
+        readSessionState(cwd),
+        readUsableSessionState(cwd),
+    ]);
+    const currentOmxSessionId = safeString(usableSessionInfo?.session_id).trim();
+    const staleCurrentSessionId = rawSessionInfo && !isSessionStateUsable(rawSessionInfo, cwd)
+        ? safeString(rawSessionInfo.session_id).trim()
+        : "";
     const sessionCandidates = [...new Set([
             safeString(preferredSessionId).trim(),
             currentOmxSessionId,
         ].filter(Boolean))];
+    // 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.
     for (const sessionId of sessionCandidates) {
-        const sessionScoped = await readJsonIfExists(join(stateDir, "sessions", sessionId, "ralph-state.json"));
-        if (sessionScoped?.active === true
-            && !TERMINAL_RALPH_PHASES.has(safeString(sessionScoped.current_phase).trim().toLowerCase())) {
+        if (staleCurrentSessionId && sessionId === staleCurrentSessionId) {
+            continue;
+        }
+        const sessionScoped = await readStopSessionPinnedState("ralph-state.json", cwd, sessionId);
+        if (sessionScoped?.active === true && shouldContinueRun(sessionScoped)) {
             return sessionScoped;
         }
     }
     if (sessionCandidates.length > 0)
         return null;
     const direct = await readJsonIfExists(join(stateDir, "ralph-state.json"));
-    if (direct?.active === true && !TERMINAL_RALPH_PHASES.has(safeString(direct.current_phase).trim().toLowerCase())) {
+    if (direct?.active === true && shouldContinueRun(direct)) {
         return direct;
     }
-    const sessionsRoot = join(stateDir, "sessions");
-    if (!existsSync(sessionsRoot))
-        return null;
-    const entries = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const candidate = await readJsonIfExists(join(sessionsRoot, entry.name, "ralph-state.json"));
-        if (candidate?.active === true
-            && !TERMINAL_RALPH_PHASES.has(safeString(candidate.current_phase).trim().toLowerCase())) {
-            return candidate;
-        }
-    }
     return null;
 }
 function readParentPid(pid) {
@@ -249,38 +314,60 @@ function resolveSessionOwnerPid(payload) {
         return resolved;
     return process.pid;
 }
-async function ensureOmxGitignoreEntry(cwd) {
-    let repoRoot = "";
+function tryReadGitValue(cwd, args) {
     try {
-        repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        const value = execFileSync("git", args, {
             cwd,
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "ignore"],
             windowsHide: true,
         }).trim();
+        return value || null;
     }
     catch {
-        return { changed: false };
+        return null;
+    }
+}
+function isPathIgnoredByGit(cwd, path) {
+    try {
+        execFileSync("git", ["check-ignore", "-q", path], {
+            cwd,
+            stdio: ["ignore", "ignore", "ignore"],
+            windowsHide: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
     }
+}
+async function ensureOmxLocalIgnoreEntry(cwd) {
+    const repoRoot = tryReadGitValue(cwd, ["rev-parse", "--show-toplevel"]);
     if (!repoRoot)
         return { changed: false };
-    const gitignorePath = join(repoRoot, ".gitignore");
-    const existing = existsSync(gitignorePath)
-        ? await readFile(gitignorePath, "utf-8")
+    if (isPathIgnoredByGit(repoRoot, ".omx/")) {
+        return { changed: false };
+    }
+    const excludePathValue = tryReadGitValue(repoRoot, ["rev-parse", "--git-path", "info/exclude"]);
+    if (!excludePathValue)
+        return { changed: false };
+    const excludePath = resolve(repoRoot, excludePathValue);
+    const existing = existsSync(excludePath)
+        ? await readFile(excludePath, "utf-8")
         : "";
     const lines = existing.split(/\r?\n/).map((line) => line.trim());
     if (lines.includes(".omx/")) {
-        return { changed: false, gitignorePath };
+        return { changed: false, excludePath };
     }
     const next = `${existing}${existing.endsWith("\n") || existing.length === 0 ? "" : "\n"}.omx/\n`;
-    await writeFile(gitignorePath, next);
-    return { changed: true, gitignorePath };
+    await writeFile(excludePath, next);
+    return { changed: true, excludePath };
 }
 async function buildSessionStartContext(cwd, sessionId) {
     const sections = [];
-    const gitignoreResult = await ensureOmxGitignoreEntry(cwd);
-    if (gitignoreResult.changed) {
-        sections.push(`Added .omx/ to ${gitignoreResult.gitignorePath} to keep local OMX state out of source control.`);
+    const localIgnoreResult = await ensureOmxLocalIgnoreEntry(cwd);
+    if (localIgnoreResult.changed) {
+        sections.push(`Added .omx/ to ${localIgnoreResult.excludePath} to keep local OMX state out of source control without mutating tracked repo ignores.`);
     }
     const modeSummaries = [];
     for (const mode of ["ralph", "autopilot", "ultrawork", "ultraqa", "ralplan", "deep-interview", "team"]) {
@@ -366,13 +453,19 @@ async function buildSessionStartContext(cwd, sessionId) {
     }
     return sections.length > 0 ? sections.join("\n\n") : null;
 }
-function buildAdditionalContextMessage(prompt, skillState) {
+function buildDeepInterviewQuestionBridgeInstruction(cwd) {
+    const omxBin = resolveOmxCliEntryPath({ cwd }) || process.argv[1] || "omx";
+    const bridgeCommand = `${shellEscapeSingle(process.execPath)} ${shellEscapeSingle(omxBin)} question`;
+    return `Deep-interview must ask each interview round via \`omx question\`; do not fall back to \`request_user_input\` or plain-text questioning. If bare \`omx question\` is unavailable in this reused session, use the current-session CLI bridge command: \`${bridgeCommand}\`. Stop remains blocked while a deep-interview question obligation is pending.`;
+}
+function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd()) {
     if (!prompt)
         return null;
+    const promptPriorityMessage = buildPromptPriorityMessage(prompt);
     const matches = detectKeywords(prompt);
     const match = detectPrimaryKeyword(prompt);
     if (!match)
-        return null;
+        return promptPriorityMessage;
     const detectedKeywordMessage = matches.length > 1
         ? `OMX native UserPromptSubmit detected workflow keywords ${matches.map((entry) => `"${entry.keyword}" -> ${entry.skill}`).join(", ")}.`
         : `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}.`;
@@ -386,6 +479,9 @@ function buildAdditionalContextMessage(prompt, skillState) {
     const ralphPromptActivationNote = skillState?.initialized_mode === "ralph"
         ? "Prompt-side `$ralph` activation seeds Ralph workflow state only; it does not invoke `omx ralph`. Use `omx ralph --prd ...` only when you explicitly want the PRD-gated CLI startup path."
         : null;
+    const deepInterviewPromptActivationNote = skillState?.initialized_mode === "deep-interview"
+        ? buildDeepInterviewQuestionBridgeInstruction(cwd)
+        : null;
     const combinedTransitionMessage = (() => {
         if (!skillState?.transition_message)
             return null;
@@ -400,6 +496,7 @@ function buildAdditionalContextMessage(prompt, skillState) {
         return [
             `OMX native UserPromptSubmit denied workflow keyword "${match.keyword}" -> ${match.skill}.`,
             skillState.transition_error,
+            promptPriorityMessage,
             'Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.',
         ].join(' ');
     }
@@ -411,6 +508,7 @@ function buildAdditionalContextMessage(prompt, skillState) {
             deferredSkills.length > 0
                 ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
                 : null,
+            promptPriorityMessage,
             skillState.initialized_mode && skillState.initialized_state_path
                 ? `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`
                 : null,
@@ -431,7 +529,9 @@ function buildAdditionalContextMessage(prompt, skillState) {
             deferredSkills.length > 0
                 ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
                 : null,
+            promptPriorityMessage,
             initializedStateMessage,
+            deepInterviewPromptActivationNote,
             "Use the durable OMX team runtime via `omx team ...` for coordinated execution; do not replace it with in-process fanout.",
             "If you need runtime syntax, run `omx team --help` yourself.",
             "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
@@ -444,12 +544,14 @@ function buildAdditionalContextMessage(prompt, skillState) {
             deferredSkills.length > 0
                 ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
                 : null,
+            promptPriorityMessage,
             `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`,
+            deepInterviewPromptActivationNote,
             ralphPromptActivationNote,
             "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
         ].join(" ");
     }
-    return `${detectedKeywordMessage} Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.`;
+    return [detectedKeywordMessage, promptPriorityMessage, "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());
@@ -549,7 +651,7 @@ async function buildModeBasedStopOutput(mode, cwd, sessionId) {
     const state = sessionId
         ? await readModeStateForSession(mode, sessionId, cwd)
         : await readModeState(mode, cwd);
-    if (state?.active !== true || !isNonTerminalPhase(state.current_phase))
+    if (!state || !shouldContinueRun(state))
         return null;
     const phase = formatPhase(state.current_phase);
     return {
@@ -737,6 +839,42 @@ async function readStopAutoNudgePhase(cwd, sessionId, threadId) {
     const modePhase = safeString(modeState.current_phase).trim().toLowerCase();
     return modePhase === "intent-first" ? "planning" : "";
 }
+async function buildDeepInterviewQuestionStopOutput(cwd, sessionId, threadId) {
+    const modeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId);
+    if (!modeState)
+        return null;
+    const questionEnforcement = safeObject(modeState.question_enforcement);
+    const hasPendingQuestionObligation = isPendingDeepInterviewQuestionEnforcement(questionEnforcement);
+    if (modeState.active !== true && !hasPendingQuestionObligation)
+        return null;
+    const phase = formatPhase(modeState.current_phase, "planning");
+    if (TERMINAL_MODE_PHASES.has(phase.toLowerCase()) || phase === "completing") {
+        return null;
+    }
+    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+    if (canonicalState) {
+        const blocker = listActiveSkills(canonicalState).find((entry) => (entry.skill === "deep-interview"
+            && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
+        if (!blocker)
+            return null;
+    }
+    if (!hasPendingQuestionObligation) {
+        return null;
+    }
+    const obligationId = safeString(questionEnforcement.obligation_id).trim();
+    if (!obligationId)
+        return null;
+    const systemMessage = `OMX deep-interview is still active (phase: ${phase}) and requires a structured question via omx question before stopping.`;
+    return {
+        obligationId,
+        output: {
+            decision: "block",
+            reason: `Deep interview is still active (phase: ${phase}) and has a pending structured question obligation; use \`omx question\` before stopping.`,
+            stopReason: "deep_interview_question_required",
+            systemMessage,
+        },
+    };
+}
 function resolveRepeatableStopSessionId(payload, canonicalSessionId) {
     return canonicalSessionId?.trim() || readPayloadSessionId(payload) || "";
 }
@@ -807,8 +945,8 @@ async function maybeReturnRepeatableStopOutput(payload, stateDir, signature, out
     await persistNativeStopSignature(stateDir, payload, signature, canonicalSessionId);
     return output;
 }
-async function returnPersistentStopBlock(payload, stateDir, signatureKind, signatureValue, output, canonicalSessionId) {
-    return await maybeReturnRepeatableStopOutput(payload, stateDir, buildRepeatableStopSignature(payload, signatureKind, signatureValue, canonicalSessionId), output, canonicalSessionId, { allowRepeatDuringStopHook: true });
+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) {
     if (!sessionId.trim())
@@ -979,6 +1117,20 @@ async function buildStopHookOutput(payload, cwd, stateDir) {
     const threadId = readPayloadThreadId(payload);
     const ralphState = await readActiveRalphState(stateDir, canonicalSessionId);
     if (!ralphState) {
+        const autoresearchState = await readActiveAutoresearchState(cwd, canonicalSessionId);
+        if (autoresearchState) {
+            const completion = await readAutoresearchCompletionStatus(cwd, canonicalSessionId.trim());
+            if (!completion.complete) {
+                const currentPhase = safeString(autoresearchState.current_phase ?? autoresearchState.currentPhase).trim() || 'executing';
+                const systemMessage = `OMX autoresearch is still active (phase: ${currentPhase}); continue until validator evidence is complete before stopping.`;
+                return await maybeReturnRepeatableStopOutput(payload, stateDir, buildRepeatableStopSignature(payload, 'autoresearch-stop', `${currentPhase}|${completion.reason}`, canonicalSessionId), {
+                    decision: 'block',
+                    reason: systemMessage,
+                    stopReason: `autoresearch_${currentPhase}`,
+                    systemMessage,
+                }, canonicalSessionId, { allowRepeatDuringStopHook: true });
+            }
+        }
         const teamWorkerOutput = await buildTeamWorkerStopOutput(cwd);
         if (hasTeamWorkerContext() && teamWorkerOutput)
             return teamWorkerOutput;
@@ -988,7 +1140,7 @@ async function buildStopHookOutput(payload, cwd, stateDir) {
         }
         const ultraworkOutput = await buildModeBasedStopOutput("ultrawork", cwd, canonicalSessionId);
         if (ultraworkOutput) {
-            return await returnPersistentStopBlock(payload, stateDir, "ultrawork-stop", safeString(ultraworkOutput.stopReason), ultraworkOutput, canonicalSessionId);
+            return await returnPersistentStopBlock(payload, stateDir, "ultrawork-stop", safeString(ultraworkOutput.stopReason), ultraworkOutput, canonicalSessionId, { allowRepeatDuringStopHook: false });
         }
         const ultraqaOutput = await buildModeBasedStopOutput("ultraqa", cwd, canonicalSessionId);
         if (ultraqaOutput) {
@@ -1002,6 +1154,10 @@ async function buildStopHookOutput(payload, cwd, stateDir) {
             return await returnPersistentStopBlock(payload, stateDir, "team-stop", safeString(teamOutput.stopReason), teamOutput, canonicalSessionId);
         }
         if (canonicalSessionId) {
+            const deepInterviewQuestionOutput = await buildDeepInterviewQuestionStopOutput(cwd, canonicalSessionId, threadId);
+            if (deepInterviewQuestionOutput) {
+                return await returnPersistentStopBlock(payload, stateDir, "deep-interview-question-stop", deepInterviewQuestionOutput.obligationId, deepInterviewQuestionOutput.output, canonicalSessionId);
+            }
             const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, canonicalSessionId);
             if (canonicalTeam) {
                 const canonicalTeamOutput = buildTeamStopOutputForPhase(canonicalTeam.teamName, canonicalTeam.phase);
@@ -1046,21 +1202,36 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     await mkdir(stateDir, { recursive: true });
     const omxEventName = mapCodexHookEventToOmxEvent(hookEventName);
     let skillState = null;
+    let triageAdditionalContext = 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();
-    let canonicalSessionId = safeString((await readUsableSessionState(cwd))?.session_id).trim();
+    const currentSessionState = await readUsableSessionState(cwd);
+    let canonicalSessionId = safeString(currentSessionState?.session_id).trim();
+    let resolvedNativeSessionId = nativeSessionId;
     if (hookEventName === "SessionStart" && nativeSessionId) {
         const sessionState = await reconcileNativeSessionStart(cwd, nativeSessionId, {
             pid: options.sessionOwnerPid ?? resolveSessionOwnerPid(payload),
         });
         canonicalSessionId = safeString(sessionState.session_id).trim();
+        resolvedNativeSessionId = safeString(sessionState.native_session_id).trim() || nativeSessionId;
     }
     else if (!canonicalSessionId) {
-        canonicalSessionId = safeString((await readUsableSessionState(cwd))?.session_id).trim();
+        canonicalSessionId = safeString(currentSessionState?.session_id).trim();
+    }
+    if (hookEventName === "Stop") {
+        const stopCanonicalSessionId = await resolveInternalSessionIdForPayload(cwd, readPayloadSessionId(payload));
+        if (stopCanonicalSessionId) {
+            canonicalSessionId = stopCanonicalSessionId;
+        }
+        if (canonicalSessionId && safeString(currentSessionState?.session_id).trim() === canonicalSessionId) {
+            resolvedNativeSessionId =
+                safeString(currentSessionState?.native_session_id).trim() || resolvedNativeSessionId;
+        }
     }
     const eventSessionId = canonicalSessionId || nativeSessionId || undefined;
     const sessionIdForState = canonicalSessionId || nativeSessionId;
+    let outputJson = null;
     if (hookEventName === "UserPromptSubmit") {
         const prompt = readPromptText(payload);
         if (prompt) {
@@ -1072,13 +1243,85 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
                 turnId,
             });
         }
-        await reconcileHudForPromptSubmit(cwd).catch(() => { });
+        // --- Triage classifier (advisory-only, non-keyword prompts) ---
+        if (prompt && skillState === null) {
+            try {
+                if (readTriageConfig().enabled) {
+                    const normalized = prompt.trim().toLowerCase();
+                    const previous = readTriageState({ cwd, sessionId: sessionIdForState || null });
+                    const suppress = shouldSuppressFollowup({
+                        previous,
+                        currentPrompt: normalized,
+                        currentHasKeyword: false,
+                    });
+                    if (!suppress) {
+                        const decision = triagePrompt(prompt);
+                        const nowIso = new Date().toISOString();
+                        const effectiveTurnId = turnId || nowIso;
+                        if (decision.lane === "HEAVY") {
+                            triageAdditionalContext =
+                                "OMX native UserPromptSubmit triage detected a multi-step goal with no workflow keyword. This is advisory prompt-routing context only; it did not activate autopilot or initialize workflow state. Prefer the existing autopilot-style workflow if AGENTS.md/runtime conditions allow it, unless newer user context narrows or opts out.";
+                            const newState = {
+                                version: 1,
+                                last_triage: {
+                                    lane: "HEAVY",
+                                    destination: "autopilot",
+                                    reason: decision.reason,
+                                    prompt_signature: promptSignature(normalized),
+                                    turn_id: effectiveTurnId,
+                                    created_at: nowIso,
+                                },
+                                suppress_followup: true,
+                            };
+                            writeTriageState({ cwd, sessionId: sessionIdForState || null, state: newState });
+                        }
+                        else if (decision.lane === "LIGHT") {
+                            if (decision.destination === "explore") {
+                                triageAdditionalContext =
+                                    "OMX native UserPromptSubmit triage detected a read-only/question-shaped request with no workflow keyword. This is advisory prompt-routing context only. Prefer the explore role surface rather than escalating to autopilot.";
+                            }
+                            else if (decision.destination === "executor") {
+                                triageAdditionalContext =
+                                    "OMX native UserPromptSubmit triage detected a narrow edit-shaped request with no workflow keyword. This is advisory prompt-routing context only. Prefer the executor role surface rather than autopilot.";
+                            }
+                            else if (decision.destination === "designer") {
+                                triageAdditionalContext =
+                                    "OMX native UserPromptSubmit triage detected a visual/style request with no workflow keyword. This is advisory prompt-routing context only. Prefer the designer role surface.";
+                            }
+                            if (triageAdditionalContext !== null) {
+                                const dest = decision.destination;
+                                const newState = {
+                                    version: 1,
+                                    last_triage: {
+                                        lane: "LIGHT",
+                                        destination: dest,
+                                        reason: decision.reason,
+                                        prompt_signature: promptSignature(normalized),
+                                        turn_id: effectiveTurnId,
+                                        created_at: nowIso,
+                                    },
+                                    suppress_followup: true,
+                                };
+                                writeTriageState({ cwd, sessionId: sessionIdForState || null, state: newState });
+                            }
+                        }
+                        // lane === "PASS": no context, no state write
+                    }
+                }
+            }
+            catch {
+                // Swallow all triage errors; never break the hook
+                triageAdditionalContext = null;
+            }
+        }
+        const reconcileHudForPromptSubmitFn = options.reconcileHudForPromptSubmitFn ?? reconcileHudForPromptSubmit;
+        await reconcileHudForPromptSubmitFn(cwd, { sessionId: canonicalSessionId || sessionIdForState || undefined }).catch(() => { });
     }
     if (omxEventName) {
-        const baseContext = buildBaseContext(cwd, payload, hookEventName);
-        if (nativeSessionId) {
-            baseContext.native_session_id = nativeSessionId;
-            baseContext.codex_session_id = nativeSessionId;
+        const baseContext = buildBaseContext(cwd, payload, hookEventName, canonicalSessionId);
+        if (resolvedNativeSessionId) {
+            baseContext.native_session_id = resolvedNativeSessionId;
+            baseContext.codex_session_id = resolvedNativeSessionId;
         }
         if (canonicalSessionId) {
             baseContext.omx_session_id = canonicalSessionId;
@@ -1091,11 +1334,10 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         });
         await dispatchHookEvent(event, { cwd });
     }
-    let outputJson = null;
     if (hookEventName === "SessionStart" || hookEventName === "UserPromptSubmit") {
         const additionalContext = hookEventName === "SessionStart"
             ? await buildSessionStartContext(cwd, canonicalSessionId || nativeSessionId)
-            : buildAdditionalContextMessage(readPromptText(payload), skillState);
+            : (buildAdditionalContextMessage(readPromptText(payload), skillState, cwd) ?? triageAdditionalContext);
         if (additionalContext) {
             outputJson = {
                 hookSpecificOutput: {
@@ -1124,6 +1366,11 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         outputJson,
     };
 }
+export function isCodexNativeHookMainModule(moduleUrl, argv1) {
+    if (!argv1)
+        return false;
+    return moduleUrl === pathToFileURL(argv1).href;
+}
 async function readStdinJson() {
     const chunks = [];
     for await (const chunk of process.stdin) {
@@ -1164,7 +1411,7 @@ export async function runCodexNativeHookCli() {
         process.stdout.write(`${JSON.stringify(result.outputJson)}\n`);
     }
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (isCodexNativeHookMainModule(import.meta.url, process.argv[1])) {
     runCodexNativeHookCli().catch((error) => {
         process.stderr.write(`[omx] codex-native-hook failed: ${error instanceof Error ? error.message : String(error)}\n`);
         process.exitCode = 1;