oh-my-codex 0.12.5 → 0.12.6

package/src/scripts/codex-native-hook.ts

@@ -43,6 +43,7 @@ import {
 import type { HookEventEnvelope } from "../hooks/extensibility/types.js";
 import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
 import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
+import { onSessionStart as buildWikiSessionStartContext } from "../wiki/lifecycle.js";
 
 type CodexHookEventName =
   | "SessionStart"
@@ -70,6 +71,14 @@ 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"]);
 const NATIVE_STOP_STATE_FILE = "native-stop-state.json";
+const STABLE_FINAL_RECOMMENDATION_PATTERNS = [
+  /^\s*(?:launch|release|ship)-?ready\s*:\s*(?:yes|no)\b[^\n\r]*/im,
+  /^\s*ready to release\s*:\s*(?:yes|no)\b[^\n\r]*/im,
+  /^\s*(?:final\s+)?recommendation\s*:\s*(?:yes|no|ship|hold|release|do not release|proceed|do not proceed)\b[^\n\r]*/im,
+  /^\s*decision\s*:\s*(?:yes|no|ship|hold|release|do not release|proceed|do not proceed)\b[^\n\r]*/im,
+] as const;
+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.";
 
 function safeString(value: unknown): string {
   return typeof value === "string" ? value : "";
@@ -141,6 +150,21 @@ function readPromptText(payload: CodexHookPayload): string {
   return "";
 }
 
+function sanitizePayloadForHookContext(
+  payload: CodexHookPayload,
+  hookEventName: CodexHookEventName,
+): CodexHookPayload {
+  if (hookEventName !== "UserPromptSubmit") return payload;
+
+  const sanitized = { ...payload };
+  delete sanitized.prompt;
+  delete sanitized.input;
+  delete sanitized.user_prompt;
+  delete sanitized.userPrompt;
+  delete sanitized.text;
+  return sanitized;
+}
+
 function buildBaseContext(
   cwd: string,
   payload: CodexHookPayload,
@@ -151,10 +175,7 @@ function buildBaseContext(
     project_path: cwd,
     transcript_path: safeString(payload.transcript_path ?? payload.transcriptPath) || null,
     source: safeString(payload.source),
-    payload,
-    ...(hookEventName === "UserPromptSubmit"
-      ? { prompt: readPromptText(payload) }
-      : {}),
+    payload: sanitizePayloadForHookContext(payload, hookEventName),
   };
 }
 
@@ -426,6 +447,11 @@ async function buildSessionStartContext(
     }
   }
 
+  const wikiContext = buildWikiSessionStartContext({ cwd });
+  if (wikiContext.additionalContext) {
+    sections.push(wikiContext.additionalContext);
+  }
+
   const subagentSummary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
   if (subagentSummary && subagentSummary.activeSubagentThreadIds.length > 0) {
     sections.push(`[Subagents]\n- active subagent threads: ${subagentSummary.activeSubagentThreadIds.length}`);
@@ -676,6 +702,12 @@ async function buildTeamStopOutput(cwd: string, sessionId?: string): Promise<Rec
   const teamState = await readTeamModeStateForStop(cwd, sessionId);
   if (teamState?.active !== true) return null;
   const teamName = safeString(teamState.team_name).trim();
+  if (teamName) {
+    const canonicalTeamDir = join(resolveCanonicalTeamStateRoot(cwd), "team", teamName);
+    if (!existsSync(canonicalTeamDir)) {
+      return null;
+    }
+  }
   const coarsePhase = teamState.current_phase;
   const canonicalPhase = teamName ? (await readTeamPhase(teamName, cwd))?.current_phase ?? coarsePhase : coarsePhase;
   if (!isNonTerminalPhase(canonicalPhase)) return null;
@@ -696,6 +728,54 @@ function buildTeamStopOutputForPhase(teamName: string, phase: string): Record<st
   };
 }
 
