oh-my-codex 0.7.6 → 0.8.1

package/scripts/notify-hook/team-dispatch.js

@@ -21,6 +21,76 @@ async function writeJsonAtomic(path, value) {
 
 // Keep stale-timeout semantics aligned with src/team/state.ts LOCK_STALE_MS.
 const DISPATCH_LOCK_STALE_MS = 5 * 60 * 1000;
+const DEFAULT_ISSUE_DISPATCH_COOLDOWN_MS = 15 * 60 * 1000;
+const ISSUE_DISPATCH_COOLDOWN_ENV = 'OMX_TEAM_DISPATCH_ISSUE_COOLDOWN_MS';
+const DEFAULT_DISPATCH_TRIGGER_COOLDOWN_MS = 30 * 1000;
+const DISPATCH_TRIGGER_COOLDOWN_ENV = 'OMX_TEAM_DISPATCH_TRIGGER_COOLDOWN_MS';
+const LEADER_PANE_MISSING_DEFERRED_REASON = 'leader_pane_missing_deferred';
+const LEADER_NOTIFICATION_DEFERRED_TYPE = 'leader_notification_deferred';
+
+function resolveIssueDispatchCooldownMs(env = process.env) {
+  const raw = safeString(env[ISSUE_DISPATCH_COOLDOWN_ENV]).trim();
+  if (raw === '') return DEFAULT_ISSUE_DISPATCH_COOLDOWN_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_ISSUE_DISPATCH_COOLDOWN_MS;
+  return parsed;
+}
+
+function resolveDispatchTriggerCooldownMs(env = process.env) {
+  const raw = safeString(env[DISPATCH_TRIGGER_COOLDOWN_ENV]).trim();
+  if (raw === '') return DEFAULT_DISPATCH_TRIGGER_COOLDOWN_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_DISPATCH_TRIGGER_COOLDOWN_MS;
+  return parsed;
+}
+
+function extractIssueKey(triggerMessage) {
+  const match = safeString(triggerMessage).match(/\b([A-Z][A-Z0-9]+-\d+)\b/i);
+  return match?.[1]?.toUpperCase() || null;
+}
+
+function issueCooldownStatePath(teamDirPath) {
+  return join(teamDirPath, 'dispatch', 'issue-cooldown.json');
+}
+
+function triggerCooldownStatePath(teamDirPath) {
+  return join(teamDirPath, 'dispatch', 'trigger-cooldown.json');
+}
+
+async function readIssueCooldownState(teamDirPath) {
+  const fallback = { by_issue: {} };
+  const parsed = await readJson(issueCooldownStatePath(teamDirPath), fallback);
+  if (!parsed || typeof parsed !== 'object' || typeof parsed.by_issue !== 'object' || parsed.by_issue === null) {
+    return fallback;
+  }
+  return parsed;
+}
+
+async function readTriggerCooldownState(teamDirPath) {
+  const fallback = { by_trigger: {} };
+  const parsed = await readJson(triggerCooldownStatePath(teamDirPath), fallback);
+  if (!parsed || typeof parsed !== 'object' || typeof parsed.by_trigger !== 'object' || parsed.by_trigger === null) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function normalizeTriggerKey(value) {
+  return safeString(value).replace(/\s+/g, ' ').trim();
+}
+
+function parseTriggerCooldownEntry(entry) {
+  if (typeof entry === 'number') {
+    return { at: entry, lastRequestId: '' };
+  }
+  if (!entry || typeof entry !== 'object') {
+    return { at: NaN, lastRequestId: '' };
+  }
+  return {
+    at: Number(entry.at),
+    lastRequestId: safeString(entry.last_request_id).trim(),
+  };
+}
 
 async function withDispatchLock(teamDirPath, fn) {
   const lockDir = join(teamDirPath, 'dispatch', '.lock');
@@ -117,18 +187,15 @@ async function withMailboxLock(teamDirPath, workerName, fn) {
 }
 
 function defaultInjectTarget(request, config) {
+  if (request.to_worker === 'leader-fixed') {
+    if (config.leader_pane_id) return { type: 'pane', value: config.leader_pane_id };
+    return null;
+  }
   if (request.pane_id) return { type: 'pane', value: request.pane_id };
   if (typeof request.worker_index === 'number' && Array.isArray(config?.workers)) {
     const worker = config.workers.find((candidate) => Number(candidate?.index) === request.worker_index);
     if (worker?.pane_id) return { type: 'pane', value: worker.pane_id };
   }
-  // Leader-fixed fallback: use config.leader_pane_id when request has no
-  // pane_id or worker_index (leader is not a worker). Without this, leader
-  // dispatch falls through to the session target which hits the active pane
-  // (likely a worker). Fixes #433.
-  if (request.to_worker === 'leader-fixed' && config.leader_pane_id) {
-    return { type: 'pane', value: config.leader_pane_id };
-  }
   if (typeof request.worker_index === 'number' && config.tmux_session) {
     return { type: 'pane', value: `${config.tmux_session}.${request.worker_index}` };
   }
@@ -136,6 +203,30 @@ function defaultInjectTarget(request, config) {
   return null;
 }
 
+async function appendLeaderNotificationDeferredEvent({
+  stateDir,
+  teamName,
+  request,
+  reason,
+  nowIso,
+}) {
+  const eventsDir = join(stateDir, 'team', teamName, 'events');
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  const event = {
+    event_id: `leader-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+    team: teamName,
+    type: LEADER_NOTIFICATION_DEFERRED_TYPE,
+    worker: request.to_worker,
+    to_worker: request.to_worker,
+    reason,
+    created_at: nowIso,
+    request_id: request.request_id,
+    ...(request.message_id ? { message_id: request.message_id } : {}),
+  };
+  await mkdir(eventsDir, { recursive: true }).catch(() => {});
+  await appendFile(eventsPath, JSON.stringify(event) + '\n').catch(() => {});
+}
+
 function resolveWorkerCliForRequest(request, config) {
   const workers = Array.isArray(config?.workers) ? config.workers : [];
   const idx = Number.isFinite(request?.worker_index) ? Number(request.worker_index) : null;
@@ -156,6 +247,19 @@ function capturedPaneContainsTrigger(captured, trigger) {
   return normalizeCaptureText(captured).includes(normalizeCaptureText(trigger));
 }
 
+function capturedPaneContainsTriggerNearTail(captured, trigger, nonEmptyTailLines = 24) {
+  if (!captured || !trigger) return false;
+  const normalizedTrigger = normalizeCaptureText(trigger);
+  if (!normalizedTrigger) return false;
+  const lines = safeString(captured)
+    .split('\n')
+    .map((line) => line.replace(/\r/g, '').trim())
+    .filter((line) => line.length > 0);
+  if (lines.length === 0) return false;
+  const tail = lines.slice(-Math.max(1, nonEmptyTailLines)).join(' ');
+  return normalizeCaptureText(tail).includes(normalizedTrigger);
+}
+
 // Ported from src/team/tmux-session.ts:949-963 — detects active CLI task indicators.
 function paneHasActiveTask(captured) {
   const lines = safeString(captured)
@@ -163,6 +267,7 @@ function paneHasActiveTask(captured) {
     .map((line) => line.replace(/\r/g, '').trim())
     .filter((line) => line.length > 0);
   const tail = lines.slice(-40);
+  if (tail.some((line) => /\b\d+\s+background terminal running\b/i.test(line))) return true;
   if (tail.some((line) => /esc to interrupt/i.test(line))) return true;
   if (tail.some((line) => /\bbackground terminal running\b/i.test(line))) return true;
   if (tail.some((line) => /^•\s.+\(.+•\s*esc to interrupt\)$/i.test(line))) return true;
@@ -171,6 +276,40 @@ function paneHasActiveTask(captured) {
   return false;
 }
 
+function paneIsBootstrapping(captured) {
+  const lines = safeString(captured)
+    .split('\n')
+    .map((line) => line.replace(/\r/g, '').trim())
+    .filter((line) => line.length > 0);
+  return lines.some((line) =>
+    /\b(loading|initializing|starting up)\b/i.test(line)
+    || /\bmodel:\s*loading\b/i.test(line)
+    || /\bconnecting\s+to\b/i.test(line),
+  );
+}
+
+function paneLooksReady(captured) {
+  const content = safeString(captured).trimEnd();
+  if (content === '') return false;
+
+  const lines = content
+    .split('\n')
+    .map((line) => line.replace(/\r/g, ''))
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim() !== '');
+
+  if (paneIsBootstrapping(content)) return false;
+
+  const lastLine = lines.length > 0 ? lines[lines.length - 1] : '';
+  if (/^\s*[›>❯]\s*/u.test(lastLine)) return true;
+
+  const hasCodexPromptLine = lines.some((line) => /^\s*›\s*/u.test(line));
+  const hasClaudePromptLine = lines.some((line) => /^\s*❯\s*/u.test(line));
+  if (hasCodexPromptLine || hasClaudePromptLine) return true;
+
+  return false;
+}
+
 const INJECT_VERIFY_DELAY_MS = 250;
 const INJECT_VERIFY_ROUNDS = 3;
 
@@ -237,16 +376,29 @@ async function injectDispatchRequest(request, config, cwd) {
   for (let round = 0; round < INJECT_VERIFY_ROUNDS; round++) {
     await new Promise((r) => setTimeout(r, INJECT_VERIFY_DELAY_MS));
     try {
-      // Primary: trigger text no longer in narrow input area
+      // Primary: trigger text no longer in narrow input area.
+      // Secondary guard: also inspect the recent non-empty tail of wide capture.
+      // This avoids false confirmations when Codex leaves the unsent draft just
+      // above a large blank area (narrow capture misses it) while still avoiding
+      // full-scrollback false positives.
       const narrowCap = await runProcess('tmux', verifyNarrowArgv, 2000);
-      if (!capturedPaneContainsTrigger(narrowCap.stdout, request.trigger_message)) {
-        return { ok: true, reason: 'tmux_send_keys_confirmed', pane: resolution.paneTarget };
-      }
-      // Secondary: worker is actively processing (mirrors sync path tmux-session.ts:1292-1294)
       const wideCap = await runProcess('tmux', verifyWideArgv, 2000);
+      // Worker is actively processing (mirrors sync path tmux-session.ts:1292-1294)
       if (paneHasActiveTask(wideCap.stdout)) {
         return { ok: true, reason: 'tmux_send_keys_confirmed_active_task', pane: resolution.paneTarget };
       }
+      // 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
+      // appear as a stuck unsent draft once the UI finishes loading.
+      // Keep leader-fixed behavior unchanged to avoid regressing leader notification flow.
+      if (request.to_worker !== 'leader-fixed' && !paneLooksReady(wideCap.stdout)) {
+        continue;
+      }
+      const triggerInNarrow = capturedPaneContainsTrigger(narrowCap.stdout, request.trigger_message);
+      const triggerNearTail = capturedPaneContainsTriggerNearTail(wideCap.stdout, request.trigger_message);
+      if (!triggerInNarrow && !triggerNearTail) {
+        return { ok: true, reason: 'tmux_send_keys_confirmed', pane: resolution.paneTarget };
+      }
     } catch {
       // capture failed; fall through to retry C-m
     }
@@ -302,6 +454,8 @@ export async function drainPendingTeamDispatch({
   let processed = 0;
   let skipped = 0;
   let failed = 0;
+  const issueCooldownMs = resolveIssueDispatchCooldownMs();
+  const triggerCooldownMs = resolveDispatchTriggerCooldownMs();
 
   for (const teamName of teams) {
     if (processed >= maxPerTick) break;
@@ -315,6 +469,11 @@ export async function drainPendingTeamDispatch({
     await withDispatchLock(teamDirPath, async () => {
       const requests = await readJson(requestsPath, []);
       if (!Array.isArray(requests)) return;
+      const issueCooldownState = await readIssueCooldownState(teamDirPath);
+      const triggerCooldownState = await readTriggerCooldownState(teamDirPath);
+      const issueCooldownByIssue = issueCooldownState.by_issue || {};
+      const triggerCooldownByKey = triggerCooldownState.by_trigger || {};
+      const nowMs = Date.now();
 
       let mutated = false;
       for (const request of requests) {
@@ -325,7 +484,66 @@ export async function drainPendingTeamDispatch({
           continue;
         }
 
+        if (request.to_worker === 'leader-fixed' && !safeString(config?.leader_pane_id).trim()) {
+          const nowIso = new Date().toISOString();
+          request.updated_at = nowIso;
+          request.last_reason = LEADER_PANE_MISSING_DEFERRED_REASON;
+          request.status = 'pending';
+          skipped += 1;
+          mutated = true;
+          await appendDispatchLog(logsDir, {
+            type: 'dispatch_deferred',
+            team: teamName,
+            request_id: request.request_id,
+            worker: request.to_worker,
+            to_worker: request.to_worker,
+            message_id: request.message_id || null,
+            reason: LEADER_PANE_MISSING_DEFERRED_REASON,
+            status: 'pending',
+            tmux_injection_attempted: false,
+          });
+          await appendLeaderNotificationDeferredEvent({
+            stateDir,
+            teamName,
+            request,
+            reason: LEADER_PANE_MISSING_DEFERRED_REASON,
+            nowIso,
+          });
+          continue;
+        }
+
+        const issueKey = extractIssueKey(request.trigger_message);
+        if (issueCooldownMs > 0 && issueKey) {
+          const lastInjectedMs = Number(issueCooldownByIssue[issueKey]);
+          if (Number.isFinite(lastInjectedMs) && lastInjectedMs > 0 && nowMs - lastInjectedMs < issueCooldownMs) {
+            skipped += 1;
+            continue;
+          }
+        }
+
+        const triggerKey = normalizeTriggerKey(request.trigger_message);
+        if (triggerCooldownMs > 0 && triggerKey) {
+          const parsed = parseTriggerCooldownEntry(triggerCooldownByKey[triggerKey]);
+          const withinCooldown = Number.isFinite(parsed.at) && parsed.at > 0 && nowMs - parsed.at < triggerCooldownMs;
+          const sameRequestRetry = parsed.lastRequestId !== '' && parsed.lastRequestId === safeString(request.request_id).trim();
+          if (withinCooldown && !sameRequestRetry) {
+            skipped += 1;
+            continue;
+          }
+        }
+
         const result = await injector(request, config, resolve(cwd));
+        if (issueKey && issueCooldownMs > 0) {
+          issueCooldownByIssue[issueKey] = Date.now();
+          mutated = true;
+        }
+        if (triggerKey && triggerCooldownMs > 0) {
+          triggerCooldownByKey[triggerKey] = {
+            at: Date.now(),
+            last_request_id: safeString(request.request_id).trim(),
+          };
+          mutated = true;
+        }
         const nowIso = new Date().toISOString();
         request.attempt_count = Number.isFinite(request.attempt_count) ? Math.max(0, request.attempt_count + 1) : 1;
         request.updated_at = nowIso;
@@ -401,6 +619,10 @@ export async function drainPendingTeamDispatch({
       }
 
       if (mutated) {
+        issueCooldownState.by_issue = issueCooldownByIssue;
+        await writeJsonAtomic(issueCooldownStatePath(teamDirPath), issueCooldownState);
+        triggerCooldownState.by_trigger = triggerCooldownByKey;
+        await writeJsonAtomic(triggerCooldownStatePath(teamDirPath), triggerCooldownState);
         await writeJsonAtomic(requestsPath, requests);
       }
     });

package/scripts/notify-hook/team-leader-nudge.js

@@ -10,6 +10,8 @@ import { readJsonIfExists, getScopedStateDirsForCurrentSession } from './state-i
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
 import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
+const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
+const LEADER_NOTIFICATION_DEFERRED_TYPE = 'leader_notification_deferred';
 
 export function resolveLeaderNudgeIntervalMs() {
   const raw = safeString(process.env.OMX_TEAM_LEADER_NUDGE_MS || '');
@@ -109,6 +111,26 @@ export async function emitTeamNudgeEvent(cwd, teamName, reason, nowIso) {
   }
 }
 
+async function emitLeaderNudgeDeferredEvent(cwd, teamName, reason, nowIso) {
+  const eventsDir = join(cwd, '.omx', 'state', 'team', teamName, 'events');
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  try {
+    await mkdir(eventsDir, { recursive: true });
+    const event = {
+      event_id: `leader-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+      team: teamName,
+      type: LEADER_NOTIFICATION_DEFERRED_TYPE,
+      worker: 'leader-fixed',
+      to_worker: 'leader-fixed',
+      reason,
+      created_at: nowIso,
+    };
+    await appendFile(eventsPath, JSON.stringify(event) + '\n');
+  } catch {
+    // Best effort
+  }
+}
+
 export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale }) {
   const intervalMs = resolveLeaderNudgeIntervalMs();
   const idleCooldownMs = resolveLeaderAllIdleNudgeCooldownMs();
@@ -163,8 +185,8 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     } catch {
       // ignore
     }
-    const tmuxTarget = leaderPaneId || tmuxSession;
-    if (!tmuxTarget) continue;
+    if (!tmuxSession && !leaderPaneId) continue;
+    const tmuxTarget = leaderPaneId;
 
     const paneStatus = tmuxSession
       ? await checkWorkerPanesAlive(tmuxSession)
@@ -234,6 +256,24 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
     const markedText = `${capped} ${DEFAULT_MARKER}`;
 
+    if (!tmuxTarget) {
+      await emitLeaderNudgeDeferredEvent(cwd, teamName, LEADER_PANE_MISSING_NO_INJECTION_REASON, nowIso);
+      try {
+        await logTmuxHookEvent(logsDir, {
+          timestamp: nowIso,
+          type: LEADER_NOTIFICATION_DEFERRED_TYPE,
+          team: teamName,
+          worker: 'leader-fixed',
+          to_worker: 'leader-fixed',
+          reason: LEADER_PANE_MISSING_NO_INJECTION_REASON,
+          leader_pane_id: null,
+          tmux_session: tmuxSession || null,
+          tmux_injection_attempted: false,
+        });
+      } catch { /* ignore */ }
+      continue;
+    }
+
     try {
       await runProcess('tmux', ['send-keys', '-t', tmuxTarget, '-l', markedText], 3000);
       await new Promise(r => setTimeout(r, 100));

package/scripts/notify-hook/team-worker.js

@@ -194,6 +194,43 @@ export async function readTeamWorkersForIdleCheck(stateDir, teamName) {
   }
 }
 
+async function emitLeaderPaneMissingDeferred({
+  stateDir,
+  logsDir,
+  teamName,
+  workerName,
+  tmuxSession,
+  leaderPaneId,
+  reason = 'leader_pane_missing_no_injection',
+}) {
+  const nowIso = new Date().toISOString();
+  await logTmuxHookEvent(logsDir, {
+    timestamp: nowIso,
+    type: 'leader_notification_deferred',
+    team: teamName,
+    worker: workerName,
+    to_worker: 'leader-fixed',
+    reason,
+    leader_pane_id: leaderPaneId || null,
+    tmux_session: tmuxSession || null,
+    tmux_injection_attempted: false,
+  }).catch(() => {});
+
+  const eventsDir = join(stateDir, 'team', teamName, 'events');
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  await mkdir(eventsDir, { recursive: true }).catch(() => {});
+  const event = {
+    event_id: `leader-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+    team: teamName,
+    type: 'leader_notification_deferred',
+    worker: workerName,
+    to_worker: 'leader-fixed',
+    reason,
+    created_at: nowIso,
+  };
+  await appendFile(eventsPath, JSON.stringify(event) + '\n').catch(() => {});
+}
+
 export async function updateWorkerHeartbeat(stateDir, teamName, workerName) {
   const heartbeatPath = join(stateDir, 'team', teamName, 'workers', workerName, 'heartbeat.json');
   let turnCount = 0;
@@ -228,8 +265,6 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
   const { workers, tmuxSession, leaderPaneId } = teamInfo;
-  const tmuxTarget = leaderPaneId || tmuxSession;
-  if (!tmuxTarget) return;
 
   // Check cooldown to prevent notification spam
   const idleStatePath = join(stateDir, 'team', teamName, 'all-workers-idle.json');
@@ -252,8 +287,21 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   );
   if (!allIdle) return;
 
+  if (!leaderPaneId) {
+    await emitLeaderPaneMissingDeferred({
+      stateDir,
+      logsDir,
+      teamName,
+      workerName,
+      tmuxSession,
+      leaderPaneId,
+    });
+    return;
+  }
+
   const N = workers.length;
   const message = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. Ready for next instructions. ${DEFAULT_MARKER}`;
+  const tmuxTarget = leaderPaneId;
 
   try {
     await runProcess('tmux', ['send-keys', '-t', tmuxTarget, '-l', message], 3000);
@@ -382,8 +430,19 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
   const { tmuxSession, leaderPaneId } = teamInfo;
-  const tmuxTarget = leaderPaneId || tmuxSession;
-  if (!tmuxTarget) return;
+
+  if (!leaderPaneId) {
+    await emitLeaderPaneMissingDeferred({
+      stateDir,
+      logsDir,
+      teamName,
+      workerName,
+      tmuxSession,
+      leaderPaneId,
+    });
+    return;
+  }
+  const tmuxTarget = leaderPaneId;
 
   // Build notification message with context
   const parts = [`[OMX] ${workerName} idle`];

package/scripts/notify-hook/visual-verdict.js

@@ -25,6 +25,40 @@ const VERDICT_PATTERNS = [
  */
 const VERDICT_CANDIDATE_RE = /(?:\*\*Status\*\*\s*:|Verdict\s*:)/i;
 
+function extractJsonCandidates(rawMessage) {
+  const message = safeString(rawMessage).trim();
+  if (!message) return [];
+
+  const candidates = [message];
+  const fencePattern = /```(?:json)?\s*([\s\S]*?)```/gi;
+  for (const match of message.matchAll(fencePattern)) {
+    const block = safeString(match[1]).trim();
+    if (block) candidates.push(block);
+  }
+  return candidates;
+}
+
+async function maybePersistRuntimeVisualFeedback({ cwd, output, sessionId }) {
+  if (!cwd || !output) return;
+
+  const candidates = extractJsonCandidates(output);
+  if (candidates.length === 0) return;
+
+  const { buildVisualLoopFeedback } = await import('../../dist/visual/verdict.js');
+  const { recordRalphVisualFeedback } = await import('../../dist/ralph/persistence.js');
+
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const feedback = buildVisualLoopFeedback(parsed);
+      await recordRalphVisualFeedback(cwd, feedback, sessionId || undefined);
+      return;
+    } catch {
+      // Try next candidate
+    }
+  }
+}
+
 /**
  * Attempt to extract a structured verdict from free-form text.
  * Returns `{ verdict, raw }` on success, `null` otherwise.
@@ -50,12 +84,27 @@ export function parseVisualVerdict(text) {
  *
  * Module import failure is handled by the caller in notify-hook.js.
  */
-export async function maybePersistVisualVerdict({ payload, stateDir, logsDir, sessionId, turnId }) {
+export async function maybePersistVisualVerdict({ cwd, payload, stateDir, logsDir, sessionId, turnId }) {
   const output = safeString(
     payload?.['last-assistant-message'] || payload?.last_assistant_message || '',
   );
   if (!output) return;
 
+  // Runtime visual feedback (JSON/fenced JSON) for ralph-progress persistence.
+  // Non-fatal and observable via warn-level structured logging.
+  try {
+    await maybePersistRuntimeVisualFeedback({ cwd, output, sessionId });
+  } catch (err) {
+    await logNotifyHookEvent(logsDir, {
+      timestamp: new Date().toISOString(),
+      level: 'warn',
+      type: 'visual_runtime_feedback_persist_failure',
+      error: err?.message || String(err),
+      session_id: sessionId,
+      turn_id: turnId,
+    });
+  }
+
   const parsed = parseVisualVerdict(output);
 
   if (!parsed) {

package/scripts/notify-hook.js

@@ -409,6 +409,7 @@ async function main() {
     try {
       const { maybePersistVisualVerdict } = await import('./notify-hook/visual-verdict.js');
       await maybePersistVisualVerdict({
+        cwd,
         payload,
         stateDir,
         logsDir,