oh-my-codex 0.18.9 → 0.18.11

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

@@ -1,5 +1,5 @@
 import { execFileSync } from "child_process";
-import { closeSync, existsSync, openSync, readFileSync, readSync } from "fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "fs";
 import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
 import { extname, join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
@@ -216,6 +216,57 @@ function safeContextSnippet(value: unknown, maxLength = 300): string {
   return `${text.slice(0, maxLength - 1).trimEnd()}…`;
 }
 
+const SIDE_CONVERSATION_BOUNDARY_PATTERNS = [
+  /side conversation boundary/i,
+  /inherited history from the parent thread/i,
+  /reference context only/i,
+  /only messages submitted after this boundary are active/i,
+  /side-conversation assistant/i,
+] as const;
+
+function textHasSideConversationBoundary(text: string): boolean {
+  return SIDE_CONVERSATION_BOUNDARY_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+function isLikelySideConversationStopPayload(payload: CodexHookPayload): boolean {
+  const payloadText = [
+    payload.prompt,
+    payload.user_prompt,
+    payload.userPrompt,
+    payload.input,
+    payload.last_user_message,
+    payload.lastUserMessage,
+    payload.last_assistant_message,
+    payload.lastAssistantMessage,
+  ].map(safeString).join("\n");
+  if (textHasSideConversationBoundary(payloadText)) return true;
+
+  const transcriptPath = safeString(payload.transcript_path ?? payload.transcriptPath).trim();
+  if (!transcriptPath || !existsSync(transcriptPath)) return false;
+
+  try {
+    const maxBytes = 256 * 1024;
+    const stats = statSync(transcriptPath);
+    const fd = openSync(transcriptPath, "r");
+    try {
+      const bytesToRead = Math.min(maxBytes, Math.max(0, stats.size));
+      const buffer = Buffer.alloc(bytesToRead);
+      const position = Math.max(0, stats.size - bytesToRead);
+      const bytesRead = readSync(fd, buffer, 0, bytesToRead, position);
+      return textHasSideConversationBoundary(buffer.toString("utf-8", 0, bytesRead));
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+
+function shouldSuppressParentWorkflowStopForSideConversation(payload: CodexHookPayload): boolean {
+  if (safeString(payload.hook_event_name ?? payload.hookEventName).trim() !== "Stop") return false;
+  return isLikelySideConversationStopPayload(payload);
+}
+
 interface NativeSubagentSessionStartMetadata {
   parentThreadId: string;
   agentNickname?: string;
@@ -2657,9 +2708,23 @@ function readPreToolUsePathCandidates(payload: CodexHookPayload): string[] {
   return candidates.map((candidate) => safeString(candidate).trim()).filter(Boolean);
 }
 
+function isNullDeviceRedirectTarget(target: string): boolean {
+  const normalized = target.trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+  return normalized === "/dev/null" || normalized === "nul";
+}
+
+function extractDeepInterviewCommandRedirectTargets(command: string): string[] {
+  const targets: string[] = [];
+  for (const match of command.matchAll(/(?:^|[^>])>{1,2}\s*(["']?)([^\s&|;<>]+)\1/g)) {
+    const candidate = safeString(match[2]).trim();
+    if (candidate && !isNullDeviceRedirectTarget(candidate)) targets.push(candidate);
+  }
+  return targets;
+}
+
 function commandHasDeepInterviewWriteIntent(command: string): boolean {
   return /\bapply_patch\b/.test(command)
-    || /(?:^|[;&|]\s*)(?:cat|printf|echo)\b[\s\S]{0,240}>\s*[^\s&|;]+/.test(command)
+    || extractDeepInterviewCommandRedirectTargets(command).length > 0
     || /\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)
@@ -2667,11 +2732,7 @@ function commandHasDeepInterviewWriteIntent(command: string): boolean {
 }
 
 function extractDeepInterviewCommandWriteTargets(command: string): string[] {
-  const targets: string[] = [];
-  for (const match of command.matchAll(/(?:^|[^>])>{1,2}\s*(["']?)([^\s&|;<>]+)\1/g)) {
-    const candidate = safeString(match[2]).trim();
-    if (candidate) targets.push(candidate);
-  }
+  const targets = extractDeepInterviewCommandRedirectTargets(command);
   for (const match of command.matchAll(/\btee\s+(?:-a\s+)?(["']?)([^\s&|;<>]+)\1/g)) {
     const candidate = safeString(match[2]).trim();
     if (candidate) targets.push(candidate);
@@ -3735,9 +3796,13 @@ async function buildStopHookOutput(
   const sessionId = readPayloadSessionId(payload);
   const canonicalSessionId = await resolveInternalSessionIdForPayload(cwd, sessionId);
   const threadId = readPayloadThreadId(payload);
+  const suppressParentWorkflowStop = shouldSuppressParentWorkflowStopForSideConversation(payload);
   if (canonicalSessionId) {
     await reconcileStaleRootSkillActiveStateForStop(cwd, stateDir, canonicalSessionId);
   }
+  if (suppressParentWorkflowStop) {
+    return null;
+  }
   const execFollowupOutput = await buildExecFollowupStopOutput(cwd, canonicalSessionId);
   if (execFollowupOutput) return execFollowupOutput;
   const ralphOwnerContext = {
@@ -4452,12 +4517,17 @@ function inferHookEventNameFromMalformedInput(raw: string): CodexHookEventName |
   return readHookEventName({ hook_event_name: value });
 }
 
-function buildMalformedStdinHookOutput(parseError: Error, rawInput: string): Record<string, unknown> {
+function buildMalformedStdinHookOutput(
+  parseError: Error,
+  rawInput: string,
+  cwd = process.cwd(),
+): Record<string, unknown> {
   const reason =
     "OMX native hook received malformed JSON input. Preserve runtime state, inspect the emitting hook payload yourself, and retry with valid JSON.";
   const systemMessage =
     `${reason} stdin JSON parsing failed inside codex-native-hook: ${parseError.message}.`;
-  if (inferHookEventNameFromMalformedInput(rawInput) === "Stop") {
+  const inferredHookEventName = inferHookEventNameFromMalformedInput(rawInput);
+  if (inferredHookEventName === "Stop" || (!inferredHookEventName && hasNativeStopRuntimeSurface(cwd))) {
     return {
       decision: "block",
       reason,
@@ -4603,7 +4673,7 @@ export async function runCodexNativeHookCli(): Promise<void> {
       {},
       buildRawInputLogFields(rawInput),
     );
-    writeNativeHookJsonStdout(buildMalformedStdinHookOutput(parseError, rawInput));
+    writeNativeHookJsonStdout(buildMalformedStdinHookOutput(parseError, rawInput, process.cwd()));
     return;
   }
 

package/src/scripts/notify-hook/team-worker-stop.ts

@@ -14,7 +14,7 @@ import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
 import { safeString, asNumber, isTerminalPhase } from './utils.js';
 import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
-import { evaluatePaneInjectionReadiness, queuePaneInput, sendPaneInput } from './team-tmux-guard.js';
+import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
 import { resolvePaneTarget } from './tmux-injection.js';
 import { readTeamWorkersForIdleCheck } from './team-worker.js';
 
@@ -147,6 +147,35 @@ async function resolveCanonicalLeaderPaneId(leaderPaneId) {
   return normalizedLeaderPaneId;
 }
 
+async function recordSuppressedWorkerStopNudge({
+  logsDir,
+  teamName,
+  workerName,
+  reason,
+}) {
+  const nowIso = new Date().toISOString();
+  await logTmuxHookEvent(logsDir, {
+    timestamp: nowIso,
+    type: 'worker_stop_leader_nudge_suppressed',
+    team: teamName,
+    worker: workerName,
+    to_worker: 'leader-fixed',
+    reason,
+    tmux_injection_attempted: false,
+    source_type: SOURCE_TYPE,
+  }).catch(() => {});
+  await appendTeamDeliveryLog(logsDir, {
+    event: 'nudge_triggered',
+    source: SOURCE_TYPE,
+    team: teamName,
+    from_worker: workerName,
+    to_worker: 'leader-fixed',
+    transport: 'none',
+    result: 'suppressed',
+    reason,
+  }).catch(() => {});
+}
+
 async function recordDeferred({
   stateDir,
   logsDir,
@@ -229,18 +258,34 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   };
   let tmuxSession = '';
   let leaderPaneId = '';
+  let recordedShutdownSuppression = false;
+  const recordShutdownSuppressionOnce = async () => {
+    if (recordedShutdownSuppression) return;
+    recordedShutdownSuppression = true;
+    await recordSuppressedWorkerStopNudge({
+      logsDir,
+      teamName,
+      workerName,
+      reason: TEAM_SHUTDOWN_NO_INJECTION_REASON,
+    });
+  };
 
   if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+    await recordShutdownSuppressionOnce();
     return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
   }
 
   const lock = await acquireTeamStopNudgeLock(teamDir, nowMs, cooldownMs);
   if (!lock.acquired) {
+    if (lock.reason === TEAM_SHUTDOWN_NO_INJECTION_REASON) {
+      await recordShutdownSuppressionOnce();
+    }
     return { ok: true, result: lock.reason || TEAM_LOCK_HELD_REASON };
   }
 
   try {
     if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      await recordShutdownSuppressionOnce();
       return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
     }
 
@@ -263,6 +308,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
 
   if (!tmuxTarget) {
     if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      await recordShutdownSuppressionOnce();
       return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
     }
     await recordDeferred({
@@ -287,6 +333,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   });
   if (!paneGuard.ok) {
     if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      await recordShutdownSuppressionOnce();
       return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
     }
     await recordDeferred({
@@ -305,6 +352,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   }
 
   if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+    await recordShutdownSuppressionOnce();
     return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
   }
 
@@ -314,23 +362,14 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     + DEFAULT_MARKER;
 
     const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
-    let deliveryMode = 'sent';
-    if (leaderHasActiveTask) {
-      const sendResult = await queuePaneInput({
-        paneTarget: tmuxTarget,
-        prompt,
-      });
-      if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
-      deliveryMode = 'queued';
-    } else {
-      const sendResult = await sendPaneInput({
-        paneTarget: tmuxTarget,
-        prompt,
-        submitKeyPresses: 2,
-        submitDelayMs: 100,
-      });
-      if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
-    }
+    const sendResult = await sendPaneInput({
+      paneTarget: tmuxTarget,
+      prompt,
+      submitKeyPresses: 2,
+      submitDelayMs: 100,
+    });
+    if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    const deliveryMode = leaderHasActiveTask ? 'steered' : 'sent';
 
     const deliveryState = {
       ...nextState,
@@ -376,6 +415,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     return { ok: true, result: deliveryMode };
   } catch (err) {
     if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      await recordShutdownSuppressionOnce();
       return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
     }
     // Worker Stop is already allowed before this helper runs; nudge failures are