oh-my-codex 0.20.3 → 0.20.5

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

@@ -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) {

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 =