oh-my-codex 0.18.1 → 0.18.3

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";
@@ -13,6 +13,7 @@ import { omxNotepadPath, resolveProjectMemoryPath } from "../utils/paths.js";
 import { findGitLayout } from "../utils/git-layout.js";
 import { getBaseStateDir, getStateFilePath, getStatePath } from "../mcp/state-paths.js";
 import { detectKeywords, detectPrimaryKeyword, recordSkillActivation, } from "../hooks/keyword-detector.js";
+import { buildDeepInterviewConfigInstruction } from "../hooks/deep-interview-config-instruction.js";
 import { detectNativeStopStallPattern, loadAutoNudgeConfig, normalizeAutoNudgeSignatureText, resolveEffectiveAutoNudgeResponse, } from "./notify-hook/auto-nudge.js";
 import { SLOPPY_FALLBACK_GROUNDING_PATTERNS, SLOPPY_FALLBACK_IMPLEMENTATION_CONTEXT_PATTERNS, SLOPPY_FALLBACK_PHRASE_PATTERNS, buildNativePostToolUseOutput, buildNativePreToolUseOutput, detectMcpTransportFailure, hasAnyPattern, } from "./codex-native-pre-post.js";
 import { handleTeamWorkerPostToolUseSuccess } from "./notify-hook/team-worker-posttooluse.js";
@@ -175,18 +176,29 @@ 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();
@@ -1361,14 +1373,42 @@ 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;
     const promptPriorityMessage = buildPromptPriorityMessage(prompt);
     const matches = detectKeywords(prompt);
     const match = detectPrimaryKeyword(prompt);
-    if (!match)
-        return promptPriorityMessage;
+    if (!match) {
+        const continuedSkill = safeString(skillState?.skill).trim();
+        if (!continuedSkill)
+            return promptPriorityMessage;
+        const deepInterviewPromptActivationNote = skillState?.initialized_mode === "deep-interview"
+            ? buildDeepInterviewQuestionBridgeInstruction(cwd, payload)
+            : null;
+        const deepInterviewConfigPromptActivationNote = buildDeepInterviewConfigInstruction(cwd, skillState);
+        return [
+            `OMX native UserPromptSubmit continued active workflow skill "${continuedSkill}".`,
+            promptPriorityMessage,
+            skillState?.initialized_mode && skillState.initialized_state_path
+                ? buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path)
+                : null,
+            deepInterviewPromptActivationNote,
+            deepInterviewConfigPromptActivationNote,
+            "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
+        ].filter(Boolean).join(" ");
+    }
     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}.`;
@@ -1385,12 +1425,14 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
     const deepInterviewPromptActivationNote = skillState?.initialized_mode === "deep-interview"
         ? buildDeepInterviewQuestionBridgeInstruction(cwd, payload)
         : null;
+    const deepInterviewConfigPromptActivationNote = buildDeepInterviewConfigInstruction(cwd, skillState);
     const ultraworkPromptActivationNote = skillState?.initialized_mode === "ultrawork"
         ? "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 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;
@@ -1419,6 +1461,8 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
                 : null,
             promptPriorityMessage,
             ultragoalPromptActivationNote,
+            autopilotPromptActivationNote,
+            deepInterviewConfigPromptActivationNote,
             skillState.initialized_mode && skillState.initialized_state_path
                 ? buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path)
                 : null,
@@ -1442,8 +1486,10 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
             promptPriorityMessage,
             initializedStateMessage,
             deepInterviewPromptActivationNote,
+            deepInterviewConfigPromptActivationNote,
             ultraworkPromptActivationNote,
             ultragoalPromptActivationNote,
+            autopilotPromptActivationNote,
             buildTeamRuntimeInstruction(cwd, payload),
             buildTeamHelpInstruction(cwd, payload),
             "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
@@ -1459,13 +1505,15 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
             promptPriorityMessage,
             buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path),
             deepInterviewPromptActivationNote,
+            deepInterviewConfigPromptActivationNote,
             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());
@@ -1664,6 +1712,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>'.`,
+                `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(" "),
         };
@@ -1744,30 +1793,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);
@@ -1776,7 +1841,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));
@@ -1859,6 +1927,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();
@@ -2310,7 +2509,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");
@@ -2332,6 +2531,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 {
@@ -2341,18 +2542,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)
@@ -2569,7 +2770,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);
         }
@@ -2580,7 +2781,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);
@@ -2857,7 +3058,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)) {