oh-my-codex 0.11.13 → 0.12.0

package/src/scripts/notify-hook/orchestration-intent.ts

@@ -0,0 +1,82 @@
+// @ts-nocheck
+
+import { safeString } from './utils.js';
+
+export const TEAM_ORCHESTRATION_INTENTS = [
+  'followup-reuse',
+  'followup-relaunch',
+  'stalled-unblock',
+  'done-review-or-shutdown',
+  'pending-mailbox-review',
+] as const;
+
+export const ORCHESTRATION_INTENT_TAG_PREFIX = '[OMX_INTENT:';
+
+const ORCHESTRATION_INTENT_TAG_RE = /\s*\[OMX_INTENT:[a-z0-9-]+\]/gi;
+
+export function buildOrchestrationIntentTag(intent) {
+  const normalizedIntent = safeString(intent).trim();
+  return normalizedIntent ? `${ORCHESTRATION_INTENT_TAG_PREFIX}${normalizedIntent}]` : '';
+}
+
+export function appendOrchestrationIntentTag(text, intent) {
+  const normalizedText = safeString(text).trim();
+  const tag = buildOrchestrationIntentTag(intent);
+  if (!tag) return normalizedText;
+  return normalizedText ? `${normalizedText} ${tag}` : tag;
+}
+
+export function stripOrchestrationIntentTags(text) {
+  return safeString(text).replace(ORCHESTRATION_INTENT_TAG_RE, '');
+}
+
+export function classifyLeaderActionState({
+  allWorkersIdle = false,
+  workerPanesAlive = false,
+  taskCounts = {},
+  teamProgressStalled = false,
+} = {}) {
+  const pending = Number.isFinite(taskCounts.pending) ? taskCounts.pending : 0;
+  const blocked = Number.isFinite(taskCounts.blocked) ? taskCounts.blocked : 0;
+  const inProgress = Number.isFinite(taskCounts.in_progress) ? taskCounts.in_progress : 0;
+  const tasksComplete = pending === 0 && blocked === 0 && inProgress === 0;
+  const pendingFollowUpTasks = allWorkersIdle && pending > 0 && blocked === 0 && inProgress === 0;
+  const blockedWaitingOnLeader = allWorkersIdle && blocked > 0 && pending === 0 && inProgress === 0;
+  const terminalWaitingOnLeader = allWorkersIdle && tasksComplete && workerPanesAlive;
+  const stalledWaitingOnLeader = blockedWaitingOnLeader || teamProgressStalled;
+
+  if (terminalWaitingOnLeader) return 'done_waiting_on_leader';
+  if (stalledWaitingOnLeader) return 'stuck_waiting_on_leader';
+  if (pendingFollowUpTasks) return 'still_actionable';
+  return 'still_actionable';
+}
+
+export function resolveAllWorkersIdleIntent(leaderActionState = 'still_actionable') {
+  if (leaderActionState === 'done_waiting_on_leader') return 'done-review-or-shutdown';
+  if (leaderActionState === 'stuck_waiting_on_leader') return 'stalled-unblock';
+  return 'followup-reuse';
+}
+
+export function resolveLeaderNudgeIntent({ nudgeReason = '', leaderActionState = 'still_actionable' } = {}) {
+  switch (safeString(nudgeReason).trim()) {
+    case 'new_mailbox_message':
+    case 'stale_leader_with_messages':
+      return 'pending-mailbox-review';
+    case 'ack_without_start_evidence':
+      return 'followup-relaunch';
+    case 'stuck_waiting_on_leader':
+    case 'stale_leader_panes_alive':
+      return 'stalled-unblock';
+    case 'done_waiting_on_leader':
+      return 'done-review-or-shutdown';
+    case 'all_workers_idle':
+    default:
+      return resolveAllWorkersIdleIntent(leaderActionState);
+  }
+}
+
+export function resolveWorkerIdleIntent(currentState = 'idle') {
+  return safeString(currentState).trim() === 'done'
+    ? 'done-review-or-shutdown'
+    : 'followup-reuse';
+}