+function extractStableFinalRecommendationSummary(message: string): string {
+  for (const pattern of STABLE_FINAL_RECOMMENDATION_PATTERNS) {
+    const match = pattern.exec(message);
+    if (!match) continue;
+    const summary = match[0]?.trim().replace(/\s+/g, " ");
+    if (!summary) continue;
+    return /[.!?]$/.test(summary) ? summary : `${summary}.`;
+  }
+  return "";
+}
+
+function buildStableFinalRecommendationStopSignature(
+  payload: CodexHookPayload,
+  teamName: string,
+  summary: string,
+): string {
+  const sessionId = readPayloadSessionId(payload) || "no-session";
+  const threadId = readPayloadThreadId(payload) || "no-thread";
+  const normalizedSummary = normalizeAutoNudgeSignatureText(summary) || summary.toLowerCase();
+  return ["release-readiness-finalize", sessionId, threadId, teamName, normalizedSummary].join("|");
+}
+
+function hasReleaseReadinessMode(payload: CodexHookPayload): boolean {
+  const mode = safeString(payload.mode).trim().toLowerCase();
+  return mode === "release-readiness";
+}
+
+async function hasReleaseReadinessStopMarker(
+  cwd: string,
+  sessionId: string,
+  teamName: string,
+): Promise<boolean> {
+  if (!sessionId) return false;
+
+  const markerState = await readStopSessionPinnedState("release-readiness-state.json", cwd, sessionId);
+  if (markerState?.active !== true || markerState.stable_final_recommendation_emitted !== true) {
+    return false;
+  }
+
+  const markerTeamName = safeString(markerState.team_name).trim();
+  if (markerTeamName && markerTeamName !== teamName) return false;
+
+  const markerSessionId = safeString(markerState.session_id).trim();
+  if (markerSessionId && markerSessionId !== sessionId) return false;
+
+  return true;
+}
+
 function readPayloadSessionId(payload: CodexHookPayload): string {
   return safeString(payload.session_id ?? payload.sessionId).trim();
 }
@@ -935,6 +1015,66 @@ async function findCanonicalActiveTeamForSession(
   return null;
 }
 
