oh-my-codex 0.12.0 → 0.12.2

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

@@ -1,7 +1,7 @@
 import { execFileSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, readdir, writeFile } from "fs/promises";
-import { join } from "path";
+import { join, resolve } from "path";
 import { readModeState } from "../modes/base.js";
 import { getReadScopedStateDirs } from "../mcp/state-paths.js";
 import { readSubagentSessionSummary } from "../subagents/tracker.js";
@@ -15,8 +15,10 @@ import {
 } from "../hooks/keyword-detector.js";
 import {
   detectStallPattern,
+  isDeepInterviewInputLockActive,
   isDeepInterviewStateActive,
   loadAutoNudgeConfig,
+  normalizeAutoNudgeSignatureText,
 } from "./notify-hook/auto-nudge.js";
 import {
   buildNativePostToolUseOutput,
@@ -53,6 +55,8 @@ export interface NativeHookDispatchResult {
 const TERMINAL_RALPH_PHASES = new Set(["complete", "failed", "cancelled"]);
 const TERMINAL_MODE_PHASES = new Set(["complete", "failed", "cancelled"]);
 const SKILL_STOP_BLOCKERS = new Set(["ralplan", "deep-interview"]);
+const TEAM_TERMINAL_TASK_STATUSES = new Set(["completed", "failed"]);
+const NATIVE_STOP_STATE_FILE = "native-stop-state.json";
 
 function safeString(value: unknown): string {
   return typeof value === "string" ? value : "";
@@ -420,14 +424,118 @@ async function buildSessionStartContext(
   return sections.join("\n\n");
 }
 
-function buildAdditionalContextMessage(prompt: string): string | null {
+function buildAdditionalContextMessage(prompt: string, skillState?: SkillActiveState | null): string | null {
   if (!prompt) return null;
   const match = detectPrimaryKeyword(prompt);
   if (!match) return null;
 
+  if (skillState?.initialized_mode && skillState.initialized_state_path) {
+    return [
+      `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}.`,
+      `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`,
+      "Follow AGENTS.md routing and preserve ralplan/ralph execution gates.",
+    ].join(" ");
+  }
+
   return `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}. Follow AGENTS.md routing and preserve ralplan/ralph execution gates.`;
 }
 
+function parseTeamWorkerEnv(rawValue: string): { teamName: string; workerName: string } | null {
+  const match = /^([a-z0-9][a-z0-9-]{0,29})\/(worker-\d+)$/.exec(rawValue.trim());
+  if (!match) return null;
+  return {
+    teamName: match[1] || "",
+    workerName: match[2] || "",
+  };
+}
+
+async function readTeamStateRootFromJson(path: string): Promise<string | null> {
+  const parsed = await readJsonIfExists(path);
+  const value = safeString(parsed?.team_state_root).trim();
+  return value || null;
+}
+
+async function resolveTeamStateDirForWorkerContext(
+  cwd: string,
+  workerContext: { teamName: string; workerName: string },
+): Promise<string> {
+  const explicitStateRoot = safeString(process.env.OMX_TEAM_STATE_ROOT).trim();
+  if (explicitStateRoot) {
+    return resolve(cwd, explicitStateRoot);
+  }
+
+  const leaderCwd = safeString(process.env.OMX_TEAM_LEADER_CWD).trim();
+  const candidateStateDirs = [
+    ...(leaderCwd ? [join(resolve(leaderCwd), ".omx", "state")] : []),
+    join(cwd, ".omx", "state"),
+  ];
+
+  for (const candidateStateDir of candidateStateDirs) {
+    const teamRoot = join(candidateStateDir, "team", workerContext.teamName);
+    if (!existsSync(teamRoot)) continue;
+
+    const identityRoot = await readTeamStateRootFromJson(
+      join(teamRoot, "workers", workerContext.workerName, "identity.json"),
+    );
+    if (identityRoot) return resolve(cwd, identityRoot);
+
+    const manifestRoot = await readTeamStateRootFromJson(join(teamRoot, "manifest.v2.json"));
+    if (manifestRoot) return resolve(cwd, manifestRoot);
+
+    const configRoot = await readTeamStateRootFromJson(join(teamRoot, "config.json"));
+    if (configRoot) return resolve(cwd, configRoot);
+
+    return candidateStateDir;
+  }
+
+  return join(cwd, ".omx", "state");
+}
+
+async function buildTeamWorkerStopOutput(
+  cwd: string,
+): Promise<Record<string, unknown> | null> {
+  const workerContext = parseTeamWorkerEnv(safeString(process.env.OMX_TEAM_WORKER));
+  if (!workerContext) return null;
+
+  const stateDir = await resolveTeamStateDirForWorkerContext(cwd, workerContext);
+  const workerRoot = join(stateDir, "team", workerContext.teamName, "workers", workerContext.workerName);
+  const [identity, status] = await Promise.all([
+    readJsonIfExists(join(workerRoot, "identity.json")),
+    readJsonIfExists(join(workerRoot, "status.json")),
+  ]);
+
+  const candidateTaskIds = new Set<string>();
+  const currentTaskId = safeString(status?.current_task_id).trim();
+  if (currentTaskId) candidateTaskIds.add(currentTaskId);
+  const assignedTasks = Array.isArray(identity?.assigned_tasks) ? identity?.assigned_tasks : [];
+  for (const taskId of assignedTasks) {
+    const normalized = safeString(taskId).trim();
+    if (normalized) candidateTaskIds.add(normalized);
+  }
+
+  for (const taskId of candidateTaskIds) {
+    const task = await readJsonIfExists(
+      join(stateDir, "team", workerContext.teamName, "tasks", `task-${taskId}.json`),
+    );
+    const statusValue = safeString(task?.status).trim().toLowerCase();
+    if (!statusValue || TEAM_TERMINAL_TASK_STATUSES.has(statusValue)) continue;
+    return {
+      decision: "block",
+      reason:
+        `OMX team worker ${workerContext.workerName} is still assigned non-terminal task ${taskId} (${statusValue}); continue the current assigned task or report a concrete blocker before stopping.`,
+      stopReason: `team_worker_${workerContext.workerName}_${taskId}_${statusValue}`,
+      systemMessage:
+        `OMX team worker ${workerContext.workerName} is still assigned task ${taskId} (${statusValue}).`,
+    };
+  }
+
+  return null;
+}
+
+function hasTeamWorkerContext(): boolean {
+  return parseTeamWorkerEnv(safeString(process.env.OMX_TEAM_WORKER)) !== null;
+}
+
 function isStopExempt(payload: CodexHookPayload): boolean {
   const candidates = [
     payload.stop_reason,
@@ -469,15 +577,145 @@ async function buildTeamStopOutput(cwd: string): Promise<Record<string, unknown>
   const coarsePhase = teamState.current_phase;
   const canonicalPhase = teamName ? (await readTeamPhase(teamName, cwd))?.current_phase ?? coarsePhase : coarsePhase;
   if (!isNonTerminalPhase(canonicalPhase)) return null;
-  const phase = formatPhase(canonicalPhase);
+  return buildTeamStopOutputForPhase(teamName, formatPhase(canonicalPhase));
+}
+
+function buildTeamStopReason(teamName: string, phase: string): string {
+  const teamContext = teamName ? ` (${teamName})` : "";
+  return `OMX team pipeline is still active${teamContext} at phase ${phase}; continue coordinating until the team reaches a terminal phase. If system-generated worker auto-checkpoint commits exist, rewrite them into Lore-format final commits before merge/finalization.`;
+}
+
+function buildTeamStopOutputForPhase(teamName: string, phase: string): Record<string, unknown> {
   return {
     decision: "block",
-    reason: `OMX team pipeline is still active${teamName ? ` (${teamName})` : ""} at phase ${phase}; continue coordinating until the team reaches a terminal phase.`,
+    reason: buildTeamStopReason(teamName, phase),
     stopReason: `team_${phase}`,
     systemMessage: `OMX team pipeline is still active at phase ${phase}.`,
   };
 }
 
+function readPayloadSessionId(payload: CodexHookPayload): string {
+  return safeString(payload.session_id ?? payload.sessionId).trim();
+}
+
+function readPayloadThreadId(payload: CodexHookPayload): string {
+  return safeString(payload.thread_id ?? payload.threadId).trim();
+}
+
+function readPayloadTurnId(payload: CodexHookPayload): string {
+  return safeString(payload.turn_id ?? payload.turnId).trim();
+}
+
+async function isDeepInterviewSuppressedForStop(
+  cwd: string,
+  stateDir: string,
+  sessionId: string,
+): Promise<boolean> {
+  if (await isDeepInterviewStateActive(stateDir)) return true;
+  if (await isDeepInterviewInputLockActive(stateDir)) return true;
+
+  const scopedModeState = sessionId
+    ? await readScopedJsonState("deep-interview-state.json", cwd, sessionId)
+    : null;
+  if (scopedModeState?.active === true) return true;
+
+  const scopedSkillState = sessionId
+    ? await readScopedJsonState("skill-active-state.json", cwd, sessionId)
+    : null;
+  if (!scopedSkillState || scopedSkillState.active !== true) return false;
+  return safeString(scopedSkillState.skill).trim() === "deep-interview";
+}
+
+function buildRepeatableStopSignature(
+  payload: CodexHookPayload,
+  kind: string,
+  detail = "",
+): string {
+  const sessionId = readPayloadSessionId(payload) || "no-session";
+  const threadId = readPayloadThreadId(payload) || "no-thread";
+  const turnId = readPayloadTurnId(payload);
+  const normalizedDetail = normalizeAutoNudgeSignatureText(detail) || safeString(detail).trim().toLowerCase();
+  const transcriptPath = safeString(payload.transcript_path ?? payload.transcriptPath).trim() || "no-transcript";
+  const lastAssistantMessage = normalizeAutoNudgeSignatureText(
+    payload.last_assistant_message ?? payload.lastAssistantMessage,
+  ) || "no-message";
+  if (turnId) {
+    return [
+      kind,
+      sessionId,
+      threadId,
+      turnId,
+      transcriptPath,
+      lastAssistantMessage,
+      normalizedDetail || "no-detail",
+    ].join("|");
+  }
+  return [
+    kind,
+    sessionId,
+    threadId,
+    transcriptPath,
+    lastAssistantMessage,
+    normalizedDetail || "no-detail",
+  ].join("|");
+}
+
+async function readNativeStopState(stateDir: string): Promise<Record<string, unknown>> {
+  return await readJsonIfExists(join(stateDir, NATIVE_STOP_STATE_FILE)) ?? {};
+}
+
+function readNativeStopSessionKey(payload: CodexHookPayload): string {
+  return readPayloadSessionId(payload) || readPayloadThreadId(payload) || "global";
+}
+
+function readPreviousNativeStopSignature(
+  state: Record<string, unknown>,
+  sessionKey: string,
+): string {
+  const sessions = safeObject(state.sessions);
+  const sessionState = safeObject(sessions[sessionKey]);
+  return safeString(sessionState.last_signature).trim();
+}
+
+async function persistNativeStopSignature(
+  stateDir: string,
+  payload: CodexHookPayload,
+  signature: string,
+): Promise<void> {
+  if (!signature) return;
+  const state = await readNativeStopState(stateDir);
+  const sessions = safeObject(state.sessions);
+  const sessionKey = readNativeStopSessionKey(payload);
+  sessions[sessionKey] = {
+    ...safeObject(sessions[sessionKey]),
+    last_signature: signature,
+    updated_at: new Date().toISOString(),
+  };
+  await writeFile(join(stateDir, NATIVE_STOP_STATE_FILE), JSON.stringify({
+    ...state,
+    sessions,
+  }, null, 2));
+}
+
+async function maybeReturnRepeatableStopOutput(
+  payload: CodexHookPayload,
+  stateDir: string,
+  signature: string,
+  output: Record<string, unknown> | null,
+): Promise<Record<string, unknown> | null> {
+  if (!output) return null;
+  const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
+  if (stopHookActive) {
+    const state = await readNativeStopState(stateDir);
+    const previousSignature = readPreviousNativeStopSignature(state, readNativeStopSessionKey(payload));
+    if (!signature || previousSignature === signature) {
+      return null;
+    }
+  }
+  await persistNativeStopSignature(stateDir, payload, signature);
+  return output;
+}
+
 async function findCanonicalActiveTeamForSession(
   cwd: string,
   sessionId: string,
@@ -513,9 +751,16 @@ async function findCanonicalActiveTeamForSession(
 async function buildSkillStopOutput(
   cwd: string,
   sessionId: string,
+  threadId: string,
 ): Promise<Record<string, unknown> | null> {
   const state = await readScopedJsonState("skill-active-state.json", cwd, sessionId);
   if (!state || state.active !== true) return null;
+  const stateSessionId = safeString(state.session_id).trim();
+  const stateThreadId = safeString(state.thread_id).trim();
+  if (sessionId && stateSessionId && stateSessionId !== sessionId) return null;
+  if (sessionId && !stateSessionId && threadId && stateThreadId && stateThreadId !== threadId) {
+    return null;
+  }
   const skill = safeString(state.skill).trim();
   const phase = formatPhase(state.phase, "planning");
   if (!SKILL_STOP_BLOCKERS.has(skill) || phase === "completing") return null;
@@ -542,10 +787,14 @@ async function buildStopHookOutput(
     return null;
   }
 
-  const sessionId = safeString(payload.session_id ?? payload.sessionId).trim();
+  const sessionId = readPayloadSessionId(payload);
+  const threadId = readPayloadThreadId(payload);
   const ralphState = await readActiveRalphState(stateDir);
   const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
   if (!ralphState) {
+    const teamWorkerOutput = await buildTeamWorkerStopOutput(cwd);
+    if (!stopHookActive && hasTeamWorkerContext()) return teamWorkerOutput;
+
     const autopilotOutput = await buildModeBasedStopOutput("autopilot", cwd);
     if (!stopHookActive && autopilotOutput) return autopilotOutput;
 
@@ -556,42 +805,55 @@ async function buildStopHookOutput(
     if (!stopHookActive && ultraqaOutput) return ultraqaOutput;
 
     const teamOutput = await buildTeamStopOutput(cwd);
-    if (!stopHookActive && teamOutput) return teamOutput;
+    if (teamOutput) {
+      const teamSignature = buildRepeatableStopSignature(payload, "team-stop", safeString(teamOutput.stopReason));
+      return await maybeReturnRepeatableStopOutput(payload, stateDir, teamSignature, teamOutput);
+    }
 
     if (sessionId) {
       const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, sessionId);
-      if (!stopHookActive && canonicalTeam) {
-        return {
-          decision: "block",
-          reason: `OMX team pipeline is still active (${canonicalTeam.teamName}) at phase ${canonicalTeam.phase}; continue coordinating until the team reaches a terminal phase.`,
-          stopReason: `team_${canonicalTeam.phase}`,
-          systemMessage: `OMX team pipeline is still active at phase ${canonicalTeam.phase}.`,
-        };
+      if (canonicalTeam) {
+        const canonicalTeamOutput = buildTeamStopOutputForPhase(
+          canonicalTeam.teamName,
+          canonicalTeam.phase,
+        );
+        const canonicalTeamSignature = buildRepeatableStopSignature(payload, "team-stop", `${canonicalTeam.teamName}|${canonicalTeam.phase}`);
+        const repeatedCanonicalTeamOutput = await maybeReturnRepeatableStopOutput(
+          payload,
+          stateDir,
+          canonicalTeamSignature,
+          canonicalTeamOutput,
+        );
+        if (repeatedCanonicalTeamOutput) return repeatedCanonicalTeamOutput;
       }
 
-      const skillOutput = await buildSkillStopOutput(cwd, sessionId);
+      const skillOutput = await buildSkillStopOutput(cwd, sessionId, threadId);
       if (!stopHookActive && skillOutput) return skillOutput;
     }
 
-    const deepInterviewActive = await isDeepInterviewStateActive(stateDir);
+    const deepInterviewActive = await isDeepInterviewSuppressedForStop(cwd, stateDir, sessionId);
     const lastAssistantMessage = safeString(
       payload.last_assistant_message ?? payload.lastAssistantMessage,
     );
     const autoNudgeConfig = await loadAutoNudgeConfig();
 
     if (
-      !stopHookActive
-      && !deepInterviewActive
+      !deepInterviewActive
       && autoNudgeConfig.enabled
       && detectStallPattern(lastAssistantMessage, autoNudgeConfig.patterns)
     ) {
-      return {
-        decision: "block",
-        reason: autoNudgeConfig.response,
-        stopReason: "auto_nudge",
-        systemMessage:
-          "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
-      };
+      return await maybeReturnRepeatableStopOutput(
+        payload,
+        stateDir,
+        buildRepeatableStopSignature(payload, "auto-nudge", lastAssistantMessage),
+        {
+          decision: "block",
+          reason: autoNudgeConfig.response,
+          stopReason: "auto_nudge",
+          systemMessage:
+            "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
+        },
+      );
     }
 
     return null;
@@ -667,7 +929,7 @@ export async function dispatchCodexNativeHook(
   if (hookEventName === "SessionStart" || hookEventName === "UserPromptSubmit") {
     const additionalContext = hookEventName === "SessionStart"
       ? await buildSessionStartContext(cwd, sessionId)
-      : buildAdditionalContextMessage(readPromptText(payload));
+      : buildAdditionalContextMessage(readPromptText(payload), skillState);
     if (additionalContext) {
       outputJson = {
         hookSpecificOutput: {

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { existsSync } from 'fs';
-import { appendFile, mkdir, open, readFile, readdir, rename, stat, unlink, writeFile } from 'fs/promises';
+import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'fs/promises';
 import { spawnSync } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
@@ -110,6 +110,13 @@ const stateDir = join(omxDir, 'state');
 const statePath = join(stateDir, 'notify-fallback-state.json');
 const pidFilePath = resolve(argValue('--pid-file', join(stateDir, 'notify-fallback.pid')));
 const logPath = join(logsDir, `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+const logRotatePath = `${logPath}.1`;
+const logLockPath = `${logPath}.lock`;
+const defaultMaxLogBytes = 10 * 1024 * 1024;
+const maxLogBytes = Math.max(
+  0,
+  asNumber(argValue('--log-max-bytes', process.env.OMX_NOTIFY_FALLBACK_LOG_MAX_BYTES || String(defaultMaxLogBytes)), defaultMaxLogBytes),
+);
 const ralphSteerTimestampPath = join(stateDir, 'ralph-last-steer-at');
 const ralphSteerLockPath = join(stateDir, 'ralph-continue-steer.lock');
 const watcherOwnerToken = `${process.pid}-${startedAt}-${Math.random().toString(36).slice(2, 10)}`;
@@ -117,6 +124,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 QUIET_ONCE_EVENT_TYPES = new Set(['watcher_start', 'watcher_once_complete']);
 
 interface WatcherFileMeta {
   threadId: string;
@@ -311,8 +319,57 @@ let adaptivePollState: AdaptivePollState = {
   last_activity_at: null,
   last_activity_reason: 'init',
 };
-function eventLog(event: Record<string, unknown>): Promise<void> {
-  return appendFile(logPath, `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`).catch(() => {});
+
+function shouldSuppressEventLog(event: Record<string, unknown>): boolean {
+  const eventType = safeString(event.type).trim();
+  return runOnce && QUIET_ONCE_EVENT_TYPES.has(eventType);
+}
+
+async function acquireLogLock(timeoutMs = 1000): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      await mkdir(logLockPath, { recursive: false });
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException | null)?.code !== 'EEXIST') return false;
+      const lockStat = await stat(logLockPath).catch(() => null);
+      if (lockStat && Date.now() - lockStat.mtimeMs > 5000) {
+        await rm(logLockPath, { recursive: true, force: true }).catch(() => {});
+        continue;
+      }
+      await sleep(10);
+    }
+  }
+  return false;
+}
+
+async function releaseLogLock(): Promise<void> {
+  await rm(logLockPath, { recursive: true, force: true }).catch(() => {});
+}
+
+async function rotateLogIfNeeded(nextEntryBytes: number): Promise<void> {
+  if (maxLogBytes <= 0) return;
+  const currentStat = await stat(logPath).catch(() => null);
+  if (!currentStat || currentStat.size + nextEntryBytes <= maxLogBytes) return;
+  await unlink(logRotatePath).catch(() => {});
+  await rename(logPath, logRotatePath).catch(() => {});
+}
+
+async function eventLog(event: Record<string, unknown>): Promise<void> {
+  if (shouldSuppressEventLog(event)) return;
+  const line = `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`;
+  await mkdir(dirname(logPath), { recursive: true }).catch(() => {});
+  const locked = await acquireLogLock();
+  if (!locked) return;
+  try {
+    await rotateLogIfNeeded(Buffer.byteLength(line));
+    await appendFile(logPath, line);
+  } catch {
+    // best effort only
+  } finally {
+    await releaseLogLock();
+  }
 }
 
 function shouldLogLeaderNudgeTick(reason: string): boolean {
@@ -1669,8 +1726,8 @@ async function main(): Promise<void> {
       notify_script: notifyScript,
       authority_only: authorityOnly,
       poll_ms: pollMs,
-    effective_poll_ms: adaptivePollState.current_ms,
-    idle_max_poll_ms: idleMaxPollMs,
+      effective_poll_ms: adaptivePollState.current_ms,
+      idle_max_poll_ms: idleMaxPollMs,
       once: runOnce,
       parent_pid: parentPid,
       pid_file: runOnce ? null : pidFilePath,