package/src/scripts/notify-hook/process-runner.ts

@@ -18,19 +18,19 @@ export function runProcess(command: string, args: string[], timeoutMs = 3000): P
       reject(new Error(`timeout after ${timeoutMs}ms`));
     }, timeoutMs);
 
-    child.stdout.on('data', (chunk: any) => {
+    child.stdout.on('data', (chunk: Buffer) => {
       stdout += chunk.toString();
     });
-    child.stderr.on('data', (chunk: any) => {
+    child.stderr.on('data', (chunk: Buffer) => {
       stderr += chunk.toString();
     });
-    child.on('error', (err: any) => {
+    child.on('error', (err: Error) => {
       if (finished) return;
       finished = true;
       clearTimeout(timer);
       reject(err);
     });
-    child.on('close', (code: any) => {
+    child.on('close', (code: number | null) => {
       if (finished) return;
       finished = true;
       clearTimeout(timer);

package/src/scripts/notify-hook/ralph-session-resume.ts

@@ -214,6 +214,7 @@ export async function reconcileRalphSessionResume({
     if (currentRalphState && currentRalphState.active === true) {
       let changed = false;
       const updated: Record<string, unknown> = { ...currentRalphState };
+      const normalizedPayloadThreadId = safeString(payloadThreadId).trim();
       if (safeString(updated.owner_omx_session_id).trim() !== currentOmxSessionId) {
         updated.owner_omx_session_id = currentOmxSessionId;
         changed = true;
@@ -222,6 +223,14 @@ export async function reconcileRalphSessionResume({
         updated.owner_codex_session_id = payloadSessionId;
         changed = true;
       }
+      if (
+        !safeString(updated.owner_codex_session_id).trim()
+        && normalizedPayloadThreadId
+        && safeString(updated.owner_codex_thread_id).trim() !== normalizedPayloadThreadId
+      ) {
+        updated.owner_codex_thread_id = normalizedPayloadThreadId;
+        changed = true;
+      }
       if (
         typeof updated.owner_codex_thread_id === 'string'
         && safeString(updated.owner_codex_session_id).trim()

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

@@ -6,6 +6,7 @@ import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'node:url';
 import { safeString } from './utils.js';
 import { resolveBridgeStateDir, resolveRuntimeBinaryPath } from '../../runtime/bridge.js';
+import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -372,6 +373,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
   if (!target) {
     return { ok: false, reason: 'missing_tmux_target' };
   }
+  const leaderTargeted = request.to_worker === 'leader-fixed';
   let resolution;
   if (target.type === 'session') {
     const paneId = await resolveSessionToPane(target.value).catch(() => null);
@@ -384,14 +386,24 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
   if (!resolution.paneTarget) {
     return { ok: false, reason: `target_resolution_failed:${resolution.reason}` };
   }
+  const isLeaderMailboxDispatch = request.to_worker === 'leader-fixed';
   const paneGuard = await evaluatePaneInjectionReadiness(resolution.paneTarget, {
     skipIfScrolling: true,
-    requireRunningAgent: false,
+    requireRunningAgent: leaderTargeted,
     requireReady: false,
     requireIdle: false,
+    requireObservableState: leaderTargeted,
   });
   if (!paneGuard.ok) {
-    return { ok: false, reason: paneGuard.reason };
+    return {
+      ok: false,
+      reason: paneGuard.reason,
+      pane: resolution.paneTarget,
+      pane_source: resolution.source || null,
+      readiness_evidence: paneGuard.readinessEvidence || null,
+      pane_current_command: paneGuard.paneCurrentCommand || null,
+      tmux_injection_attempted: false,
+    };
   }
 
   const attemptCountAtStart = Number.isFinite(request.attempt_count)
@@ -427,7 +439,15 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
     typePrompt: shouldTypePrompt,
   });
   if (!sendResult.ok) {
-    return { ok: false, reason: sendResult.error || sendResult.reason };
+    return {
+      ok: false,
+      reason: sendResult.error || sendResult.reason,
+      pane: resolution.paneTarget,
+      pane_source: resolution.source || null,
+      readiness_evidence: paneGuard.readinessEvidence || null,
+      pane_current_command: paneGuard.paneCurrentCommand || null,
+      tmux_injection_attempted: true,
+    };
   }
 
   // Post-injection verification: confirm the trigger text was consumed.
@@ -448,7 +468,15 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       // Worker is actively processing (mirrors sync path tmux-session.ts:1292-1294)
       if (paneHasActiveTask(wideCap.stdout)) {
         runtimeExec({ command: 'MarkDelivered', request_id: request.request_id }, stateDir);
-        return { ok: true, reason: 'tmux_send_keys_confirmed_active_task', pane: resolution.paneTarget };
+        return {
+          ok: true,
+          reason: 'tmux_send_keys_confirmed_active_task',
+          pane: resolution.paneTarget,
+          pane_source: resolution.source || null,
+          readiness_evidence: paneGuard.readinessEvidence || null,
+          pane_current_command: paneGuard.paneCurrentCommand || null,
+          tmux_injection_attempted: true,
+        };
       }
       // Do not declare success while a *worker* pane is still bootstrapping / not
       // input-ready. Otherwise a pre-ready send can be marked "confirmed" and later
@@ -461,7 +489,15 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       const triggerNearTail = capturedPaneContainsTriggerNearTail(wideCap.stdout, request.trigger_message);
       if (!triggerInNarrow && !triggerNearTail) {
         runtimeExec({ command: 'MarkDelivered', request_id: request.request_id }, stateDir);
-        return { ok: true, reason: 'tmux_send_keys_confirmed', pane: resolution.paneTarget };
+        return {
+          ok: true,
+          reason: 'tmux_send_keys_confirmed',
+          pane: resolution.paneTarget,
+          pane_source: resolution.source || null,
+          readiness_evidence: paneGuard.readinessEvidence || null,
+          pane_current_command: paneGuard.paneCurrentCommand || null,
+          tmux_injection_attempted: true,
+        };
       }
     } catch {
       // capture failed; fall through to retry C-m
@@ -476,7 +512,15 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
   }
 
   // Trigger text is still visible after all retry rounds.
-  return { ok: true, reason: 'tmux_send_keys_unconfirmed', pane: resolution.paneTarget };
+  return {
+    ok: true,
+    reason: 'tmux_send_keys_unconfirmed',
+    pane: resolution.paneTarget,
+    pane_source: resolution.source || null,
+    readiness_evidence: paneGuard.readinessEvidence || null,
+    pane_current_command: paneGuard.paneCurrentCommand || null,
+    tmux_injection_attempted: true,
+  };
 }
 
 function shouldSkipRequest(request) {
@@ -505,12 +549,38 @@ async function appendDispatchLog(logsDir, event) {
   await appendFile(path, `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`).catch(() => {});
 }
 
+async function appendDeliveryTelemetry(logsDir, event) {
+  await appendTeamDeliveryLog(logsDir, {
+    source: 'notify-hook.team-dispatch',
+    ...event,
+  }).catch(() => {});
+}
+
+function buildDispatchAttemptEvidence(result, fallback = {}) {
+  return {
+    pane_target: safeString(result?.pane || fallback.pane || '').trim() || null,
+    pane_source: safeString(result?.pane_source || fallback.pane_source || '').trim() || null,
+    readiness_evidence: safeString(result?.readiness_evidence || fallback.readiness_evidence || '').trim() || null,
+    pane_current_command: safeString(result?.pane_current_command || fallback.pane_current_command || '').trim() || null,
+    tmux_injection_attempted:
+      typeof result?.tmux_injection_attempted === 'boolean'
+        ? result.tmux_injection_attempted
+        : (typeof fallback.tmux_injection_attempted === 'boolean' ? fallback.tmux_injection_attempted : null),
+  };
+}
+
 export async function drainPendingTeamDispatch({
   cwd,
   stateDir = resolveBridgeStateDir(cwd),
   logsDir = join(cwd, '.omx', 'logs'),
   maxPerTick = 5,
   injector = injectDispatchRequest,
+}: {
+  cwd?: string;
+  stateDir?: string;
+  logsDir?: string;
+  maxPerTick?: number;
+  injector?: typeof injectDispatchRequest;
 } = {}) {
   if (safeString(process.env.OMX_TEAM_WORKER)) {
     return { processed: 0, skipped: 0, failed: 0, reason: 'worker_context' };
@@ -575,6 +645,20 @@ export async function drainPendingTeamDispatch({
               tmux_session: safeString(config?.tmux_session).trim() || null,
               leader_pane_id: safeString(config?.leader_pane_id).trim() || null,
               tmux_injection_attempted: false,
+              pane_target: null,
+              pane_source: null,
+              readiness_evidence: null,
+              pane_current_command: null,
+            });
+            await appendDeliveryTelemetry(logsDir, {
+              event: 'dispatch_result',
+              team: teamName,
+              request_id: request.request_id,
+              message_id: request.message_id || null,
+              to_worker: request.to_worker,
+              transport: 'send-keys',
+              result: 'deferred',
+              reason: LEADER_PANE_MISSING_DEFERRED_REASON,
             });
             // On the legacy fallback lane, requests.json still carries the queue
             // state for this deferred request; this event stays a progress
@@ -645,6 +729,17 @@ export async function drainPendingTeamDispatch({
               worker: request.to_worker,
               attempt: request.attempt_count,
               reason: result.reason,
+              ...buildDispatchAttemptEvidence(result),
+            });
+            await appendDeliveryTelemetry(logsDir, {
+              event: 'dispatch_result',
+              team: teamName,
+              request_id: request.request_id,
+              message_id: request.message_id || null,
+              to_worker: request.to_worker,
+              transport: 'send-keys',
+              result: 'retry',
+              reason: result.reason,
             });
             await emitOperationalHookEvent(cwd, 'retry-needed', {
               team: teamName,
@@ -672,6 +767,17 @@ export async function drainPendingTeamDispatch({
               worker: request.to_worker,
               message_id: request.message_id || null,
               reason: request.last_reason,
+              ...buildDispatchAttemptEvidence(result),
+            });
+            await appendDeliveryTelemetry(logsDir, {
+              event: 'dispatch_result',
+              team: teamName,
+              request_id: request.request_id,
+              message_id: request.message_id || null,
+              to_worker: request.to_worker,
+              transport: 'send-keys',
+              result: 'failed',
+              reason: request.last_reason,
             });
             await emitOperationalHookEvent(cwd, 'failed', {
               team: teamName,
@@ -704,6 +810,17 @@ export async function drainPendingTeamDispatch({
             worker: request.to_worker,
             message_id: request.message_id || null,
             reason: result.reason,
+            ...buildDispatchAttemptEvidence(result),
+          });
+          await appendDeliveryTelemetry(logsDir, {
+            event: 'dispatch_result',
+            team: teamName,
+            request_id: request.request_id,
+            message_id: request.message_id || null,
+            to_worker: request.to_worker,
+            transport: 'send-keys',
+            result: 'notified',
+            reason: result.reason,
           });
         } else {
           request.status = 'failed';
@@ -720,6 +837,17 @@ export async function drainPendingTeamDispatch({
             worker: request.to_worker,
             message_id: request.message_id || null,
             reason: result.reason,
+            ...buildDispatchAttemptEvidence(result),
+          });
+          await appendDeliveryTelemetry(logsDir, {
+            event: 'dispatch_result',
+            team: teamName,
+            request_id: request.request_id,
+            message_id: request.message_id || null,
+            to_worker: request.to_worker,
+            transport: 'send-keys',
+            result: 'failed',
+            reason: result.reason,
           });
           await emitOperationalHookEvent(cwd, result.reason === LEADER_PANE_MISSING_DEFERRED_REASON ? 'handoff-needed' : 'failed', {
             team: teamName,