+async function resolveActiveTeamNameForStop(
+  cwd: string,
+  sessionId: string,
+): Promise<string> {
+  const directState = await readTeamModeStateForStop(cwd, sessionId);
+  const directTeamName = safeString(directState?.team_name).trim();
+  if (directState?.active === true && directTeamName) return directTeamName;
+
+  const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, sessionId);
+  return canonicalTeam?.teamName ?? "";
+}
+
+async function maybeBuildReleaseReadinessFinalizeStopOutput(
+  payload: CodexHookPayload,
+  cwd: string,
+  stateDir: string,
+  sessionId: string,
+): Promise<{ matched: boolean; output: Record<string, unknown> | null }> {
+  if (!sessionId) return { matched: false, output: null };
+
+  const teamName = await resolveActiveTeamNameForStop(cwd, sessionId);
+  if (!teamName) return { matched: false, output: null };
+
+  const explicitReleaseReadinessContext =
+    hasReleaseReadinessMode(payload)
+    || await hasReleaseReadinessStopMarker(cwd, sessionId, teamName);
+  if (!explicitReleaseReadinessContext) {
+    return { matched: false, output: null };
+  }
+
+  const summary = extractStableFinalRecommendationSummary(
+    safeString(payload.last_assistant_message ?? payload.lastAssistantMessage),
+  );
+  if (!summary) return { matched: false, output: null };
+
+  const leaderAttention = await readTeamLeaderAttention(teamName, cwd);
+  if (
+    !leaderAttention
+    || leaderAttention.leader_decision_state !== "done_waiting_on_leader"
+    || leaderAttention.work_remaining !== false
+  ) {
+    return { matched: false, output: null };
+  }
+
+  const signature = buildStableFinalRecommendationStopSignature(payload, teamName, summary);
+  const output = await maybeReturnRepeatableStopOutput(
+    payload,
+    stateDir,
+    signature,
+    {
+      decision: "block",
+      reason:
+        `Stable final recommendation already reached with no active worker tasks. Emit exactly one concise final decision summary aligned to "${summary}" with no filler or residual acknowledgements (for example "yes"), then stop.`,
+      stopReason: "release_readiness_auto_finalize",
+      systemMessage: RELEASE_READINESS_FINALIZE_SYSTEM_MESSAGE,
+    },
+  );
+  return { matched: true, output };
+}
+
 async function buildSkillStopOutput(
   cwd: string,
   sessionId: string,
@@ -1088,6 +1228,14 @@ async function buildStopHookOutput(
     const ultraqaOutput = await buildModeBasedStopOutput("ultraqa", cwd, canonicalSessionId);
     if (!stopHookActive && ultraqaOutput) return ultraqaOutput;
 
+    const releaseReadinessFinalizeResult = await maybeBuildReleaseReadinessFinalizeStopOutput(
+      payload,
+      cwd,
+      stateDir,
+      canonicalSessionId,
+    );
+    if (releaseReadinessFinalizeResult.matched) return releaseReadinessFinalizeResult.output;
+
     const teamOutput = await buildTeamStopOutput(cwd, canonicalSessionId);
     if (teamOutput) {
       const teamSignature = buildRepeatableStopSignature(payload, "team-stop", safeString(teamOutput.stopReason));
@@ -1257,17 +1405,49 @@ export async function dispatchCodexNativeHook(
   };
 }
 
-async function readStdinJson(): Promise<CodexHookPayload> {
+interface NativeHookCliReadResult {
+  payload: CodexHookPayload;
+  parseError: Error | null;
+}
+
+async function readStdinJson(): Promise<NativeHookCliReadResult> {
   const chunks: Buffer[] = [];
   for await (const chunk of process.stdin) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
   }
   const raw = Buffer.concat(chunks).toString("utf-8").trim();
-  return raw ? safeObject(JSON.parse(raw)) : {};
+  if (!raw) {
+    return { payload: {}, parseError: null };
+  }
+
+  try {
+    return {
+      payload: safeObject(JSON.parse(raw)),
+      parseError: null,
+    };
+  } catch (error) {
+    return {
+      payload: {},
+      parseError: error instanceof Error ? error : new Error(String(error)),
+    };
+  }
 }
 
 export async function runCodexNativeHookCli(): Promise<void> {
-  const payload = await readStdinJson();
+  const { payload, parseError } = await readStdinJson();
+  if (parseError) {
+    process.stdout.write(`${JSON.stringify({
+      decision: "block",
+      reason: "OMX native hook received malformed JSON input. Preserve runtime state and inspect the emitting hook payload before retrying.",
+      hookSpecificOutput: {
+        hookEventName: "Unknown",
+        additionalContext:
+          `stdin JSON parsing failed inside codex-native-hook: ${parseError.message}. Emit valid JSON from the native hook caller before retrying.`,
+      },
+    })}\n`);
+    return;
+  }
+
   const result = await dispatchCodexNativeHook(payload);
   if (result.outputJson) {
     process.stdout.write(`${JSON.stringify(result.outputJson)}\n`);

package/src/scripts/hook-derived-watcher.ts

@@ -62,6 +62,48 @@ function safeString(value: unknown): string {
   return typeof value === 'string' ? value : '';
 }
 
+function collectMessageTextFragments(value: unknown, fragments: string[]): void {
+  if (typeof value === 'string') {
+    if (value.trim() !== '') fragments.push(value);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) collectMessageTextFragments(item, fragments);
+    return;
+  }
+
+  if (!value || typeof value !== 'object') return;
+
+  const record = value as Record<string, unknown>;
+  let usedPreferredField = false;
+  for (const key of ['text', 'message', 'content']) {
+    if (!(key in record)) continue;
+    usedPreferredField = true;
+    collectMessageTextFragments(record[key], fragments);
+  }
+  if (usedPreferredField) return;
+
+  for (const child of Object.values(record)) {
+    collectMessageTextFragments(child, fragments);
+  }
+}
+
+function extractMessageText(payload: Record<string, unknown>): string {
+  for (const candidate of [payload.text, payload.message, payload.content]) {
+    if (typeof candidate === 'string') {
+      if (candidate.trim() !== '') return candidate;
+      continue;
+    }
+
+    const fragments: string[] = [];
+    collectMessageTextFragments(candidate, fragments);
+    const text = fragments.join('\n').trim();
+    if (text) return text;
+  }
+  return '';
+}
+
 function derivedLog(entry: Record<string, unknown>): Promise<void> {
   return appendFile(logPath, `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`).catch(() => {});
 }
@@ -185,7 +227,7 @@ function inferDerivedEvent(parsed: Record<string, unknown> | null, meta: FileMet
   }
 
   if (payloadType === 'assistant_message') {
-    const message = safeString(payload.text || payload.message || payload.content);
+    const message = extractMessageText(payload);
     const looksLikeQuestion = /\?|\b(can you|could you|please provide|need input|what should)/i.test(message);
     if (looksLikeQuestion) {
       return {

package/src/scripts/notify-fallback-watcher.ts

@@ -33,6 +33,7 @@ import {
   readSubagentSessionSummary,
 } from '../subagents/tracker.js';
 import { listNotifyCanonicalActiveTeams } from './notify-hook/active-team.js';
+import { sameFilePath } from '../utils/paths.js';
 
 function argValue(name: string, fallback = ''): string {
   const idx = process.argv.indexOf(name);
@@ -128,6 +129,7 @@ const RALPH_CONTINUE_TEXT = 'Ralph loop active continue';
 const RALPH_CONTINUE_CADENCE_MS = 60_000;
 const RALPH_STEER_LOCK_STALE_MS = 30_000;
 const RALPH_TERMINAL_PHASES = new Set(['complete', 'failed', 'cancelled']);
+const RALPH_STARTING_PHASE_TIMEOUT_MS = RALPH_CONTINUE_CADENCE_MS * 2;
 const QUIET_ONCE_EVENT_TYPES = new Set(['watcher_start', 'watcher_once_complete']);
 
 interface WatcherFileMeta {
@@ -457,10 +459,19 @@ function hasRalphTerminalState(raw: Record<string, unknown> | null | undefined):
   if (raw.active !== true) return true;
   const phase = safeString(raw.current_phase).trim().toLowerCase();
   if (phase && RALPH_TERMINAL_PHASES.has(phase)) return true;
+  if (isStaleRalphStartingPhase(raw)) return true;
   if (safeString(raw.completed_at).trim()) return true;
   return false;
 }
 
+function isStaleRalphStartingPhase(raw: Record<string, unknown>): boolean {
+  const phase = safeString(raw.current_phase).trim().toLowerCase();
+  if (phase !== 'starting') return false;
+  const reference = parseIsoMillis(safeString(raw.last_turn_at)) ?? parseIsoMillis(safeString(raw.started_at));
+  if (reference === null) return false;
+  return Date.now() - reference > RALPH_STARTING_PHASE_TIMEOUT_MS;
+}
+
 async function loadPersistedWatcherState(): Promise<void> {
   const persisted = await readFile(statePath, 'utf-8')
     .then((content) => JSON.parse(content) as Record<string, unknown>)
@@ -537,6 +548,14 @@ async function resolveActiveModeState(mode: string): Promise<ActiveModeResult> {
       .then((content) => JSON.parse(content) as Record<string, unknown>)
       .catch(() => null);
     if (!parsed || typeof parsed !== 'object') continue;
+    if (mode === 'ralph' && dir !== stateDir && isStaleRalphStartingPhase(parsed)) {
+      return {
+        active: false,
+        reason: 'starting_stale',
+        path,
+        state: parsed,
+      };
+    }
     if (hasRalphTerminalState(parsed)) {
       return {
         active: false,
@@ -909,7 +928,7 @@ async function resolveAuthorityPrimaryWatcherHealth(now = Date.now()): Promise<A
 
   const existingRecord = await readPidFileRecord(pidFilePath).catch(() => null);
   if (!existingRecord) return createAuthorityBackoffState('pid_missing');
-  if (existingRecord.cwd && resolve(existingRecord.cwd) !== cwd) return createAuthorityBackoffState('cwd_mismatch');
+  if (existingRecord.cwd && !sameFilePath(existingRecord.cwd, cwd)) return createAuthorityBackoffState('cwd_mismatch');
   if (!isPidAlive(existingRecord.pid)) {
     return createAuthorityBackoffState('pid_stale', {
       primary_pid: existingRecord.pid,
@@ -1004,7 +1023,12 @@ async function runRalphContinueSteerTick(): Promise<void> {
     singleton_lock_path: ralphSteerLockPath,
   };
 
-  if (!activeRalph.active) return;
+  if (!activeRalph.active) {
+    if (activeRalph.reason === 'starting_stale') {
+      lastRalphContinueSteer.last_reason = 'starting_stale';
+    }
+    return;
+  }
 
   if (parseIsoMillis(lastRalphContinueSteer.last_sent_at) === null && parseIsoMillis(lastRalphContinueSteer.cooldown_anchor_at) === null) {
     lastRalphContinueSteer.cooldown_anchor_at = startupIso;

package/src/scripts/notify-hook/auto-nudge.ts

@@ -347,6 +347,24 @@ function looksLikePermissionSeekingContinuation(normalizedText) {
   return matchesNormalizedPatterns(normalizedText, normalizePatternList(PERMISSION_SEEKING_STALL_PATTERNS));
 }
 
+/**
+ * Pattern to identify test-runner output lines (status symbols, PASS/FAIL prefixes).
+ * These lines may incidentally contain stall-pattern words inside test names and
+ * should be excluded before running stall detection on pane captures.
+ */
+const CAPTURE_TEST_LINE_RE = /^\s*(?:[✓✗✕×●✔✘▶◆○]|(?:PASS|FAIL|SKIP|ERROR)\s)/u;
+
+/**
+ * Strip lines that look like test-runner output so stall patterns inside test
+ * names (e.g. "✓ should continue with the next step") do not trigger a nudge.
+ */
+function filterCapturedTestLines(text) {
+  return safeString(text)
+    .split('\n')
+    .filter((line) => !CAPTURE_TEST_LINE_RE.test(line))
+    .join('\n');
+}
+
 function summarizePaneCaptureForLog(captured, maxLines = 6) {
   const lines = safeString(captured)
     .replace(/\r\n?/g, '\n')
@@ -516,7 +534,7 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
 
     if (!detected && paneId) {
       captured = await capturePane(paneId);
-      detected = detectStallPattern(captured, config.patterns, skillState?.phase);
+      detected = detectStallPattern(filterCapturedTestLines(captured), config.patterns, skillState?.phase);
       source = 'capture-pane';
     }
 

package/src/scripts/notify-hook/managed-tmux.ts

@@ -1,9 +1,10 @@
 import { execFileSync } from 'child_process';
 import { readFileSync } from 'fs';
-import { basename, dirname, resolve as resolvePath } from 'path';
+import { basename, dirname } from 'path';
 import { readSessionState, isSessionStale } from '../../hooks/session.js';
 import { runProcess } from './process-runner.js';
 import { safeString } from './utils.js';
+import { sameFilePath } from '../../utils/paths.js';
 
 function sanitizeTmuxToken(value: string): string {
   const cleaned = safeString(value)
@@ -139,7 +140,7 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
     if (!sessionState) {
       return { managed: false, reason: 'missing_session_state', invocationSessionId, sessionState: null, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
     }
-    if (resolvePath(safeString(sessionState.cwd || cwd)) !== resolvePath(cwd)) {
+    if (!sameFilePath(safeString(sessionState.cwd || cwd), cwd)) {
       return { managed: false, reason: 'cwd_mismatch', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
     }
     const canonicalSessionId = safeString(sessionState.session_id).trim();
@@ -152,7 +153,11 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
       return { managed: false, reason: 'stale_session', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
     }
 
-    const expectedTmuxSessionName = buildExpectedManagedTmuxSessionName(cwd, canonicalSessionId || invocationSessionId);
+    const authoritativeSessionCwd = safeString(sessionState.cwd || cwd).trim() || cwd;
+    const expectedTmuxSessionName = buildExpectedManagedTmuxSessionName(
+      authoritativeSessionCwd,
+      canonicalSessionId || invocationSessionId,
+    );
     const currentTmuxSessionName = readCurrentTmuxSessionName();
     if (currentTmuxSessionName && currentTmuxSessionName === expectedTmuxSessionName) {
       return {