fix(codex): log unsafe Stop skips

Missing turn identity skips are visible only with PLANNOTATOR_DEBUG.

Author: rNoz

apps/hook/server/codex-session.test.ts

@@ -10,7 +10,13 @@ import { describe, expect, test, afterEach } from "bun:test";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { findCodexRolloutByThreadId, getLastCodexMessage, getLatestCodexPlan } from "./codex-session";
+import {
+  findCodexRolloutByThreadId,
+  getCodexStopSkipReason,
+  getLastCodexMessage,
+  getLatestCodexPlan,
+  logCodexStopSkip,
+} from "./codex-session";
 
 // --- Fixture Helpers ---
 
@@ -389,6 +395,7 @@ describe("getLatestCodexPlan", () => {
       text: "Authoritative plan item",
       source: "plan-item",
     });
+
   });
 
   test("falls back to raw proposed_plan blocks for plan-only assistant replies", () => {
@@ -408,6 +415,40 @@ describe("getLatestCodexPlan", () => {
     });
   });
 
+  describe("Codex Stop skip diagnostics", () => {
+    test("classifies a missing Stop turn id without reading stale plan content", () => {
+      expect(getCodexStopSkipReason("not-read.jsonl")).toBe("missing-turn-id");
+    });
+
+    test("requires an id-carrying rollout turn marker", () => {
+      const turnId = "turn-without-marker";
+      const path = writeTempRollout(
+        buildRollout(
+          sessionMeta(),
+          turnStarted("other-turn"),
+          completedPlanItem("Plan item without matching start marker", turnId),
+        ),
+      );
+
+      expect(getCodexStopSkipReason(path, turnId)).toBe("missing-turn-marker");
+    });
+
+    test("writes the exact skip breadcrumb only when debug is enabled", () => {
+      const messages: string[] = [];
+      const write = (message: string) => messages.push(message);
+
+      logCodexStopSkip("missing-turn-id", { debug: "", write });
+      expect(messages).toEqual([]);
+
+      logCodexStopSkip("missing-turn-id", { debug: "1", write });
+      logCodexStopSkip("missing-turn-marker", { debug: "1", write });
+      expect(messages).toEqual([
+        "[DEBUG] Codex Stop plan review skipped: missing Stop payload turn_id.",
+        "[DEBUG] Codex Stop plan review skipped: missing id-carrying rollout turn marker.",
+      ]);
+    });
+  });
+
   test("extracts plan blocks surrounded by assistant prose", () => {
     const turnId = "turn-prose";
     const path = writeTempRollout(

apps/hook/server/codex-session.ts

@@ -60,6 +60,8 @@ export interface GetLatestCodexPlanOptions {
   stopHookActive?: boolean;
 }
 
+export type CodexStopSkipReason = "missing-turn-id" | "missing-turn-marker";
+
 const TURN_START_TYPES = new Set(["task_started", "turn_started"]);
 const TURN_COMPLETE_TYPES = new Set(["task_complete", "turn_completed"]);
 const PROPOSED_PLAN_RE = /<proposed_plan>([\s\S]*?)<\/proposed_plan>/gi;
@@ -182,23 +184,26 @@ function findLastIndex(
   return -1;
 }
 
-function findTurnStartIndex(entries: RolloutEntry[], turnId?: string): number {
-  const matchingTurnStart = findLastIndex(
+function findMatchingTurnMarkerIndex(
+  entries: RolloutEntry[],
+  turnId: string,
+): number {
+  return findLastIndex(
     entries,
     (entry) =>
-      entry.type === "event_msg" &&
-      TURN_START_TYPES.has(entry.payload?.type || "") &&
-      (!turnId || entry.payload?.turn_id === turnId)
+      (
+        (entry.type === "event_msg" && TURN_START_TYPES.has(entry.payload?.type || "")) ||
+        entry.type === "turn_context"
+      ) &&
+      getTurnId(entry) === turnId,
   );
-  if (matchingTurnStart !== -1) return matchingTurnStart;
+}
 
-  const matchingTurnContext = findLastIndex(
-    entries,
-    (entry) =>
-      entry.type === "turn_context" &&
-      (!turnId || entry.payload?.turn_id === turnId)
-  );
-  if (matchingTurnContext !== -1) return matchingTurnContext;
+function findTurnStartIndex(entries: RolloutEntry[], turnId?: string): number {
+  const matchingTurnStart = turnId
+    ? findMatchingTurnMarkerIndex(entries, turnId)
+    : -1;
+  if (matchingTurnStart !== -1) return matchingTurnStart;
 
   const lastTurnStart = findLastIndex(
     entries,
@@ -283,6 +288,32 @@ function getTurnId(entry: RolloutEntry): string | null {
   return typeof turnId === "string" && turnId ? turnId : null;
 }
 
+export function getCodexStopSkipReason(
+  rolloutPath: string,
+  turnId?: string,
+): CodexStopSkipReason | null {
+  if (!turnId) return "missing-turn-id";
+  const entries = parseRolloutEntries(rolloutPath);
+  return findMatchingTurnMarkerIndex(entries, turnId) === -1
+    ? "missing-turn-marker"
+    : null;
+}
+
+export function logCodexStopSkip(
+  reason: CodexStopSkipReason,
+  opts: {
+    debug?: string;
+    write?: (message: string) => void;
+  } = {},
+): void {
+  if (!opts.debug) return;
+  const detail =
+    reason === "missing-turn-id"
+      ? "missing Stop payload turn_id."
+      : "missing id-carrying rollout turn marker.";
+  (opts.write ?? console.error)(`[DEBUG] Codex Stop plan review skipped: ${detail}`);
+}
+
 function collectPlanCandidates(
   entries: RolloutEntry[],
   startIndex: number,

apps/hook/server/index.ts

@@ -133,7 +133,13 @@ import {
   findActiveExitPlanModeOccurrenceInTranscript,
   type RenderedMessage,
 } from "./session-log";
-import { findCodexRolloutByThreadId, getLatestCodexPlan, getRecentCodexMessages } from "./codex-session";
+import {
+  findCodexRolloutByThreadId,
+  getCodexStopSkipReason,
+  getLatestCodexPlan,
+  getRecentCodexMessages,
+  logCodexStopSkip,
+} from "./codex-session";
 import {
   recordPlanApprovalForSubmission,
   shouldReusePlanApproval,
@@ -1939,8 +1945,18 @@ if (args[0] === "sessions") {
       process.exit(0);
     }
 
+    const turnId =
+      typeof event.turn_id === "string" && event.turn_id
+        ? event.turn_id
+        : undefined;
+    const skipReason = getCodexStopSkipReason(rolloutPath, turnId);
+    if (skipReason) {
+      logCodexStopSkip(skipReason, { debug: process.env.PLANNOTATOR_DEBUG });
+      process.exit(0);
+    }
+
     const latestPlan = getLatestCodexPlan(rolloutPath, {
-      turnId: typeof event.turn_id === "string" ? event.turn_id : undefined,
+      turnId,
       stopHookActive: !!event.stop_hook_active,
     });
 

apps/hook/server/session-log.test.ts

@@ -17,6 +17,7 @@ import {
   getRecentRenderedMessages,
   resolveActiveBranchIndices,
   findActiveExitPlanModeOccurrence,
+  findActiveExitPlanModeOccurrenceInTranscript,
   findDroidSessionLogsForCwd,
   resolveDroidSessionLogForCwd,
   projectSlugFromCwd,
@@ -30,7 +31,7 @@ import {
   resolveSessionLogByCwdScan,
   type SessionLogEntry,
 } from "./session-log";
-import { mkdirSync, writeFileSync, rmSync, utimesSync } from "node:fs";
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync, utimesSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -951,6 +952,29 @@ describe("findActiveExitPlanModeOccurrence", () => {
 
     expect(findActiveExitPlanModeOccurrence(entries, { plan: "# Plan" })).toBeNull();
   });
+
+  test("resolves ExitPlanMode from the transcript state before PermissionRequest", () => {
+    const plan = "# Plan\n- step";
+    const dir = mkdtempSync(join(tmpdir(), "plannotator-pre-permission-"));
+    const transcriptPath = join(dir, "session.jsonl");
+    try {
+      writeFileSync(
+        transcriptPath,
+        buildLog(
+          userPrompt("make a plan"),
+          exitPlanModeToolUse("toolu_before_permission", plan),
+        ),
+      );
+
+      expect(
+        findActiveExitPlanModeOccurrenceInTranscript(transcriptPath, { plan }),
+      ).toMatchObject({
+        toolUseId: "toolu_before_permission",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("extractRecentRenderedMessages — after a rewind", () => {