oh-my-codex 0.18.5 → 0.18.7

package/src/scripts/codex-native-pre-post.ts

@@ -1223,6 +1223,85 @@ function hasActionableBashHardFailure(normalized: NormalizedPostToolUsePayload):
   return containsHardFailure(`${normalized.stderrText}\n${normalized.stdoutText}`);
 }
 
+function isShellEnvAssignment(token: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token);
+}
+
+function shellCommandBasename(token: string): string {
+  const normalized = token.replace(/\\/g, "/");
+  return (normalized.split("/").pop() || normalized).toLowerCase();
+}
+
+function skipEnvWrapper(tokens: string[]): number {
+  let index = 0;
+  while (isShellEnvAssignment(tokens[index] || "")) index += 1;
+  if (!isEnvExecutableToken(tokens[index] || "")) return index;
+
+  index += 1;
+  while (index < tokens.length) {
+    const token = tokens[index] || "";
+    if (token === "--") {
+      index += 1;
+      break;
+    }
+    if (isShellEnvAssignment(token)) {
+      index += 1;
+      continue;
+    }
+    if (envOptionConsumesNextValue(token)) {
+      index += 2;
+      continue;
+    }
+    if (token === "-i" || token === "--ignore-environment" || token.startsWith("-u") && token.length > 2) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
+function skipGhGlobalOptions(tokens: string[], startIndex: number): number {
+  let index = startIndex;
+  const optionsWithValue = new Set(["--repo", "-R", "--hostname", "--config-dir"]);
+  while (index < tokens.length) {
+    const token = tokens[index] || "";
+    if (optionsWithValue.has(token)) {
+      index += 2;
+      continue;
+    }
+    if (/^(?:--repo|--hostname|--config-dir)=/.test(token)) {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-") && token !== "-") {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
+function isReviewableGhPrChecksTokens(tokens: string[]): boolean {
+  const commandIndex = skipEnvWrapper(tokens);
+  const basename = shellCommandBasename(tokens[commandIndex] || "");
+  if (basename !== "gh" && basename !== "gh.exe") return false;
+  const subcommandIndex = skipGhGlobalOptions(tokens, commandIndex + 1);
+  return tokens[subcommandIndex] === "pr" && tokens[subcommandIndex + 1] === "checks";
+}
+
+function isReviewableNonZeroBashCommand(command: string): boolean {
+  const boundaryTokens = tokenizeShellCommandWithBoundaries(removeHereDocBodies(command));
+  if (!boundaryTokens) return false;
+  for (let commandStart = 0; commandStart < boundaryTokens.length; commandStart = nextCommandStart(boundaryTokens, commandStart)) {
+    const commandEnd = nextCommandStart(boundaryTokens, commandStart);
+    const commandTokens = boundaryTokens.slice(commandStart, commandEnd).map((candidate) => candidate.value);
+    if (isReviewableGhPrChecksTokens(commandTokens)) return true;
+  }
+  return false;
+}
+
 export function buildNativePostToolUseOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
@@ -1264,6 +1343,7 @@ export function buildNativePostToolUseOutput(
     && normalized.exitCode !== 0
     && combined.length > 0
     && !containsHardFailure(combined)
+    && isReviewableNonZeroBashCommand(normalized.normalizedCommand)
   ) {
     return {
       decision: "block",

package/src/scripts/hook-payload-guard.ts

@@ -0,0 +1,113 @@
+export const MAX_NOTIFY_ARGV_JSON_BYTES = 64 * 1024;
+export const MAX_NATIVE_STDIN_JSON_BYTES = 1024 * 1024;
+export const RAW_JSON_FIELD_SCAN_BYTES = 64 * 1024;
+
+export const CODEX_HOOK_EVENT_NAMES = [
+  "SessionStart",
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "PreCompact",
+  "PostCompact",
+  "Stop",
+] as const;
+
+export type RawCodexHookEventName = typeof CODEX_HOOK_EVENT_NAMES[number];
+
+export function utf8ByteLength(value: string): number {
+  return Buffer.byteLength(value, "utf-8");
+}
+
+function skipJsonWhitespace(raw: string, index: number): number {
+  while (index < raw.length && /\s/.test(raw[index] ?? "")) index += 1;
+  return index;
+}
+
+function readJsonStringLiteral(raw: string, quoteIndex: number): { value: string; endIndex: number } | null {
+  if (raw[quoteIndex] !== '"') return null;
+  let value = "";
+  for (let index = quoteIndex + 1; index < raw.length; index += 1) {
+    const char = raw[index];
+    if (char === '"') return { value, endIndex: index + 1 };
+    if (char !== "\\") {
+      value += char;
+      continue;
+    }
+
+    index += 1;
+    if (index >= raw.length) return null;
+    const escaped = raw[index];
+    switch (escaped) {
+      case '"':
+      case "\\":
+      case "/":
+        value += escaped;
+        break;
+      case "b":
+        value += "\b";
+        break;
+      case "f":
+        value += "\f";
+        break;
+      case "n":
+        value += "\n";
+        break;
+      case "r":
+        value += "\r";
+        break;
+      case "t":
+        value += "\t";
+        break;
+      case "u": {
+        const hex = raw.slice(index + 1, index + 5);
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+        value += String.fromCharCode(Number.parseInt(hex, 16));
+        index += 4;
+        break;
+      }
+      default:
+        return null;
+    }
+  }
+  return null;
+}
+
+export function extractRawJsonStringField(rawInput: string, fieldNames: readonly string[]): string | null {
+  const raw = rawInput.slice(0, RAW_JSON_FIELD_SCAN_BYTES);
+  const wanted = new Set(fieldNames);
+  let depth = 0;
+  let index = 0;
+
+  while (index < raw.length) {
+    const char = raw[index];
+    if (char === '"') {
+      const key = readJsonStringLiteral(raw, index);
+      if (!key) return null;
+      index = key.endIndex;
+      const afterKey = skipJsonWhitespace(raw, index);
+      if (depth === 1 && raw[afterKey] === ":" && wanted.has(key.value)) {
+        const valueStart = skipJsonWhitespace(raw, afterKey + 1);
+        const value = readJsonStringLiteral(raw, valueStart);
+        return value?.value ?? null;
+      }
+      continue;
+    }
+    if (char === "{") depth += 1;
+    else if (char === "}") depth = Math.max(0, depth - 1);
+    index += 1;
+  }
+
+  return null;
+}
+
+export function extractRawCodexHookEventName(rawInput: string): RawCodexHookEventName | null {
+  const raw = extractRawJsonStringField(rawInput, [
+    "hook_event_name",
+    "hookEventName",
+    "event",
+    "name",
+  ]);
+  return CODEX_HOOK_EVENT_NAMES.includes(raw as RawCodexHookEventName)
+    ? raw as RawCodexHookEventName
+    : null;
+}

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

@@ -1963,10 +1963,15 @@ function shutdown(signal: string): void {
 }
 
 async function main(): Promise<void> {
+  if (process.env.NODE_ENV === 'test' && process.env.OMX_NOTIFY_FALLBACK_TEST_FATAL === '1') {
+    throw new Error('test fatal notify fallback failure');
+  }
   await mkdir(logsDir, { recursive: true }).catch(() => {});
   await mkdir(stateDir, { recursive: true }).catch(() => {});
   if (!existsSync(notifyScript)) {
+    const reason = `notify script missing: ${notifyScript}`;
     await eventLog({ type: 'watcher_error', reason: 'notify_script_missing', notify_script: notifyScript });
+    process.stderr.write(`notify-fallback-watcher: ${reason}\n`);
     process.exit(1);
   }
 
@@ -2006,10 +2011,12 @@ async function main(): Promise<void> {
 
 main().catch(async (err) => {
   await mkdir(dirname(logPath), { recursive: true }).catch(() => {});
+  const message = err instanceof Error ? err.message : safeString(err);
   await eventLog({
     type: 'watcher_error',
     reason: 'fatal',
-    error: err instanceof Error ? err.message : safeString(err),
+    error: message,
   });
+  process.stderr.write(`notify-fallback-watcher: fatal: ${message || 'unknown error'}\n`);
   process.exit(1);
 });

package/src/scripts/notify-hook/__tests__/payload-guard.test.ts

@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it } from 'node:test';
+import { MAX_NOTIFY_ARGV_JSON_BYTES } from '../../hook-payload-guard.js';
+
+function notifyHookScriptPath(): string {
+  return join(process.cwd(), 'dist', 'scripts', 'notify-hook.js');
+}
+
+describe('notify-hook raw payload guard', () => {
+  it('ignores oversized argv JSON before parsing or writing hook state', async () => {
+    const cwd = await mkdtemp(join(tmpdir(), 'omx-notify-hook-oversized-'));
+    try {
+      await mkdir(join(cwd, '.omx'), { recursive: true });
+      await writeFile(join(cwd, '.omx', 'setup-scope.json'), '{}', 'utf-8');
+      const payload = JSON.stringify({
+        cwd,
+        type: 'agent-turn-complete',
+        session_id: 'sess-notify-oversized',
+        turn_id: 'turn-notify-oversized',
+        input_messages: ['hello'],
+        last_assistant_message: 'x'.repeat(MAX_NOTIFY_ARGV_JSON_BYTES + 1),
+      });
+
+      execFileSync(process.execPath, [notifyHookScriptPath(), payload], {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+      });
+
+      assert.equal(existsSync(join(cwd, '.omx', 'logs')), false);
+      assert.equal(existsSync(join(cwd, '.omx', 'state')), false);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -6,11 +6,12 @@
  * It must not depend on idle/heartbeat freshness or inferred progress stalls.
  */
 
-import { appendFile, mkdir, rename, writeFile } from 'fs/promises';
-import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { appendFile, mkdir, rename, rm, stat, writeFile } from 'fs/promises';
+import { dirname, join, relative } from 'path';
 import { DEFAULT_MARKER, paneHasActiveTask } from '../tmux-hook-engine.js';
 import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
-import { safeString, asNumber } from './utils.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';
@@ -21,6 +22,110 @@ const STOP_NUDGE_COOLDOWN_MS = 30_000;
 const SOURCE_TYPE = 'worker_stop';
 const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
+const TEAM_SHUTDOWN_NO_INJECTION_REASON = 'team_state_gone_or_shutdown';
+const TEAM_LOCK_HELD_REASON = 'suppressed_team_lock_held';
+
+async function teamStateAllowsWorkerStopNudge(stateDir, teamName) {
+  const teamDir = join(stateDir, 'team', teamName);
+  if (!existsSync(teamDir)) return false;
+  if (existsSync(join(teamDir, 'shutdown.json'))) return false;
+
+  const phase = await readJsonIfExists(join(teamDir, 'phase.json'), null);
+  const currentPhase = safeString(phase?.current_phase || phase?.phase || '').trim();
+  if (currentPhase && isTerminalPhase(currentPhase)) return false;
+
+  return true;
+}
+
+async function acquireTeamStopNudgeLock(teamDir, nowMs, cooldownMs) {
+  const lockDir = join(teamDir, 'worker-stop-nudge.lock');
+  const staleAfterMs = Math.max(cooldownMs, 30_000);
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await mkdir(lockDir);
+      await writeFile(join(lockDir, 'owner.json'), JSON.stringify({
+        pid: process.pid,
+        acquired_at_ms: nowMs,
+        acquired_at: new Date(nowMs).toISOString(),
+      }, null, 2)).catch(() => {});
+      return { acquired: true, lockDir };
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { acquired: false, reason: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+      if (error?.code !== 'EEXIST') return { acquired: false, reason: TEAM_LOCK_HELD_REASON };
+
+      try {
+        const lockStat = await stat(lockDir);
+        if ((nowMs - lockStat.mtimeMs) >= staleAfterMs) {
+          await rm(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      return { acquired: false, reason: TEAM_LOCK_HELD_REASON };
+    }
+  }
+
+  return { acquired: false, reason: TEAM_LOCK_HELD_REASON };
+}
+
+async function releaseTeamStopNudgeLock(lockDir) {
+  if (!lockDir) return;
+  await rm(lockDir, { recursive: true, force: true }).catch(() => {});
+}
+
+async function ensureDirectoryUnderExistingTeam(teamDir, targetDir) {
+  if (!existsSync(teamDir)) return false;
+  const rel = relative(teamDir, targetDir);
+  if (!rel) return true;
+  if (rel.startsWith('..')) throw new Error('state_path_outside_team_dir');
+
+  let current = teamDir;
+  for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
+    if (!existsSync(teamDir)) return false;
+    current = join(current, segment);
+    try {
+      await mkdir(current);
+    } catch (error) {
+      if (error?.code === 'ENOENT' && !existsSync(teamDir)) return false;
+      if (error?.code !== 'EEXIST') throw error;
+      const currentStat = await stat(current);
+      if (!currentStat.isDirectory()) throw error;
+    }
+  }
+  return existsSync(teamDir);
+}
+
+async function writeStopNudgeStateIfTeamExists(teamDir, statePath, state) {
+  const stateDir = dirname(statePath);
+  const ready = await ensureDirectoryUnderExistingTeam(teamDir, stateDir);
+  if (!ready) return false;
+  try {
+    const tmpPath = `${statePath}.tmp.${process.pid}`;
+    await writeFile(tmpPath, JSON.stringify(state, null, 2));
+    await rename(tmpPath, statePath);
+  } catch (error) {
+    if (error?.code === 'ENOENT' && !existsSync(teamDir)) return false;
+    throw error;
+  }
+  return existsSync(teamDir);
+}
+
+async function appendWorkerStopEventIfTeamExists(stateDir, teamName, event) {
+  const teamDir = join(stateDir, 'team', teamName);
+  const eventsDir = join(teamDir, 'events');
+  const ready = await ensureDirectoryUnderExistingTeam(teamDir, eventsDir);
+  if (!ready) return false;
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  try {
+    await appendFile(eventsPath, JSON.stringify(event) + '\n');
+  } catch (error) {
+    if (error?.code === 'ENOENT' && !existsSync(teamDir)) return false;
+    throw error;
+  }
+  return existsSync(teamDir);
+}
 
 function resolveWorkerStopCooldownMs() {
   const raw = safeString(process.env.OMX_TEAM_WORKER_STOP_COOLDOWN_MS || '');
@@ -42,20 +147,6 @@ async function resolveCanonicalLeaderPaneId(leaderPaneId) {
   return normalizedLeaderPaneId;
 }
 
-async function appendWorkerStopEvent(stateDir, teamName, event) {
-  const eventsDir = join(stateDir, 'team', teamName, 'events');
-  const eventsPath = join(eventsDir, 'events.ndjson');
-  await mkdir(eventsDir, { recursive: true }).catch(() => {});
-  await appendFile(eventsPath, JSON.stringify(event) + '\n').catch(() => {});
-}
-
-async function writeStopNudgeState(statePath, state) {
-  await mkdir(dirname(statePath), { recursive: true }).catch(() => {});
-  const tmpPath = `${statePath}.tmp.${process.pid}`;
-  await writeFile(tmpPath, JSON.stringify(state, null, 2));
-  await rename(tmpPath, statePath);
-}
-
 async function recordDeferred({
   stateDir,
   logsDir,
@@ -69,23 +160,26 @@ async function recordDeferred({
   paneCurrentCommand = '',
 }) {
   const nowIso = nextState.last_notified_at;
-  await writeStopNudgeState(statePath, {
+  const teamDir = join(stateDir, 'team', teamName);
+  const wroteState = await writeStopNudgeStateIfTeamExists(teamDir, statePath, {
     ...nextState,
     delivery: 'deferred',
     reason,
     pane_current_command: paneCurrentCommand || null,
   }).catch(() => {});
-  await appendWorkerStopEvent(stateDir, teamName, {
-    event_id: `worker-stop-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
-    team: teamName,
-    type: 'worker_stop_leader_nudge',
-    worker: workerName,
-    to_worker: 'leader-fixed',
-    delivery: 'deferred',
-    reason,
-    created_at: nowIso,
-    source_type: SOURCE_TYPE,
-  });
+  if (wroteState) {
+    await appendWorkerStopEventIfTeamExists(stateDir, teamName, {
+      event_id: `worker-stop-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+      team: teamName,
+      type: 'worker_stop_leader_nudge',
+      worker: workerName,
+      to_worker: 'leader-fixed',
+      delivery: 'deferred',
+      reason,
+      created_at: nowIso,
+      source_type: SOURCE_TYPE,
+    }).catch(() => {});
+  }
   await logTmuxHookEvent(logsDir, {
     timestamp: nowIso,
     type: 'leader_notification_deferred',
@@ -119,30 +213,58 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   const { teamName, workerName } = workerContext || {};
   if (!teamName || !workerName || !stateDir) return { ok: false, result: 'unresolved' };
 
-  const workerDir = join(stateDir, 'team', teamName, 'workers', workerName);
+  const teamDir = join(stateDir, 'team', teamName);
+  const workerDir = join(teamDir, 'workers', workerName);
   const statePath = join(workerDir, 'worker-stop-nudge.json');
+  const teamStatePath = join(teamDir, 'worker-stop-nudge.json');
   const nowMs = Date.now();
   const nowIso = new Date(nowMs).toISOString();
+  const cooldownMs = resolveWorkerStopCooldownMs();
+  const nextState = {
+    last_notified_at_ms: nowMs,
+    last_notified_at: nowIso,
+    team: teamName,
+    worker: workerName,
+    source_type: SOURCE_TYPE,
+  };
+  let tmuxSession = '';
+  let leaderPaneId = '';
+
+  if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+    return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+  }
+
+  const lock = await acquireTeamStopNudgeLock(teamDir, nowMs, cooldownMs);
+  if (!lock.acquired) {
+    return { ok: true, result: lock.reason || TEAM_LOCK_HELD_REASON };
+  }
+
+  try {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
+
+  const teamExisting = (await readJsonIfExists(teamStatePath, null)) || {};
+  const teamLastNotifiedMs = asNumber(teamExisting.last_notified_at_ms) ?? 0;
+  if ((nowMs - teamLastNotifiedMs) < cooldownMs) {
+    return { ok: true, result: 'suppressed_team_cooldown' };
+  }
+
   const existing = (await readJsonIfExists(statePath, null)) || {};
   const lastNotifiedMs = asNumber(existing.last_notified_at_ms) ?? 0;
-  const cooldownMs = resolveWorkerStopCooldownMs();
   if ((nowMs - lastNotifiedMs) < cooldownMs) {
     return { ok: true, result: 'suppressed_cooldown' };
   }
 
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return { ok: false, result: 'unresolved' };
-  const { tmuxSession, leaderPaneId } = teamInfo;
+  ({ tmuxSession, leaderPaneId } = teamInfo);
   const tmuxTarget = await resolveCanonicalLeaderPaneId(leaderPaneId);
-  const nextState = {
-    last_notified_at_ms: nowMs,
-    last_notified_at: nowIso,
-    team: teamName,
-    worker: workerName,
-    source_type: SOURCE_TYPE,
-  };
 
   if (!tmuxTarget) {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
     await recordDeferred({
       stateDir,
       logsDir,
@@ -164,6 +286,9 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     requireIdle: false,
   });
   if (!paneGuard.ok) {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
     await recordDeferred({
       stateDir,
       logsDir,
@@ -179,12 +304,15 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     return { ok: true, result: 'deferred' };
   }
 
+  if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+    return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+  }
+
   const prompt =
     `[OMX] ${workerName} native Stop allowed. `
     + `Run \`omx team status ${teamName}\`, read worker messages/results, then assign next task, reconcile completion, or shut down. `
     + DEFAULT_MARKER;
 
-  try {
     const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
     let deliveryMode = 'sent';
     if (leaderHasActiveTask) {
@@ -204,22 +332,28 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
       if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
     }
 
-    await writeStopNudgeState(statePath, {
+    const deliveryState = {
       ...nextState,
       delivery: deliveryMode,
       leader_pane_id: leaderPaneId || null,
       tmux_target: tmuxTarget,
-    });
-    await appendWorkerStopEvent(stateDir, teamName, {
-      event_id: `worker-stop-nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
-      team: teamName,
-      type: 'worker_stop_leader_nudge',
-      worker: workerName,
-      to_worker: 'leader-fixed',
-      delivery: deliveryMode,
-      created_at: nowIso,
-      source_type: SOURCE_TYPE,
-    });
+    };
+    const wroteWorkerState = await writeStopNudgeStateIfTeamExists(teamDir, statePath, deliveryState);
+    const wroteTeamState = wroteWorkerState
+      ? await writeStopNudgeStateIfTeamExists(teamDir, teamStatePath, deliveryState)
+      : false;
+    if (wroteTeamState) {
+      await appendWorkerStopEventIfTeamExists(stateDir, teamName, {
+        event_id: `worker-stop-nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+        team: teamName,
+        type: 'worker_stop_leader_nudge',
+        worker: workerName,
+        to_worker: 'leader-fixed',
+        delivery: deliveryMode,
+        created_at: nowIso,
+        source_type: SOURCE_TYPE,
+      }).catch(() => {});
+    }
     await logTmuxHookEvent(logsDir, {
       timestamp: nowIso,
       type: 'worker_stop_leader_nudge',
@@ -241,6 +375,11 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     }).catch(() => {});
     return { ok: true, result: deliveryMode };
   } catch (err) {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
+    // Worker Stop is already allowed before this helper runs; nudge failures are
+    // surfaced as deferred operational evidence instead of re-blocking Stop.
     await recordDeferred({
       stateDir,
       logsDir,
@@ -253,5 +392,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
       leaderPaneId,
     });
     return { ok: true, result: 'deferred' };
+  } finally {
+    await releaseTeamStopNudgeLock(lock.lockDir);
   }
 }

package/src/scripts/notify-hook.ts

@@ -68,6 +68,11 @@ import {
 } from './notify-hook/team-worker.js';
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 import { sameFilePath } from '../utils/paths.js';
+import {
+  MAX_NOTIFY_ARGV_JSON_BYTES,
+  extractRawJsonStringField,
+  utf8ByteLength,
+} from './hook-payload-guard.js';
 
 const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
   'start',
@@ -285,6 +290,9 @@ async function main() {
   if (!rawPayload || rawPayload.startsWith('-')) {
     process.exit(0);
   }
+  if (utf8ByteLength(rawPayload) > MAX_NOTIFY_ARGV_JSON_BYTES) {
+    process.exit(0);
+  }
 
   let payload;
   try {
@@ -909,8 +917,12 @@ async function logFatalNotifyHookError(err: unknown): Promise<void> {
   try {
     const rawPayload = process.argv[process.argv.length - 1];
     if (rawPayload && !rawPayload.startsWith('-')) {
-      const payload = JSON.parse(rawPayload) as Record<string, unknown>;
-      cwd = safeString(payload.cwd || payload['cwd'] || cwd) || cwd;
+      if (utf8ByteLength(rawPayload) <= MAX_NOTIFY_ARGV_JSON_BYTES) {
+        const payload = JSON.parse(rawPayload) as Record<string, unknown>;
+        cwd = safeString(payload.cwd || payload['cwd'] || cwd) || cwd;
+      } else {
+        cwd = extractRawJsonStringField(rawPayload, ['cwd']) || cwd;
+      }
     }
   } catch {
     // Keep notification hook failures silent in Codex TUI surfaces.