oh-my-codex 0.20.3 → 0.21.0

package/src/scripts/notify-hook/team-leader-nudge.ts

@@ -24,6 +24,7 @@ import { readLatestTeamProgressEvidenceMs } from '../../team/progress-evidence.j
 import { validateSessionId } from '../../mcp/state-paths.js';
 import { TEAM_NAME_SAFE_PATTERN } from '../../team/contracts.js';
 import { isDeepInterviewStateActive } from './auto-nudge.js';
+import { registerTeamNotice, releaseTeamNoticeWake } from '../../team/notice-ledger.js';
 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';
@@ -1043,8 +1044,16 @@ export async function maybeNudgeTeamLeader({
       await recordShutdownSuppression(orchestrationIntent);
       continue;
     }
-    const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
-    const markedText = `${capped} ${DEFAULT_MARKER}`;
+    const noticeClass = nudgeReason === 'all_workers_idle'
+      || nudgeReason === 'done_waiting_on_leader'
+      || nudgeReason === 'stuck_waiting_on_leader'
+      ? 'all_idle'
+      : nudgeReason.includes('stale')
+        ? 'leader_stale'
+        : 'mailbox';
+    const noticeGeneration = noticeClass === 'mailbox' && newestId
+      ? newestId
+      : `${nudgeReason}:${progressSnapshot.signature}:${prevIdleAtIso || prevAtIso || 'initial'}`;
 
     if (!tmuxTarget) {
       if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
@@ -1148,7 +1157,7 @@ export async function maybeNudgeTeamLeader({
       continue;
     }
 
-    if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, capped)) {
+    if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, text)) {
       if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
         await recordShutdownSuppression(orchestrationIntent);
         continue;
@@ -1194,11 +1203,26 @@ export async function maybeNudgeTeamLeader({
       await recordShutdownSuppression(orchestrationIntent);
       continue;
     }
-
+    let queuedNoticeRegistration = null;
     try {
       const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
       let deliveryMode = 'sent';
+      let markedText = `${text.length > 180 ? `${text.slice(0, 177)}...` : text} ${DEFAULT_MARKER}`;
       if (leaderHasActiveTask) {
+        const noticeRegistration = await registerTeamNotice({
+          stateRoot: stateDir,
+          targetId: tmuxPaneOwnerId,
+          teamName,
+          noticeClass,
+          generation: noticeGeneration,
+          source: { kind: 'leader_nudge', detail: nudgeReason },
+        }).catch(() => null);
+        if (!noticeRegistration?.queued || !noticeRegistration.prompt) {
+          await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true });
+          continue;
+        }
+        markedText = `${noticeRegistration.prompt} ${DEFAULT_MARKER}`;
+        queuedNoticeRegistration = noticeRegistration;
         const sendResult = await sendPaneInput({
           paneTarget: tmuxTarget,
           prompt: markedText,
@@ -1214,6 +1238,7 @@ export async function maybeNudgeTeamLeader({
           throw new Error(sendResult.error || sendResult.reason);
         }
         deliveryMode = 'queued';
+        queuedNoticeRegistration = null;
       } else {
         const sendResult = await sendPaneInput({
           paneTarget: tmuxTarget,
@@ -1266,6 +1291,9 @@ export async function maybeNudgeTeamLeader({
         orchestration_intent: orchestrationIntent,
       }).catch(() => {});
     } catch (err) {
+      if (queuedNoticeRegistration?.targetKey && queuedNoticeRegistration?.wakeId) {
+        await releaseTeamNoticeWake(stateDir, queuedNoticeRegistration.targetKey, queuedNoticeRegistration.wakeId).catch(() => {});
+      }
       if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
         await recordShutdownSuppression(orchestrationIntent);
         continue;

package/src/scripts/notify-hook/team-tmux-guard.ts

@@ -386,6 +386,7 @@ export async function sendPaneInput({
   expectedPanePid = undefined,
   expectedPaneOwnerId = undefined,
   expectedHudPaneId = undefined,
+  submitKey = 'Enter',
 }: any): Promise<any> {
   const target = safeString(paneTarget).trim();
   if (!target) {
@@ -447,6 +448,7 @@ export async function sendPaneInput({
       prompt: literalPrompt,
       dryRun: false,
       submitKeyPresses: normalizedSubmitKeyPresses,
+      submitKey: safeString(submitKey).trim() || 'Enter',
     })?.submitArgv;
   if (!submitArgv) {
     return { ok: false, sent: false, reason: 'send_failed', paneTarget: target, exactPaneProof };
@@ -601,7 +603,7 @@ export async function queuePaneInput({
   };
   const submitArgv = [
     ['send-keys', '-t', target, 'Tab'],
-    ['send-keys', '-t', target, 'C-m'],
+    ['send-keys', '-t', target, 'Enter'],
   ];
   const firstSubmitProof = await verifyExplicitPane();
   if (!firstSubmitProof.ok) {

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

@@ -16,6 +16,7 @@ import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
 import { evaluatePaneInjectionReadiness, normalizeExactPaneId, sendPaneInput } from './team-tmux-guard.js';
 import { readTeamWorkersForIdleCheck } from './team-worker.js';
+import { registerTeamNotice, releaseTeamNoticeWake } from '../../team/notice-ledger.js';
 
 const STOP_NUDGE_COOLDOWN_MS = 30_000;
 const SOURCE_TYPE = 'worker_stop';
@@ -249,6 +250,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   let tmuxSession = '';
   let leaderPaneId = '';
   let recordedShutdownSuppression = false;
+  let queuedNoticeRegistration = null;
   const recordShutdownSuppressionOnce = async () => {
     if (recordedShutdownSuppression) return;
     recordedShutdownSuppression = true;
@@ -356,10 +358,23 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     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;
+  const leaderBusy = paneHasActiveTask(paneGuard.paneCapture);
+  let 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}`;
+  if (leaderBusy) {
+    const noticeRegistration = await registerTeamNotice({
+      stateRoot: stateDir,
+      targetId: leaderPaneOwnerId,
+      teamName,
+      noticeClass: 'worker_stop',
+      generation: `${nowIso}:${workerName}`,
+      source: { kind: SOURCE_TYPE, detail: workerName },
+    }).catch(() => null);
+    if (!noticeRegistration?.queued || !noticeRegistration.prompt) {
+      return { ok: true, result: 'coalesced' };
+    }
+    prompt = `${noticeRegistration.prompt} ${DEFAULT_MARKER}`;
+    queuedNoticeRegistration = noticeRegistration;
+  }
 
     const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
     const sendResult = await sendPaneInput({
@@ -373,6 +388,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
       expectedHudPaneId: teamInfo.hudPaneId,
     });
     if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    queuedNoticeRegistration = null;
     const deliveryMode = leaderHasActiveTask ? 'steered' : 'sent';
 
     const deliveryState = {
@@ -418,6 +434,9 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     }).catch(() => {});
     return { ok: true, result: deliveryMode };
   } catch (err) {
+    if (queuedNoticeRegistration?.targetKey && queuedNoticeRegistration?.wakeId) {
+      await releaseTeamNoticeWake(stateDir, queuedNoticeRegistration.targetKey, queuedNoticeRegistration.wakeId).catch(() => {});
+    }
     if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
       await recordShutdownSuppressionOnce();
       return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };

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

@@ -16,7 +16,8 @@ import {
   resolveAllWorkersIdleIntent,
   resolveWorkerIdleIntent,
 } from './orchestration-intent.js';
-import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
+import { DEFAULT_MARKER, paneHasActiveTask } from '../tmux-hook-engine.js';
+import { registerTeamNotice, releaseTeamNoticeWake } from '../../team/notice-ledger.js';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
 
 function positivePanePid(value) {
@@ -425,8 +426,6 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   }
 
   const N = workers.length;
-  const nextAction = `Run \`omx team status ${teamName}\` now, read unread worker messages, then assign the next concrete task, reconcile results, or shut the team down.`;
-  const message = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. ${nextAction} ${DEFAULT_MARKER}`;
   const tmuxTarget = canonicalLeaderPaneId;
   const paneGuard = await checkLeaderPaneReadyForWorkerStateReminder(tmuxTarget, canonicalLeaderPaneId, leaderPanePid, tmuxPaneOwnerId);
   if (!paneGuard.ok) {
@@ -454,6 +453,22 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
     });
     return;
   }
+  const leaderBusy = paneHasActiveTask(paneGuard.paneCapture);
+  let queuedNoticeRegistration = null;
+  let message = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. Run \`omx team status ${teamName}\` now, read unread worker messages, then assign the next concrete task, reconcile results, or shut the team down. ${DEFAULT_MARKER}`;
+  if (leaderBusy) {
+    const noticeRegistration = await registerTeamNotice({
+      stateRoot: stateDir,
+      targetId: tmuxPaneOwnerId,
+      teamName,
+      noticeClass: 'all_idle',
+      generation: `${nowIso}:${N}:${orchestrationIntent}`,
+      source: { kind: 'all_workers_idle', detail: orchestrationIntent },
+    }).catch(() => null);
+    if (!noticeRegistration?.queued || !noticeRegistration.prompt) return;
+    message = `${noticeRegistration.prompt} ${DEFAULT_MARKER}`;
+    queuedNoticeRegistration = noticeRegistration;
+  }
 
   try {
     const sendResult = await sendPaneInput({
@@ -467,6 +482,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       expectedHudPaneId: hudPaneId,
     });
     if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    queuedNoticeRegistration = null;
 
     const nextIdleState = {
       ...idleState,
@@ -503,6 +519,9 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       orchestration_intent: orchestrationIntent,
     });
   } catch (err) {
+    if (queuedNoticeRegistration?.targetKey && queuedNoticeRegistration?.wakeId) {
+      await releaseTeamNoticeWake(stateDir, queuedNoticeRegistration.targetKey, queuedNoticeRegistration.wakeId).catch(() => {});
+    }
     await logTmuxHookEvent(logsDir, {
       timestamp: nowIso,
       type: 'all_workers_idle_notification',
@@ -646,13 +665,28 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
     return;
   }
 
-  // Build notification message with context
+  // Build notification message with context. Busy panes use the durable ledger wake.
   const parts = [`[OMX] ${workerName} ${currentState}`];
   if (prevState && prevState !== 'unknown') parts.push(`(was: ${prevState})`);
   if (currentTaskId) parts.push(`task: ${currentTaskId}`);
   if (currentReason) parts.push(`reason: ${currentReason}`);
   parts.push(`Next: read ${workerName}'s latest message/output, then assign the next concrete step or mark the task complete.`);
-  const message = `${parts.join('. ')}. ${DEFAULT_MARKER}`;
+  const leaderBusy = paneHasActiveTask(paneGuard.paneCapture);
+  let queuedNoticeRegistration = null;
+  let message = `${parts.join('. ')}. ${DEFAULT_MARKER}`;
+  if (leaderBusy) {
+    const noticeRegistration = await registerTeamNotice({
+      stateRoot: stateDir,
+      targetId: tmuxPaneOwnerId,
+      teamName,
+      noticeClass: 'worker_idle',
+      generation: `${workerName}:${currentState}:${currentTaskId}:${safeString(heartbeat.last_turn_at)}`,
+      source: { kind: 'worker_idle', detail: orchestrationIntent },
+    }).catch(() => null);
+    if (!noticeRegistration?.queued || !noticeRegistration.prompt) return;
+    queuedNoticeRegistration = noticeRegistration;
+    message = `${noticeRegistration.prompt} ${DEFAULT_MARKER}`;
+  }
 
   try {
     const sendResult = await sendPaneInput({
@@ -666,6 +700,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       expectedHudPaneId: hudPaneId,
     });
     if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    queuedNoticeRegistration = null;
 
     // Update cooldown state
     try {
@@ -709,6 +744,9 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       orchestration_intent: orchestrationIntent,
     });
   } catch (err) {
+    if (queuedNoticeRegistration?.targetKey && queuedNoticeRegistration?.wakeId) {
+      await releaseTeamNoticeWake(stateDir, queuedNoticeRegistration.targetKey, queuedNoticeRegistration.wakeId).catch(() => {});
+    }
     await logTmuxHookEvent(logsDir, {
       timestamp: nowIso,
       type: 'worker_idle_notification',

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

@@ -37,6 +37,10 @@ import {
 } from '../tmux-hook-engine.js';
 import type { ResolvedPromptTurnContext } from '../../hooks/prompt-session-provenance.js';
 
+export function isNotifyModeStateFilename(file: string): boolean {
+  return file.endsWith('-state.json') && file !== 'tmux-hook-state.json' && file !== 'run-state.json';
+}
+
 function isHudPaneStartCommand(startCommand: any): boolean {
   return /\bomx\b.*\bhud\b.*--watch/i.test(safeString(startCommand));
 }
@@ -483,7 +487,7 @@ export async function handleTmuxInjection({ payload, cwd, stateDir, logsDir, con
 
       const files = await readdir(scopedDir).catch(() => []);
       for (const file of files) {
-        if (!file.endsWith('-state.json') || file === 'tmux-hook-state.json') continue;
+        if (!isNotifyModeStateFilename(file)) continue;
         const path = join(scopedDir, file);
         const parsed = JSON.parse(await readFile(path, 'utf-8'));
         if (parsed && parsed.active) {

package/src/scripts/notify-hook.ts

@@ -70,7 +70,6 @@ import {
 } from './notify-hook/auto-nudge.js';
 import { isManagedOmxSessionAtPromptContext } from './notify-hook/managed-tmux.js';
 import { logNotifyHookEvent } from './notify-hook/log.js';
-import { reconcileRalphSessionResume } from './notify-hook/ralph-session-resume.js';
 import { sendPaneInput } from './notify-hook/team-tmux-guard.js';
 import {
   buildOperationalContext,
@@ -550,6 +549,66 @@ async function resolveLeaderNotifyWriteDecision(
   };
 }
 
+async function dispatchTurnCompleteHookEvents(
+  payload: Record<string, any>,
+  cwd: string,
+  payloadSessionId: string,
+  sessionIdForHooks: string,
+): Promise<void> {
+  try {
+    const { buildNativeHookEvent, buildDerivedHookEvent } = await import('../hooks/extensibility/events.js');
+    const { dispatchHookEvent } = await import('../hooks/extensibility/dispatcher.js');
+    const threadIdForHooks = safeString(payload['thread-id'] || payload.thread_id || '');
+    const turnIdForHooks = safeString(payload['turn-id'] || payload.turn_id || '');
+    const modeForHooks = safeString(payload.mode || '');
+    const outputPreview = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '').slice(0, 400);
+    const event = buildNativeHookEvent('turn-complete', {
+      source: safeString(payload.source || 'native'),
+      type: safeString(payload.type || 'agent-turn-complete'),
+      input_messages: normalizeInputMessages(payload),
+      output_preview: outputPreview,
+      native_session_id: payloadSessionId || null,
+      omx_session_id: sessionIdForHooks || null,
+      ...readRepositoryMetadata(cwd),
+      session_name: resolveOperationalSessionName(cwd, sessionIdForHooks),
+      project_path: cwd,
+      project_name: safeString(payload.project_name || ''),
+    }, {
+      session_id: sessionIdForHooks,
+      thread_id: threadIdForHooks,
+      turn_id: turnIdForHooks,
+      mode: modeForHooks,
+    });
+    await dispatchHookEvent(event, { cwd });
+
+    for (const signal of deriveAssistantSignalEvents(outputPreview)) {
+      const derivedEvent = buildDerivedHookEvent(signal.event, buildOperationalContext({
+        cwd,
+        normalizedEvent: signal.normalized_event,
+        sessionId: sessionIdForHooks,
+        text: outputPreview,
+        status: signal.normalized_event,
+        errorSummary: signal.error_summary,
+        extra: {
+          native_session_id: payloadSessionId || null,
+          omx_session_id: sessionIdForHooks || null,
+          source_event: safeString(payload.type || 'agent-turn-complete'),
+        },
+      }), {
+        session_id: sessionIdForHooks,
+        thread_id: threadIdForHooks,
+        turn_id: turnIdForHooks,
+        mode: modeForHooks,
+        confidence: signal.confidence,
+        parser_reason: signal.parser_reason,
+      });
+      await dispatchHookEvent(derivedEvent, { cwd });
+    }
+  } catch {
+    // Non-fatal: extensibility modules may not be built yet
+  }
+}
+
 async function main() {
   const rawPayload = process.argv[process.argv.length - 1];
   if (!rawPayload || rawPayload.startsWith('-')) {
@@ -578,15 +637,26 @@ async function main() {
   const isTurnComplete = isTurnCompletePayload(payload);
   const isNotifyFallbackTaskComplete = isNotifyFallbackTaskCompletePayload(payload);
 
-  // Team worker detection via environment variable
-  const teamWorkerEnv = process.env.OMX_TEAM_INTERNAL_WORKER || process.env.OMX_TEAM_WORKER; // e.g., "fix-ts/worker-1"
-  const parsedTeamWorker = parseTeamWorkerEnv(teamWorkerEnv);
+  // Team worker detection is authorized only by a syntactically valid internal identity.
+  // Public OMX_TEAM_WORKER is a display alias and must never authorize worker or leader writes.
+  const rawInternalTeamWorker = safeString(process.env.OMX_TEAM_INTERNAL_WORKER).trim();
+  const rawPublicTeamWorker = safeString(process.env.OMX_TEAM_WORKER).trim();
+  const parsedInternalTeamWorker = parseTeamWorkerEnv(rawInternalTeamWorker);
+  const parsedPublicTeamWorker = parseTeamWorkerEnv(rawPublicTeamWorker);
+  const hasTeamWorkerDeclaration = rawInternalTeamWorker !== '' || rawPublicTeamWorker !== '';
+  if (hasTeamWorkerDeclaration && (!parsedInternalTeamWorker
+    || (rawPublicTeamWorker !== '' && !parsedPublicTeamWorker)
+    || (parsedPublicTeamWorker && parsedPublicTeamWorker.workerName !== parsedInternalTeamWorker.workerName))) {
+    return;
+  }
+  const parsedTeamWorker = parsedInternalTeamWorker;
   const isTeamWorker = !!parsedTeamWorker;
 
   const resolvedWorkerStateDir = (isTeamWorker && parsedTeamWorker)
     ? await resolveTeamStateDirForWorker(cwd, parsedTeamWorker)
     : null;
   const workerStateRootResolved = !isTeamWorker || !!resolvedWorkerStateDir;
+  if (isTeamWorker && !workerStateRootResolved) return;
   const stateDir = resolvedWorkerStateDir || getBaseStateDir(cwd);
   const logsDir = join(cwd, '.omx', 'logs');
   const omxDir = join(cwd, '.omx');
@@ -703,73 +773,8 @@ async function main() {
     return;
   }
 
-  if (isTeamWorker && !workerStateRootResolved) {
-    await logNotifyHookEvent(logsDir, {
-      timestamp: new Date().toISOString(),
-      level: 'warn',
-      type: 'team_worker_state_root_unresolved',
-      team_worker: teamWorkerEnv || null,
-      reason: 'skip_team_worker_state_mutations',
-    }).catch(() => {});
-
-    // Keep the fail-closed worker state-root behavior for normal team-worker
-    // mutations, but allow the narrow auto-nudge path to use an explicitly
-    // supplied, already-existing worker state root. Auto-nudge only needs the
-    // worker-scoped state files/pane anchor and should not fall back to creating
-    // local `.omx/state` when identity resolution failed.
-    const explicitWorkerStateRoot = safeString(process.env.OMX_TEAM_STATE_ROOT || '').trim();
-    const autoNudgeStateDir = explicitWorkerStateRoot ? resolve(cwd, explicitWorkerStateRoot) : '';
-    if (autoNudgeStateDir && existsSync(autoNudgeStateDir)) {
-      try {
-        await maybeAutoNudge({ cwd, stateDir: autoNudgeStateDir, logsDir, payload });
-      } catch {
-        // Non-critical
-      }
-    }
-    return;
-  }
 
-  // Reconcile Ralph ownership for same-Codex-session continuation before
-  // lifecycle counters or injection read the active scope.
-  if (!isTeamWorker && canWriteLeaderScopedState) {
-    try {
-      const resumeResult = await reconcileRalphSessionResume({
-        stateDir,
-        authorization: leaderAuthorization!,
-        env: {
-          ...process.env,
-          OMX_SESSION_ID: leaderAuthorization!.targetSessionId,
-          CODEX_SESSION_ID: '',
-          SESSION_ID: '',
-        },
-        payloadThreadId,
-      });
-      if (resumeResult.currentOmxSessionId && resumeResult.currentOmxSessionId === leaderAuthorization!.targetSessionId) {
-        currentOmxSessionId = resumeResult.currentOmxSessionId;
-      }
-      if (resumeResult.resumed || resumeResult.updatedCurrentOwner) {
-        await logNotifyHookEvent(logsDir, {
-          timestamp: new Date().toISOString(),
-          type: 'ralph_session_resume',
-          reason: resumeResult.reason,
-          current_omx_session_id: resumeResult.currentOmxSessionId || null,
-          payload_codex_session_id: payloadSessionId || null,
-          source_path: resumeResult.sourcePath || null,
-          target_path: resumeResult.targetPath || null,
-          owner_updated: resumeResult.updatedCurrentOwner,
-          resumed: resumeResult.resumed,
-        });
-      }
-    } catch (error) {
-      await logNotifyHookEvent(logsDir, {
-        timestamp: new Date().toISOString(),
-        level: 'warn',
-        type: 'ralph_session_resume_failure',
-        payload_codex_session_id: payloadSessionId || null,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
+  // #3497: ralph-session-resume gating deleted; notify-hook is notifications/team-dispatch only.
 
   // 2. Update active mode state (increment iteration)
   // GUARD: Skip when running inside a team worker to prevent state corruption
@@ -963,7 +968,6 @@ async function main() {
         }),
       });
     }
-
     try {
       skillSyncResult = await syncSkillStateFromTurn(
         stateDir,
@@ -1029,59 +1033,7 @@ async function main() {
   }
 
   // 7. Dispatch native turn-complete hook event (best effort, post-dedupe)
-  try {
-    const { buildNativeHookEvent, buildDerivedHookEvent } = await import('../hooks/extensibility/events.js');
-    const { dispatchHookEvent } = await import('../hooks/extensibility/dispatcher.js');
-    const sessionIdForHooks = getEffectiveSessionId();
-    const threadIdForHooks = safeString(payload['thread-id'] || payload.thread_id || '');
-    const turnIdForHooks = safeString(payload['turn-id'] || payload.turn_id || '');
-    const modeForHooks = safeString(payload.mode || '');
-    const outputPreview = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '').slice(0, 400);
-    const event = buildNativeHookEvent('turn-complete', {
-      source: safeString(payload.source || 'native'),
-      type: safeString(payload.type || 'agent-turn-complete'),
-      input_messages: normalizeInputMessages(payload),
-      output_preview: outputPreview,
-      native_session_id: payloadSessionId || null,
-      omx_session_id: sessionIdForHooks || null,
-      ...readRepositoryMetadata(cwd),
-      session_name: resolveOperationalSessionName(cwd, sessionIdForHooks),
-      project_path: cwd,
-      project_name: safeString(payload.project_name || ''),
-    }, {
-      session_id: sessionIdForHooks,
-      thread_id: threadIdForHooks,
-      turn_id: turnIdForHooks,
-      mode: modeForHooks,
-    });
-    await dispatchHookEvent(event, { cwd });
-
-    for (const signal of deriveAssistantSignalEvents(outputPreview)) {
-      const derivedEvent = buildDerivedHookEvent(signal.event, buildOperationalContext({
-        cwd,
-        normalizedEvent: signal.normalized_event,
-        sessionId: sessionIdForHooks,
-        text: outputPreview,
-        status: signal.normalized_event,
-        errorSummary: signal.error_summary,
-        extra: {
-          native_session_id: payloadSessionId || null,
-          omx_session_id: sessionIdForHooks || null,
-          source_event: safeString(payload.type || 'agent-turn-complete'),
-        },
-      }), {
-        session_id: sessionIdForHooks,
-        thread_id: threadIdForHooks,
-        turn_id: turnIdForHooks,
-        mode: modeForHooks,
-        confidence: signal.confidence,
-        parser_reason: signal.parser_reason,
-      });
-      await dispatchHookEvent(derivedEvent, { cwd });
-    }
-  } catch {
-    // Non-fatal: extensibility modules may not be built yet
-  }
+  await dispatchTurnCompleteHookEvents(payload, cwd, payloadSessionId, getEffectiveSessionId());
 
   // 8. Dispatch session-idle lifecycle notification (lead session only, best effort)
   if (!isTeamWorker) {

package/src/scripts/postinstall-advisory.ts

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { omxUserInstallStampPath } from '../utils/paths.js';
+
+export interface UserInstallStamp {
+  installed_version: string;
+  setup_completed_version?: string;
+  install_channel?: 'stable' | 'dev';
+  install_source?: string;
+  install_revision?: string;
+  dev_base_version?: string;
+  package_manager?: 'npm' | 'bun';
+  updated_at: string;
+}
+
+function stripLeadingV(version: string): string {
+  return version.trim().replace(/^v/i, '');
+}
+
+export async function readUserInstallStamp(
+  path = omxUserInstallStampPath(),
+): Promise<UserInstallStamp | null> {
+  if (!existsSync(path)) return null;
+  try {
+    const content = await readFile(path, 'utf-8');
+    const parsed = JSON.parse(content) as Partial<UserInstallStamp>;
+    if (typeof parsed.installed_version !== 'string' || typeof parsed.updated_at !== 'string') {
+      return null;
+    }
+    return {
+      installed_version: parsed.installed_version,
+      ...(typeof parsed.setup_completed_version === 'string'
+        ? { setup_completed_version: parsed.setup_completed_version }
+        : {}),
+      ...(parsed.install_channel === 'stable' || parsed.install_channel === 'dev'
+        ? { install_channel: parsed.install_channel }
+        : {}),
+      ...(typeof parsed.install_source === 'string' ? { install_source: parsed.install_source } : {}),
+      ...(typeof parsed.install_revision === 'string' ? { install_revision: parsed.install_revision } : {}),
+      ...(typeof parsed.dev_base_version === 'string' ? { dev_base_version: parsed.dev_base_version } : {}),
+      ...(parsed.package_manager === 'npm' || parsed.package_manager === 'bun'
+        ? { package_manager: parsed.package_manager }
+        : {}),
+      updated_at: parsed.updated_at,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function writeUserInstallStamp(
+  stamp: UserInstallStamp,
+  path = omxUserInstallStampPath(),
+): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(stamp, null, 2));
+}
+
+export function isInstallVersionBump(
+  currentVersion: string | null | undefined,
+  stamp: UserInstallStamp | null,
+): boolean {
+  if (!currentVersion) return false;
+  if (!stamp?.installed_version) return true;
+  return stripLeadingV(currentVersion) !== stripLeadingV(stamp.installed_version);
+}

package/src/scripts/postinstall.ts

@@ -6,7 +6,7 @@ import {
   readUserInstallStamp,
   type UserInstallStamp,
   writeUserInstallStamp,
-} from "../cli/update.js";
+} from './postinstall-advisory.js';
 import { getPackageRoot } from "../utils/package.js";
 
 type PostinstallStatus =