borgmcp 3.11.0 → 3.12.0

package/src/codex-app-wake.ts

@@ -6,7 +6,7 @@ import {
 } from './cubes.js';
 import { CodexAppServerClient } from './codex-app-server.js';
 import { checkCodexBridgeHealthy } from './codex-remote.js';
-import { hasPendingWakeActivity } from './remote-client.js';
+import { hasPendingWakeActivity, hasPendingWakeEntry } from './remote-client.js';
 import {
   BORG_CODEX_REMOTE_WAKE_ENV,
   resolveSessionAgentKind,
@@ -98,6 +98,7 @@ let wakeInFlight = false;
 const pendingWakeRequests: Array<{
   reason: string;
   deliveryIdentity?: string;
+  sourceEntryId?: string;
   deps: CodexWakeDeps;
 }> = [];
 const deliveredWakeKeys = new Set<string>();
@@ -108,6 +109,8 @@ const DELIVERED_WAKE_KEY_CAP = 100;
 // (mid-turn thread) or missed (transient error) into ONE retried-until-delivered
 // drain. The coalesce gate means a burst collapses to one poller, not N.
 let retryDrainInFlight = false;
+const retryDrainSourceEntryIds = new Set<string>();
+let retryDrainHasUnscopedWork = false;
 
 // gh#857 WI-2: timestamp of the last SUCCESSFUL wake delivery (per-entry OR
 // retry-drain OR heartbeat). The heartbeat reads this (shouldFireHeartbeat) to
@@ -192,6 +195,7 @@ export interface CodexWakeDeps {
   // Per-entry and retry-drain paths do not use this: their pending obligation is
   // already established by a concrete delivered/deferred event.
   hasPendingWork?: (active: ActiveCube) => Promise<boolean>;
+  hasPendingEntry?: (active: ActiveCube, entryId: string) => Promise<boolean>;
   // gh#861 finding 2: lease-ownership gate for the heartbeat tick — a lease-LOSING
   // duplicate child must NOT tick/inject (symmetry with the per-entry path, which
   // only fires inside an SSE session that holds the stream lease). Heartbeat-only;
@@ -280,10 +284,11 @@ export function wakeCodexViaAppServer(
   env: NodeJS.ProcessEnv = process.env,
   deps: CodexWakeDeps = {},
   deliveryIdentity?: string,
+  sourceEntryId?: string,
 ): void {
   const target = resolveCodexWakeTarget(env);
   if (!target.enabled) return;
-  pendingWakeRequests.push({ reason, deliveryIdentity, deps });
+  pendingWakeRequests.push({ reason, deliveryIdentity, sourceEntryId, deps });
   if (wakeInFlight) return;
 
   wakeInFlight = true;
@@ -295,21 +300,30 @@ export function wakeCodexViaAppServer(
 async function drainCodexWakeQueue(): Promise<void> {
   while (pendingWakeRequests.length > 0) {
     const request = pendingWakeRequests.shift()!;
-    await wakeCodexTargeted(request.reason, request.deliveryIdentity, request.deps);
+    await wakeCodexTargeted(
+      request.reason, request.deliveryIdentity, request.sourceEntryId, request.deps,
+    );
   }
 }
 
-async function wakeCodexTargeted(reason: string, deliveryIdentity: string | undefined, deps: CodexWakeDeps): Promise<void> {
+async function wakeCodexTargeted(
+  reason: string,
+  deliveryIdentity: string | undefined,
+  sourceEntryId: string | undefined,
+  deps: CodexWakeDeps,
+): Promise<void> {
   // gh#861 finding 1: another path (heartbeat/retry-drain) is mid-inject into the
   // same thread — defer to the retry-drain so this entry isn't double-injected nor
   // lost (the drain re-syncs the whole burst via the server read-cursor).
   if (!tryAcquireInjectLock()) {
-    scheduleRetryDrain(deps);
+    scheduleRetryDrain(deps, sourceEntryId);
     return;
   }
   try {
     const active = await (deps.getActiveCube ?? getActiveCube)();
     if (!active) return;
+    const pendingEntry = deps.hasPendingEntry ?? hasPendingWakeEntry;
+    if (sourceEntryId && !(await pendingEntry(active, sourceEntryId))) return;
     // gh#855: resolve FRESH (live env socket + re-resolved thread), falling back
     // to the launch-recorded file only when the env socket is absent.
     const resolved = await resolveFreshCodexWakeTarget(active, deps);
@@ -326,9 +340,10 @@ async function wakeCodexTargeted(reason: string, deliveryIdentity: string | unde
         // now. Schedule the retry-drain (coalesced, retried-until-delivered) so
         // the burst's entries are drained once the thread goes idle; codex has no
         // on-disk tail fallback like Claude's borg-inbox-monitor.
-        scheduleRetryDrain(deps);
+        scheduleRetryDrain(deps, sourceEntryId);
         return;
       }
+      if (sourceEntryId && !(await pendingEntry(active, sourceEntryId))) return;
       await client.startTurn(threadId, reason);
       rememberDeliveredWake(wakeKey);
       markDelivered(deps);
@@ -340,7 +355,7 @@ async function wakeCodexTargeted(reason: string, deliveryIdentity: string | unde
     // swallowed (the old best-effort drop let a single blip lose an entry).
     // Schedule the retry-drain so the wake is retried-until-delivered; the SSE
     // stream is never broken (this is fire-and-forget).
-    scheduleRetryDrain(deps);
+    scheduleRetryDrain(deps, sourceEntryId);
   } finally {
     releaseInjectLock();
   }
@@ -357,7 +372,9 @@ async function wakeCodexTargeted(reason: string, deliveryIdentity: string | unde
  * (wakeRetryExpired); the gh#857 WI-2 heartbeat is the backstop beyond that.
  * Never throws into the SSE path (fire-and-forget).
  */
-function scheduleRetryDrain(deps: CodexWakeDeps): void {
+function scheduleRetryDrain(deps: CodexWakeDeps, sourceEntryId?: string): void {
+  if (sourceEntryId) retryDrainSourceEntryIds.add(sourceEntryId);
+  else retryDrainHasUnscopedWork = true;
   if (retryDrainInFlight) return; // coalesce: one loop covers all deferred/missed wakes
   retryDrainInFlight = true;
   void runRetryDrainLoop(deps).finally(() => {
@@ -383,6 +400,15 @@ async function runRetryDrainLoop(deps: CodexWakeDeps): Promise<void> {
     try {
       const active = await (deps.getActiveCube ?? getActiveCube)();
       if (!active) continue; // no active cube yet → keep retrying (until age cap)
+      const pendingEntry = deps.hasPendingEntry ?? hasPendingWakeEntry;
+      for (const entryId of retryDrainSourceEntryIds) {
+        try {
+          if (!(await pendingEntry(active, entryId))) retryDrainSourceEntryIds.delete(entryId);
+        } catch {
+          // Retain the obligation until unread state can be checked.
+        }
+      }
+      if (!retryDrainHasUnscopedWork && retryDrainSourceEntryIds.size === 0) return;
       // gh#855: same FRESH resolution as the per-entry wake, so a stale launch
       // probe can't defeat the retry-drain either.
       const resolved = await resolveFreshCodexWakeTarget(active, deps);
@@ -395,7 +421,13 @@ async function runRetryDrainLoop(deps: CodexWakeDeps): Promise<void> {
         if (thread?.status?.type === 'active') {
           continue; // re-defer: still mid-turn (backoff before next poll)
         }
+        for (const entryId of retryDrainSourceEntryIds) {
+          if (!(await pendingEntry(active, entryId))) retryDrainSourceEntryIds.delete(entryId);
+        }
+        if (!retryDrainHasUnscopedWork && retryDrainSourceEntryIds.size === 0) return;
         await client.startTurn(threadId, CODEX_CATCHUP_PROMPT);
+        retryDrainSourceEntryIds.clear();
+        retryDrainHasUnscopedWork = false;
         markDelivered(deps);
         return; // drain delivered → server read-cursor drains all unread → done
       } finally {
@@ -515,6 +547,8 @@ export function resetCodexWakeForTests(): void {
   deliveredWakeKeys.clear();
   deliveredWakeKeyOrder.length = 0;
   retryDrainInFlight = false;
+  retryDrainSourceEntryIds.clear();
+  retryDrainHasUnscopedWork = false;
   lastDeliveredAt = null;
   heartbeatInFlight = false;
   injectInFlight = false;

package/src/config-utils.ts

@@ -24,6 +24,10 @@ import { shellEscape } from './shell-escape.js';
 import { BORG_STATE_ROOT_ENV, borgAgentConfigEnv, borgHomeRoot } from './private-root.js';
 import type { LaunchAccessPaths } from './launch-access.js';
 import { BORG_LAUNCH_EXPECTED_SEAT_ENV } from './cubes.js';
+import {
+  OPENCODE_SERVER_PASSWORD_ENV,
+  OPENCODE_SERVER_PASSWORD_REFERENCE,
+} from './opencode-launch-trust.js';
 
 // Get __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
@@ -53,6 +57,7 @@ const CLAUDE_CONFIG_PATH = path.join(CONFIG_HOME, '.claude.json');
 const CODEX_CONFIG_PATH = path.join(CONFIG_HOME, '.codex', 'config.toml');
 const CODEX_HOOKS_PATH = path.join(CONFIG_HOME, '.codex', 'hooks.json');
 const OPENCODE_CONFIG_PATH = path.join(CONFIG_HOME, '.config', 'opencode', 'opencode.json');
+const OPENCODE_GLOBAL_CONFIG_FILENAMES = ['config.json', 'opencode.json', 'opencode.jsonc'] as const;
 const MCP_SERVER_NAME = 'borg';
 
 function settingsPath(): string {
@@ -80,6 +85,125 @@ function readJsonFile(p: string): any {
   return JSON.parse(text);
 }
 
+function parseJsonc(text: string): unknown {
+  let stripped = '';
+  let inString = false;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') {
+        lineComment = false;
+        stripped += char;
+      } else {
+        stripped += ' ';
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        stripped += '  ';
+        index++;
+        blockComment = false;
+      } else {
+        stripped += char === '\n' || char === '\r' ? char : ' ';
+      }
+      continue;
+    }
+    if (inString) {
+      stripped += char;
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      stripped += char;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      stripped += '  ';
+      index++;
+      lineComment = true;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      stripped += '  ';
+      index++;
+      blockComment = true;
+      continue;
+    }
+    stripped += char;
+  }
+
+  if (inString || blockComment) throw new SyntaxError('unterminated JSONC token');
+
+  let withoutTrailingCommas = '';
+  inString = false;
+  escaped = false;
+  for (let index = 0; index < stripped.length; index++) {
+    const char = stripped[index];
+    if (inString) {
+      withoutTrailingCommas += char;
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      withoutTrailingCommas += char;
+      continue;
+    }
+    if (char === ',') {
+      let lookahead = index + 1;
+      while (/\s/.test(stripped[lookahead] ?? '')) lookahead++;
+      if (stripped[lookahead] === '}' || stripped[lookahead] === ']') continue;
+    }
+    withoutTrailingCommas += char;
+  }
+
+  return JSON.parse(withoutTrailingCommas.replace(/^\uFEFF/, ''));
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function mergeOpenCodeConfigValue(target: unknown, source: unknown): unknown {
+  if (!isPlainRecord(target) || !isPlainRecord(source)) return source;
+  const merged = Object.assign(Object.create(null) as Record<string, unknown>, target);
+  for (const [key, value] of Object.entries(source)) {
+    merged[key] = key in merged ? mergeOpenCodeConfigValue(merged[key], value) : value;
+  }
+  return merged;
+}
+
+function readOpenCodeGlobalConfig(configPath: string): Record<string, unknown> {
+  const basename = path.basename(configPath);
+  const paths = OPENCODE_GLOBAL_CONFIG_FILENAMES.includes(
+    basename as typeof OPENCODE_GLOBAL_CONFIG_FILENAMES[number],
+  )
+    ? OPENCODE_GLOBAL_CONFIG_FILENAMES.map((filename) => path.join(path.dirname(configPath), filename))
+    : [configPath];
+  let merged: unknown = {};
+  for (const candidate of paths) {
+    if (!fs.existsSync(candidate)) continue;
+    const text = fs.readFileSync(candidate, 'utf-8');
+    if (text.length === 0) continue;
+    const parsed = parseJsonc(text);
+    if (!isPlainRecord(parsed)) throw new TypeError(`OpenCode config is not an object: ${candidate}`);
+    merged = mergeOpenCodeConfigValue(merged, parsed);
+  }
+  if (!isPlainRecord(merged)) throw new TypeError('OpenCode global config is not an object');
+  return merged;
+}
+
 function writeJsonFile(p: string, data: any): void {
   fs.mkdirSync(path.dirname(p), { recursive: true });
   fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf-8');
@@ -1162,22 +1286,18 @@ export function isCodexUserPromptSubmitHookRegistered(hooksPath: string = CODEX_
 // ─── OpenCode MCP integration ────────────────────────────────────────────
 
 /**
- * Detect whether the borg MCP server is already registered in the opencode
- * config (`~/.config/opencode/opencode.json` `mcp.borg`).
+ * Detect whether the borg MCP server is registered in OpenCode's effective
+ * global config. OpenCode 1.18.15 loads `config.json`, `opencode.json`, then
+ * `opencode.jsonc`, merging later files over earlier ones.
  *
- * Reads the config as JSON and checks for a `mcp.borg` entry with
+ * Reads JSON or JSONC and checks the effective `mcp.borg` entry for
  * `type: "local"`. Safe-default: any read error returns `false`.
  */
 export function isOpenCodeMcpServerConfigured(
   configPath: string = path.join(borgHomeRoot(), '.config', 'opencode', 'opencode.json')
 ): boolean {
   try {
-    if (!fs.existsSync(configPath)) return false;
-    const text = fs.readFileSync(configPath, 'utf-8');
-    if (!text.trim()) return false;
-    const parsed = JSON.parse(text);
-    if (!parsed || typeof parsed !== 'object') return false;
-    const borgServer = (parsed as any).mcp?.borg;
+    const borgServer = (readOpenCodeGlobalConfig(configPath) as any).mcp?.borg;
     if (!borgServer || typeof borgServer !== 'object') return false;
     return borgServer.type === 'local';
   } catch {
@@ -1186,22 +1306,24 @@ export function isOpenCodeMcpServerConfigured(
 }
 
 /**
- * Launch-time OpenCode registration check. Ordinary launches retain the
- * existing configured/not-configured behavior. A targeted `borg launch`,
- * identified by its non-empty expected-seat marker, additionally requires the
- * config substitution that carries that marker into OpenCode's MCP child.
+ * Launch-time OpenCode registration check. Every launch requires the exact
+ * password substitution that carries its ephemeral credential into OpenCode's
+ * MCP child. A targeted `borg launch`, identified by its non-empty expected-seat
+ * marker, additionally requires the substitution that carries that marker.
  */
 export function isOpenCodeMcpServerConfiguredForLaunch(
   configPath: string = path.join(borgHomeRoot(), '.config', 'opencode', 'opencode.json'),
   env: NodeJS.ProcessEnv = process.env,
 ): boolean {
   if (!isOpenCodeMcpServerConfigured(configPath)) return false;
-  if (!env[BORG_LAUNCH_EXPECTED_SEAT_ENV]) return true;
   try {
-    const borgServer = readJsonFile(configPath)?.mcp?.borg;
+    const borgServer = (readOpenCodeGlobalConfig(configPath) as any).mcp?.borg;
     const environment = borgServer?.environment ?? borgServer?.env;
-    return environment?.[BORG_LAUNCH_EXPECTED_SEAT_ENV] ===
-      OPENCODE_LAUNCH_EXPECTED_SEAT_REFERENCE;
+    if (environment?.[OPENCODE_SERVER_PASSWORD_ENV] !== OPENCODE_SERVER_PASSWORD_REFERENCE) {
+      return false;
+    }
+    if (!env[BORG_LAUNCH_EXPECTED_SEAT_ENV]) return true;
+    return environment?.[BORG_LAUNCH_EXPECTED_SEAT_ENV] === OPENCODE_LAUNCH_EXPECTED_SEAT_REFERENCE;
   } catch {
     return false;
   }
@@ -1278,11 +1400,11 @@ export function addOpenCodeLaunchAccess(
 
 /**
  * Add borg MCP server to OpenCode using `opencode mcp add` CLI.
- * Pins activation and agent-kind signals plus an OpenCode config substitution
- * for the launch-scoped expected seat. OpenCode resolves `{env:NAME}` from its
- * own launch environment before starting the MCP child, so `borg launch`
- * reaches the identity check without persisting one launch's value. Existing
- * configs with BORG_OPENCODE remain supported by the runtime fallback.
+ * Pins activation and agent-kind signals plus OpenCode config substitutions
+ * for the launch-scoped password and expected seat. OpenCode resolves
+ * `{env:NAME}` from its own launch environment before starting the MCP child,
+ * so no launch credential is persisted. Existing configs with BORG_OPENCODE
+ * remain supported by the runtime fallback after launch-time self-healing.
  */
 export function addOpenCodeMcpServer(): void {
   try {
@@ -1295,8 +1417,10 @@ export function addOpenCodeMcpServer(): void {
       : '';
     const launchExpectedSeatEnvArg =
       ` --env ${BORG_LAUNCH_EXPECTED_SEAT_ENV}=${shellQuote(OPENCODE_LAUNCH_EXPECTED_SEAT_REFERENCE)}`;
+    const apiPasswordEnvArg =
+      ` --env ${OPENCODE_SERVER_PASSWORD_ENV}=${shellQuote(OPENCODE_SERVER_PASSWORD_REFERENCE)}`;
     execSync(
-      `opencode mcp add borg --env BORG_SESSION=1 --env BORG_AGENT_KIND=opencode --env BORG_OPENCODE=1${apiUrlEnvArg}${stateRootEnvArg}${launchExpectedSeatEnvArg} -- ${shellQuote(MCP_COMMAND)}`,
+      `opencode mcp add borg --env BORG_SESSION=1 --env BORG_AGENT_KIND=opencode --env BORG_OPENCODE=1${apiUrlEnvArg}${stateRootEnvArg}${launchExpectedSeatEnvArg}${apiPasswordEnvArg} -- ${shellQuote(MCP_COMMAND)}`,
       { stdio: 'inherit', env: borgAgentConfigEnv(process.env) }
     );
   } catch (error: any) {

package/src/cube-activity-wake-copy.ts

@@ -1,5 +1,5 @@
 export const CUBE_ACTIVITY_RESUME_WAKE_MESSAGE =
-  'Borg cube activity arrived while you were busy. Reading cube messages does not end your current task. Drain `borg_read-log unread_only=true` until caught up, handle actionable entries, then RESUME the interrupted work.';
+  'Borg cube activity arrived while you were busy. Reading cube messages does not end your current task. Drain `borg_read-log unread_only=true` until caught up, handle actionable entries, then RESUME the interrupted work. If the unread drain is empty, resume silently without a liveness post or full regen.';
 
 export function formatCubeActivityWakeMessage(detail: string): string {
   return `${CUBE_ACTIVITY_RESUME_WAKE_MESSAGE}\n${detail}`;

package/src/index.ts

@@ -139,6 +139,7 @@ import {
   openCodeLaunchBinding,
 } from './opencode-drone.js';
 import { installBorgPlugin } from './opencode-plugin.js';
+import { openCodeApiPasswordFromEnv } from './opencode-launch-trust.js';
 import { setModuleInjectOpenCode } from './log-stream.js';
 import {
   lifecycleSignalForMessage,
@@ -261,9 +262,15 @@ export async function connectOpenCodeRuntime(
     console.error(OPEN_CODE_PORT_MISSING_DIAGNOSTIC);
     return false;
   }
+  const apiPassword = openCodeApiPasswordFromEnv(env);
+  if (apiPassword === null) {
+    console.error('OpenCode API credential is missing or unverifiable; skipping OpenCode entry injection. Relaunch through borg.');
+    return false;
+  }
   const binding = openCodeLaunchBinding(configuredPort);
   await (deps.connect ?? connectOpenCodeDrone)({
     serverUrl: binding.serverUrl,
+    apiPassword,
     directory: active.worktree ?? findProjectRoot(),
     droneLabel: active.droneLabel,
     cubeName: active.name,

package/src/log-stream.ts

@@ -125,12 +125,14 @@ function isProcessAlive(pid: number): boolean {
  * Used by defaultDeps when no explicit injectOpenCode is supplied.
  */
 let _moduleInjectOpenCode:
-  | ((text: string, entryId: string, allowSubmit: boolean, sourceEntryId?: string) => Promise<boolean>)
+  | ((text: string, entryId: string, allowSubmit: boolean, sourceEntryId?: string,
+      isSourcePending?: () => Promise<boolean>) => Promise<boolean>)
   | undefined;
 let _moduleSettleOpenCodeEntry: ((sourceEntryId: string) => void) | undefined;
 
 export function setModuleInjectOpenCode(
-  fn: (text: string, entryId: string, allowSubmit: boolean, sourceEntryId?: string) => Promise<boolean>,
+  fn: (text: string, entryId: string, allowSubmit: boolean, sourceEntryId?: string,
+    isSourcePending?: () => Promise<boolean>) => Promise<boolean>,
   settle: (sourceEntryId: string) => void,
 ): void {
   _moduleInjectOpenCode = fn;
@@ -392,7 +394,7 @@ export interface StreamDeps {
     renderedLine: string
   ) => Promise<boolean>;
   /** Optional Codex app-server wake sink; tests inject a spy. */
-  wakeCodex?: (reason: string, deliveryIdentity?: string) => void;
+  wakeCodex?: (reason: string, deliveryIdentity?: string, sourceEntryId?: string) => void;
   /** Override the heartbeat watchdog timeout. */
   heartbeatTimeoutMs?: number;
   /** Override HWM divergence grace for focused tests. */
@@ -409,6 +411,7 @@ export interface StreamDeps {
     entryId: string,
     allowSubmit: boolean,
     sourceEntryId?: string,
+    isSourcePending?: () => Promise<boolean>,
   ) => Promise<boolean>;
   /** Inspect whether one retry source remains beyond the durable unread cursor. */
   hasPendingWakeEntry?: (active: ActiveCube, entryId: string) => Promise<boolean>;
@@ -422,16 +425,16 @@ const defaultDeps: Required<StreamDeps> = {
   getCursor: getLocalServerCursor,
   appendLine: defaultAppendLine,
   hasInboxEntryId: defaultHasInboxEntryId,
-  wakeCodex: (reason, deliveryIdentity) =>
-    wakeCodexViaAppServer(reason, process.env, {}, deliveryIdentity),
+  wakeCodex: (reason, deliveryIdentity, sourceEntryId) =>
+    wakeCodexViaAppServer(reason, process.env, {}, deliveryIdentity, sourceEntryId),
   heartbeatTimeoutMs: HEARTBEAT_TIMEOUT_MS,
   hwmDivergenceGraceMs: HWM_DIVERGENCE_GRACE_MS,
   abortSignal: new AbortController().signal,
   ownerDeps: {},
   ownerStaleMs: 70_000,
-  injectOpenCode: (text, entryId, allowSubmit, sourceEntryId) =>
+  injectOpenCode: (text, entryId, allowSubmit, sourceEntryId, isSourcePending) =>
     _moduleInjectOpenCode
-      ? _moduleInjectOpenCode(text, entryId, allowSubmit, sourceEntryId)
+      ? _moduleInjectOpenCode(text, entryId, allowSubmit, sourceEntryId, isSourcePending)
       : Promise.resolve(false),
   hasPendingWakeEntry: (active, entryId) => hasPendingDurableWakeEntry(
     active as Parameters<typeof hasPendingDurableWakeEntry>[0],
@@ -902,7 +905,10 @@ export async function streamOnce(
       // OpenCode queue. A still-unread re-ping may reconcile the prior attempt;
       // its source entry ID prevents a new nonce from resubmitting that prompt.
       if (isReping) {
-        await injectOpenCode(formatOpenCodeWakePrompt(line), deliveryId, true, ev.id);
+        await injectOpenCode(
+          formatOpenCodeWakePrompt(line), deliveryId, true, ev.id,
+          () => hasPendingWakeEntry(active, ev.id),
+        );
       }
       markEventPersisted(ev.id, ev.data?.created_at ?? '');
       return 'persisted-skip';
@@ -910,12 +916,12 @@ export async function streamOnce(
     // The inbox append is the durable record. OpenCode injection is only the
     // wake attempt and may return before the agent finishes processing.
     await appendLine(active.cubeId, active.droneId, line);
-    const openCodeDelivered = isReping
-      ? await injectOpenCode(formatOpenCodeWakePrompt(line), deliveryId, true, ev.id)
-      : await injectOpenCode(formatOpenCodeWakePrompt(line), deliveryId, true);
+    const openCodeDelivered = await injectOpenCode(
+      formatOpenCodeWakePrompt(line), deliveryId, true, ev.id,
+      () => hasPendingWakeEntry(active, ev.id),
+    );
     if (!openCodeDelivered) {
-      if (ev.wake_nonce === undefined) wakeCodex(formatCodexWakePrompt(line));
-      else wakeCodex(formatCodexWakePrompt(line), ev.wake_nonce);
+      wakeCodex(formatCodexWakePrompt(line), ev.wake_nonce, ev.id);
     }
     return 'written';
   };
@@ -1234,9 +1240,12 @@ export async function streamOnce(
           if (
             wakeNonce !== undefined &&
             await shouldDeliverWakeRetry(event.id) &&
-            !(await injectOpenCode(formatOpenCodeWakePrompt(line), wakeNonce, true, event.id))
+            !(await injectOpenCode(
+              formatOpenCodeWakePrompt(line), wakeNonce, true, event.id,
+              () => hasPendingWakeEntry(active, event.id),
+            ))
           ) {
-            wakeCodex(formatCodexWakePrompt(line), wakeNonce);
+            wakeCodex(formatCodexWakePrompt(line), wakeNonce, event.id);
           }
           continue;
         }