oh-my-codex 0.20.2 → 0.20.5

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

@@ -10,16 +10,21 @@ import { resolveWorkerNotifyTeamStateRootPath } from '../../team/state-root.js';
 import { asNumber, safeString, isTerminalPhase } from './utils.js';
 import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
-import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
-import { resolvePaneTarget } from './tmux-injection.js';
+import { evaluatePaneInjectionReadiness, normalizeExactPaneId, sendPaneInput } from './team-tmux-guard.js';
 import {
   classifyLeaderActionState,
   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) {
+  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : undefined;
+}
+
+
 export async function resolveTeamStateDirForWorker(cwd, parsedTeamWorker) {
   return resolveWorkerNotifyTeamStateRootPath(cwd, parsedTeamWorker, process.env);
 }
@@ -216,8 +221,11 @@ export async function readTeamWorkersForIdleCheck(stateDir, teamName) {
       if (!Array.isArray(workers) || workers.length === 0) continue;
       const tmuxSession = safeString(parsed.tmux_session || '').trim();
       const leaderPaneId = safeString(parsed.leader_pane_id || '').trim();
-      const result = { workers, tmuxSession, leaderPaneId };
-      if (leaderPaneId) return result;
+      const hudPaneId = safeString(parsed.hud_pane_id || '').trim();
+      const leaderPanePid = positivePanePid(parsed.leader_pane_pid);
+      const tmuxPaneOwnerId = safeString(parsed.tmux_pane_owner_id || '').trim();
+      const result = { workers, tmuxSession, leaderPaneId, leaderPanePid, tmuxPaneOwnerId, hudPaneId };
+      if (leaderPaneId && leaderPanePid && tmuxPaneOwnerId) return result;
       if (!fallback) fallback = result;
     } catch {
       // Try the next state source.
@@ -253,22 +261,11 @@ async function readTeamTaskCounts(stateDir, teamName) {
   return taskCounts;
 }
 
-async function resolveCanonicalLeaderPaneId(_tmuxSession, leaderPaneId) {
-  const normalizedLeaderPaneId = safeString(leaderPaneId).trim();
-  if (normalizedLeaderPaneId) {
-    try {
-      const resolved = await resolvePaneTarget({ type: 'pane', value: normalizedLeaderPaneId }, '', '', '', {});
-      const paneTarget = safeString(resolved?.paneTarget).trim();
-      if (paneTarget) return paneTarget;
-    } catch {
-      // fall through to tmux session scan
-    }
-    return normalizedLeaderPaneId;
-  }
-  return '';
+function resolveCanonicalLeaderPaneId(_tmuxSession, leaderPaneId) {
+  return normalizeExactPaneId(leaderPaneId);
 }
 
-async function checkLeaderPaneReadyForWorkerStateReminder(paneTarget) {
+async function checkLeaderPaneReadyForWorkerStateReminder(paneTarget, exactPaneId, expectedPanePid, expectedPaneOwnerId) {
   return evaluatePaneInjectionReadiness(paneTarget, {
     skipIfScrolling: true,
     // Worker-state reminders are their own trigger path. They should still
@@ -277,6 +274,9 @@ async function checkLeaderPaneReadyForWorkerStateReminder(paneTarget) {
     requireRunningAgent: true,
     requireReady: false,
     requireIdle: false,
+    exactPaneId,
+    expectedPanePid,
+    expectedPaneOwnerId,
   });
 }
 
@@ -367,8 +367,11 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   // Read team config to get worker list and leader tmux target
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
-  const { workers, tmuxSession, leaderPaneId } = teamInfo;
-  const canonicalLeaderPaneId = await resolveCanonicalLeaderPaneId(tmuxSession, leaderPaneId);
+  const { workers, tmuxSession, leaderPaneId, leaderPanePid, tmuxPaneOwnerId, hudPaneId } = teamInfo;
+  const resolvedLeaderPaneId = await resolveCanonicalLeaderPaneId(tmuxSession, leaderPaneId);
+  const canonicalLeaderPaneId = resolvedLeaderPaneId && resolvedLeaderPaneId !== normalizeExactPaneId(hudPaneId)
+    ? resolvedLeaderPaneId
+    : '';
 
   // Check cooldown to prevent notification spam
   const idleStatePath = join(stateDir, 'team', teamName, 'all-workers-idle.json');
@@ -399,7 +402,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   });
   const orchestrationIntent = resolveAllWorkersIdleIntent(leaderActionState);
 
-  if (!canonicalLeaderPaneId) {
+  if (!canonicalLeaderPaneId || !positivePanePid(leaderPanePid) || !tmuxPaneOwnerId) {
     const nextIdleState = {
       ...idleState,
       last_notified_at_ms: nowMs,
@@ -423,10 +426,8 @@ 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);
+  const paneGuard = await checkLeaderPaneReadyForWorkerStateReminder(tmuxTarget, canonicalLeaderPaneId, leaderPanePid, tmuxPaneOwnerId);
   if (!paneGuard.ok) {
     const nextIdleState = {
       ...idleState,
@@ -452,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({
@@ -459,8 +476,13 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       prompt: message,
       submitKeyPresses: 2,
       submitDelayMs: 100,
+      exactPaneId: canonicalLeaderPaneId,
+      expectedPanePid: leaderPanePid,
+      expectedPaneOwnerId: tmuxPaneOwnerId,
+      expectedHudPaneId: hudPaneId,
     });
     if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    queuedNoticeRegistration = null;
 
     const nextIdleState = {
       ...idleState,
@@ -497,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',
@@ -591,10 +616,13 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
   // Read team config for tmux target
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
-  const { tmuxSession, leaderPaneId } = teamInfo;
-  const canonicalLeaderPaneId = await resolveCanonicalLeaderPaneId(tmuxSession, leaderPaneId);
+  const { tmuxSession, leaderPaneId, leaderPanePid, tmuxPaneOwnerId, hudPaneId } = teamInfo;
+  const resolvedLeaderPaneId = await resolveCanonicalLeaderPaneId(tmuxSession, leaderPaneId);
+  const canonicalLeaderPaneId = resolvedLeaderPaneId && resolvedLeaderPaneId !== normalizeExactPaneId(hudPaneId)
+    ? resolvedLeaderPaneId
+    : '';
 
-  if (!canonicalLeaderPaneId) {
+  if (!canonicalLeaderPaneId || !positivePanePid(leaderPanePid) || !tmuxPaneOwnerId) {
     await emitLeaderPaneMissingDeferred({
       stateDir,
       logsDir,
@@ -608,7 +636,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
     return;
   }
   const tmuxTarget = canonicalLeaderPaneId;
-  const paneGuard = await checkLeaderPaneReadyForWorkerStateReminder(tmuxTarget);
+  const paneGuard = await checkLeaderPaneReadyForWorkerStateReminder(tmuxTarget, canonicalLeaderPaneId, leaderPanePid, tmuxPaneOwnerId);
   if (!paneGuard.ok) {
     try {
       const tmpPath = cooldownPath + '.tmp.' + process.pid;
@@ -637,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({
@@ -651,8 +694,13 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       prompt: message,
       submitKeyPresses: 2,
       submitDelayMs: 100,
+      exactPaneId: canonicalLeaderPaneId,
+      expectedPanePid: leaderPanePid,
+      expectedPaneOwnerId: tmuxPaneOwnerId,
+      expectedHudPaneId: hudPaneId,
     });
     if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    queuedNoticeRegistration = null;
 
     // Update cooldown state
     try {
@@ -696,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) {
@@ -687,9 +691,11 @@ export async function handleTmuxInjection({ payload, cwd, stateDir, logsDir, con
 
   // Shared pane-state guard: skip injection when the target pane is scrolling,
   // has returned to a shell, is still bootstrapping, or is visibly busy.
+  let readinessPanePid: number | undefined;
   try {
     const paneGuard = await evaluatePaneInjectionReadiness(paneTarget, {
       skipIfScrolling: config.skip_if_scrolling,
+      exactPaneId: paneTarget,
     });
     if (!paneGuard.ok) {
       const reason = mapPaneInjectionReadinessReason(paneGuard.reason);
@@ -706,8 +712,30 @@ export async function handleTmuxInjection({ payload, cwd, stateDir, logsDir, con
       });
       return;
     }
-  } catch {
-    // Non-fatal: if querying pane state fails, proceed with injection.
+    readinessPanePid = asNumber(paneGuard.exactPaneProof?.pid);
+    if (!Number.isInteger(readinessPanePid) || readinessPanePid <= 0) {
+      state.last_reason = 'pane_readiness_unverified';
+      state.last_event_at = nowIso;
+      await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+      await logTmuxHookEvent(logsDir, {
+        ...baseLog,
+        event: 'injection_skipped',
+        reason: 'pane_readiness_unverified',
+        pane_target: paneTarget,
+      });
+      return;
+    }
+  } catch (error) {
+    const reason = `pane_proof_unavailable:${error instanceof Error ? error.message : String(error)}`;
+    updateStateForAttempt(false, reason);
+    await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+    await logTmuxHookEvent(logsDir, {
+      ...baseLog,
+      event: 'injection_skipped',
+      reason,
+      pane_target: paneTarget,
+    });
+    return;
   }
 
   if (config.dry_run) {
@@ -727,6 +755,8 @@ export async function handleTmuxInjection({ payload, cwd, stateDir, logsDir, con
     const sendResult = await sendPaneInput({
       paneTarget,
       prompt,
+      exactPaneId: paneTarget,
+      expectedPanePid: readinessPanePid,
       submitKeyPresses: argv.submitArgv.length,
       submitDelayMs: 25,
     });

package/src/scripts/notify-hook.ts

@@ -550,6 +550,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 +638,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,31 +774,6 @@ 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.
@@ -942,8 +988,9 @@ async function main() {
 
   // 4.45. Skill activation tracking: update skill-active-state.json before any nudge logic.
   if (isTeamWorker || canWriteLeaderScopedState) {
+    let activationResult: SkillActiveState | null = null;
     if (latestUserInput) {
-      await recordNotifySkillActivationNonFatal({
+      activationResult = await recordNotifySkillActivationNonFatal({
         stateDir,
         sourceCwd: cwd,
         text: latestUserInput,
@@ -963,6 +1010,12 @@ async function main() {
         }),
       });
     }
+    if (activationResult?.skill === 'autopilot'
+      && activationResult.active === false
+      && activationResult.error === 'documented_host_consensus_receipt_unavailable') {
+      await dispatchTurnCompleteHookEvents(payload, cwd, payloadSessionId, getEffectiveSessionId());
+      return;
+    }
 
     try {
       skillSyncResult = await syncSkillStateFromTurn(
@@ -1029,59 +1082,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) {
@@ -1218,6 +1219,7 @@ async function main() {
             const csText = `${csResult.message} ${DEFAULT_MARKER}`;
             const sendResult = await sendPaneInput({
               paneTarget: csPaneId,
+              exactPaneId: csPaneId,
               prompt: csText,
               submitKeyPresses: 2,
               submitDelayMs: 100,

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 =