borgmcp 5.1.2 → 5.3.0

package/src/assimilate-cmd.ts

@@ -10,20 +10,15 @@ import {
 import { validateName } from './name-validator.js';
 import { renderAssimilationWelcome } from './assimilate-welcome.js';
 import { shellEscape } from './shell-escape.js';
-import { withCodexCwdArg, type CodexRemoteLaunch } from './codex-remote.js';
+import { type CodexRemoteLaunch } from './codex-remote.js';
 import {
   buildAgentKickoffPrompt,
   buildKickoffWakePathClause,
-  recordCodexWakeTarget,
-  socketPathFromRemoteArgs,
+  buildCodexLaunchArgs,
 } from './codex-launch.js';
 import { perWorktreeBranchName, computeWorktreePath, localBranchExists, isMerged } from './worktree-lifecycle.js';
 import { DroneEvictedError } from './drone-lifecycle.js';
-import { codexBorgSessionConfigArgs } from './launch-gate.js';
 import {
-  codexAgentKindConfigArgs,
-  codexRemoteWakeConfigArgs,
-  codexStateRootConfigArgs,
   withAgentRuntimeEnv,
 } from './agent-runtime.js';
 import {
@@ -405,13 +400,6 @@ export interface AssimilateDeps {
   setCliPreferenceForWorktree: (cli: BorgCli, worktree: string) => Promise<void>;
   resolveCli: (explicit?: BorgCli) => Promise<BorgCli>;
   prepareCodexRemoteLaunch: () => Promise<CodexRemoteLaunch>;
-  setCodexWakeTarget: (cubeId: string, droneId: string, target: { threadId: string; socketPath: string }) => Promise<void>;
-  findLoadedCodexThread: (options: {
-    socketPath: string;
-    cwd: string;
-    previewIncludes: string;
-    updatedAfter: number;
-  }) => Promise<string | null>;
 
 }
 
@@ -952,13 +940,11 @@ export async function finalizeAssimilationSeat(
 export type LaunchDeps = Pick<
   AssimilateDeps,
   | 'exec'
-  | 'findLoadedCodexThread'
   | 'getInboxPath'
   | 'isTTY'
   | 'prepareCodexRemoteLaunch'
   | 'probeMcpReady'
   | 'resolveCliApprovals'
-  | 'setCodexWakeTarget'
   | 'setTerminalTitle'
   | 'stderr'
   | 'stdout'
@@ -1019,17 +1005,14 @@ export async function launchAssimilatedAgent(
     );
   }
   const inboxPath = deps.getInboxPath(result.cube_id, result.drone_id);
-  const codexWakeNonce = cli === 'codex' ? `borg-wake-${randomUUID()}` : null;
   const monitorClause = buildKickoffWakePathClause(
     cli,
     cli === 'claude' ? inboxPath : null,
     cli === 'claude' ? monitorStateRoot : null,
   );
-  let codexWakePathClause: string | undefined;
-  let remoteArgs: string[] = [];
   let launchArgs: string[];
-  let codexSocketPath: string | null = null;
   let codexServerCleanup: (() => void) | null = null;
+  let codexRemote: CodexRemoteLaunch | null = null;
   const launchApproval = deps.resolveCliApprovals
     ? await deps.resolveCliApprovals(cli, agentCwd, { skipOverride: flags.noBorgApprovalOverride })
     : { codexArgs: [] };
@@ -1050,39 +1033,36 @@ export async function launchAssimilatedAgent(
   for (const key of modelEnv.unset) delete childEnv[key];
 
   if (cli === 'codex') {
-    const remote = await deps.prepareCodexRemoteLaunch();
-    if (remote.warning) {
-      deps.stderr(`warning: ${remote.warning}\n`);
-      codexWakePathClause =
-        '⚠ Codex wake-path capability check failed: remote-control is unavailable for this session. Run borg_regen manually whenever you return, and expect only fallback wakeups until relaunch.';
-    } else {
-      codexWakePathClause = 'Codex wake-path capability check passed: remote-control socket established for this session.';
+    codexRemote = await deps.prepareCodexRemoteLaunch();
+    if (!codexRemote.ready) {
+      const stderr = codexRemote.stderr ? `\n${codexRemote.stderr}` : '';
+      deps.stderr(`Codex launch refused: ${codexRemote.reason}${stderr}\n`);
+      return 1;
     }
-    remoteArgs = remote.args;
-    if (Object.keys(remote.env).length > 0) Object.assign(childEnv, remote.env);
-    codexSocketPath = socketPathFromRemoteArgs(remote.args);
-    codexServerCleanup = remote.server?.cleanup ?? null;
+    Object.assign(childEnv, codexRemote.env);
+    codexServerCleanup = codexRemote.server.cleanup;
   }
   const kickoff = buildAgentKickoffPrompt({
     cli,
-    codexWakeNonce,
     monitorClause,
-    codexWakePathClause,
   });
   let openCodeKickoff: ReturnType<typeof createOpenCodeLaunchKickoff> | null = null;
   let dronePort: number | undefined;
   launchArgs = [kickoff];
   if (cli === 'codex') {
-    launchArgs = [
-      ...codexLaunchDirectoryArgs(launchAccessPaths),
-      ...launchApproval.codexArgs,
-      ...codexBorgSessionConfigArgs(),
-      ...codexAgentKindConfigArgs(),
-      ...codexRemoteWakeConfigArgs(codexSocketPath !== null),
-      ...codexStateRootConfigArgs(),
-      ...remoteArgs,
-      ...withCodexCwdArg(launchArgs, agentCwd),
-    ];
+    const plan = buildCodexLaunchArgs({
+      remote: codexRemote!,
+      cwd: agentCwd,
+      kickoff,
+      approvalArgs: launchApproval.codexArgs,
+      accessArgs: codexLaunchDirectoryArgs(launchAccessPaths),
+    });
+    if (!plan.ready) {
+      codexServerCleanup?.();
+      deps.stderr(`Codex launch refused: ${plan.reason}\n`);
+      return 1;
+    }
+    launchArgs = plan.args;
   } else if (cli === 'opencode') {
     dronePort = await allocateOpenCodePort();
     childEnv.BORG_OPENCODE_PORT = String(dronePort);
@@ -1094,17 +1074,12 @@ export async function launchAssimilatedAgent(
     launchArgs = buildOpenCodeLaunchArgs(agentCwd, dronePort, openCodeKickoff.prompt);
   }
 
-  const exitPromise = deps.exec(cli, launchArgs, agentCwd, childEnv);
-  if (cli === 'codex' && codexSocketPath && codexWakeNonce) {
-    void recordCodexWakeTarget({
-      deps,
-      cubeId: result.cube_id,
-      droneId: result.drone_id,
-      socketPath: codexSocketPath,
-      cwd: agentCwd,
-      previewNeedle: codexWakeNonce,
-      launchedAtSeconds: Math.floor(Date.now() / 1000),
-    });
+  let exitPromise: Promise<number>;
+  try {
+    exitPromise = deps.exec(cli, launchArgs, agentCwd, childEnv);
+  } catch (error) {
+    codexServerCleanup?.();
+    throw error;
   }
   if (cli === 'opencode' && openCodeKickoff) {
     const launchKickoff = openCodeKickoff;
@@ -1117,12 +1092,14 @@ export async function launchAssimilatedAgent(
       launchIdentity: launchKickoff.correlationIdentity,
     }).then(() => injectInitialKickoff(launchKickoff)).catch(() => {});
   }
-  const exitCode = await exitPromise;
-  if (codexServerCleanup) {
+  let exitCode: number;
+  try {
+    exitCode = await exitPromise;
+  } finally {
     try {
-      codexServerCleanup();
+      codexServerCleanup?.();
     } catch {
-      // Best-effort cleanup after a normal Codex exit.
+      // Best-effort cleanup after Codex exits or fails to spawn.
     }
   }
   if (spawnedWorktreePath && originalCwd !== spawnedWorktreePath) {

package/src/assimilate-deps.ts

@@ -61,7 +61,6 @@ import {
   hasPersistedActiveCube as cubesHasPersistedActive,
   inboxPathForDrone,
   setProjectCliPreference,
-  setCodexWakeTarget,
 } from './cubes.js';
 import {
   addProjectSessionStartHook,
@@ -71,7 +70,6 @@ import { findPendingServerEnrollment, listServerCredentialOrigins } from './conf
 import { setTerminalTitle as setTitle } from './terminal-title.js';
 import { defaultCliChoiceDeps, resolveCliChoice } from './cli-platform.js';
 import { prepareCodexRemoteLaunch, defaultCodexRemoteDeps } from './codex-remote.js';
-import { findLoadedCodexThread } from './codex-app-server.js';
 import { defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
 import { ensurePrivateBorgConfigRoot } from './private-root.js';
 import {
@@ -577,7 +575,5 @@ export function buildDefaultAssimilateDeps(
     ),
     setCliPreferenceForWorktree: (cli, worktree) => setProjectCliPreference(cli, worktree),
     prepareCodexRemoteLaunch: () => prepareCodexRemoteLaunch(defaultCodexRemoteDeps()),
-    setCodexWakeTarget,
-    findLoadedCodexThread,
   };
 }

package/src/claude.ts

@@ -16,7 +16,6 @@
  */
 
 import { spawn } from 'child_process';
-import { randomUUID } from 'node:crypto';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename } from 'node:path';
@@ -30,8 +29,6 @@ import {
   getActiveCube,
   inboxPathForDrone,
   LaunchSeatIdentityChangedError,
-  setCodexWakeTarget,
-  pruneDeadCodexWakeTargets,
   type ActiveCube,
   type BorgCli,
 } from './cubes.js';
@@ -82,22 +79,15 @@ import { setTerminalTitle } from './terminal-title.js';
 import { initConsolePrefix, consolePrefix } from './console-prefix.js';
 import { initDebugFromArgv } from './debug.js';
 import { configuredCliNames, defaultCliChoiceDeps, detectCliAvailability, detectCliConfiguration, parseCliFlag, resolveCliChoice } from './cli-platform.js';
-import { prepareCodexRemoteLaunch, resolveCodexLaunchCwd, withCodexCwdArg, defaultCodexRemoteDeps, checkCodexBridgeHealthy } from './codex-remote.js';
+import { prepareCodexRemoteLaunch, resolveCodexLaunchCwd, defaultCodexRemoteDeps } from './codex-remote.js';
 import {
-  BORG_CODEX_REMOTE_WAKE_ENV,
-  codexAgentKindConfigArgs,
-  codexRemoteWakeConfigArgs,
-  codexStateRootConfigArgs,
   withAgentRuntimeEnv,
 } from './agent-runtime.js';
-import { findLoadedCodexThread } from './codex-app-server.js';
 import {
   buildAgentKickoffPrompt,
   buildKickoffWakePathClause,
-  recordCodexWakeTarget,
-  socketPathFromRemoteArgs,
+  buildCodexLaunchArgs,
 } from './codex-launch.js';
-import { codexBorgSessionConfigArgs } from './launch-gate.js';
 import {
   addCodexSessionStartHook,
   addCodexUserPromptSubmitHook,
@@ -639,9 +629,6 @@ async function main() {
       : null
   );
 
-  const codexWakeNonce = cli === 'codex' ? `borg-wake-${randomUUID()}` : null;
-  let codexWakePathClause: string | undefined;
-  let remoteArgs: string[] = [];
   // gh#673 P1: mark the agent session as borg-launched. Claude Code's MCP
   // child + hook commands inherit this env, gating the borg activation
   // surface (launch-gate.ts). ACTIVATION-only — never a security gate.
@@ -654,45 +641,33 @@ async function main() {
   if (cli === 'opencode' && launchApproval.openCodePermission) {
     launchEnv.OPENCODE_PERMISSION = launchApproval.openCodePermission;
   }
-  let codexSocketPath: string | null = null;
   let codexServerCleanup: (() => void) | null = null;
-  if (cli === 'codex' && !passthroughArgs.includes('--remote')) {
+  let codexRemote: Awaited<ReturnType<typeof prepareCodexRemoteLaunch>> | null = null;
+  if (cli === 'codex') {
+    if (passthroughArgs.some((arg) => arg === '--remote' || arg.startsWith('--remote='))) {
+      console.error(`${consolePrefix()}${chalk.red('Codex launch refused: Borg owns Codex remote control; remove the passthrough --remote option and retry.')}`);
+      process.exit(1);
+      return;
+    }
     console.error(`${consolePrefix()}${chalk.gray('◼ Starting Codex remote-wake app-server…')}`);
-    const remote = await prepareCodexRemoteLaunch(defaultCodexRemoteDeps());
-    if (remote.warning) {
-      console.error(`${consolePrefix()}${chalk.yellow(`warning: ${remote.warning}`)}`);
-      codexWakePathClause =
-        `⚠ Codex wake-path capability check failed: remote-control is unavailable for this session. Run borg_regen manually whenever you return, and expect only fallback wakeups until relaunch.`;
-    } else {
-      codexWakePathClause =
-        `Codex wake-path capability check passed: remote-control socket established for this session.`;
+    codexRemote = await prepareCodexRemoteLaunch(defaultCodexRemoteDeps());
+    if (!codexRemote.ready) {
+      const stderr = codexRemote.stderr ? `\n${codexRemote.stderr}` : '';
+      console.error(`${consolePrefix()}${chalk.red(`Codex launch refused: ${codexRemote.reason}${stderr}`)}`);
+      process.exit(1);
+      return;
     }
-    remoteArgs = remote.args;
     launchEnv = {
       ...withAgentRuntimeEnv(process.env, cli),
-      ...remote.env,
+      ...codexRemote.env,
       BORG_SESSION: '1',
     };
-    codexSocketPath = socketPathFromRemoteArgs(remote.args);
-    codexServerCleanup = remote.server?.cleanup ?? null;
-  } else if (cli === 'codex' && passthroughArgs.includes('--remote')) {
-    codexWakePathClause =
-      `Codex wake-path capability check: using caller-provided --remote socket; if no wake arrives, run borg_regen manually when returning to the session.`;
-    codexSocketPath = socketPathFromRemoteArgs(passthroughArgs);
-    if (codexSocketPath) {
-      launchEnv = {
-        ...withAgentRuntimeEnv(process.env, cli),
-        [BORG_CODEX_REMOTE_WAKE_ENV]: '1',
-        BORG_SESSION: '1',
-      };
-    }
+    codexServerCleanup = codexRemote.server.cleanup;
   }
 
   const kickoff = buildAgentKickoffPrompt({
     cli,
-    codexWakeNonce,
     monitorClause,
-    codexWakePathClause,
   });
   // This stays separate from the shared kickoff so OpenCode can carry
   // launch-only API and correlation identities outside argv and prompt text.
@@ -700,29 +675,26 @@ async function main() {
   let openCodePort: number | undefined;
   let launchArgs: string[];
   if (cli === 'codex') {
-    // gh#673 P1-codex: codex MCP children only see the pinned
-    // [mcp_servers.borg.env], never inherited env (V2 probe) — deliver
-    // the borg-launch marker and selected CLI identity via per-invocation
-    // -c overrides instead (V2b-proven). Remote wake remains a separate
-    // transport capability, explicitly disabled when this launch has no
-    // socket so legacy static config cannot spuriously arm a bridge.
-    // client#20: the exact approval overrides above are launch-scoped and
-    // consented. They remain separate from activation/identity/wake config.
-    launchArgs = [
-      ...launchApproval.codexArgs,
-      ...codexBorgSessionConfigArgs(),
-      ...codexAgentKindConfigArgs(),
-      ...codexRemoteWakeConfigArgs(codexSocketPath !== null),
-      ...codexStateRootConfigArgs(),
-      ...codexLaunchSeatExpectationConfigArgs(),
-      ...remoteArgs,
-      ...withCodexCwdArg([...passthroughArgs, kickoff], process.cwd()),
-    ];
+    const plan = buildCodexLaunchArgs({
+      remote: codexRemote!,
+      cwd: process.cwd(),
+      kickoff,
+      approvalArgs: launchApproval.codexArgs,
+      seatExpectationArgs: codexLaunchSeatExpectationConfigArgs(),
+      passthroughArgs,
+    });
+    if (!plan.ready) {
+      codexServerCleanup?.();
+      console.error(`${consolePrefix()}${chalk.red(`Codex launch refused: ${plan.reason}`)}`);
+      process.exit(1);
+      return;
+    }
+    launchArgs = plan.args;
   } else if (cli === 'opencode') {
     // OpenCode launch: start TUI with the kickoff passed via --prompt
     // (auto-submits it as the first message). BORG_SESSION is pinned in
-    // opencode.json. The OS-selected loopback port lets the MCP child connect
-    // to OpenCode's local HTTP API without a shared deterministic collision space.
+    // opencode.json. Wake delivery uses HTTP entry injection through OpenCode's local HTTP API;
+    // the OS-selected port avoids a deterministic collision space.
     openCodePort = await allocateOpenCodePort();
     installBorgPlugin();
     openCodeKickoff = createOpenCodeLaunchKickoff(kickoff);
@@ -749,25 +721,6 @@ async function main() {
       })).process
     : spawn(cli, launchArgs, { stdio: 'inherit', shell: false, env: launchEnv });
 
-  // gh#857 WI-2: wake-target recording is codex-only (app-server bridge).
-  // OpenCode uses HTTP entry injection; Claude uses the inbox Monitor.
-  if (cli === 'codex' && active && codexSocketPath) {
-    void recordCodexWakeTarget({
-      deps: { setCodexWakeTarget, findLoadedCodexThread },
-      cubeId: active.cubeId,
-      droneId: active.droneId,
-      socketPath: codexSocketPath,
-      passthroughArgs,
-      previewNeedle: codexWakeNonce ?? kickoff.slice(0, 120),
-      cwd: process.cwd(),
-      launchedAtSeconds: Math.floor(Date.now() / 1000),
-    });
-    // gh#855: self-heal the wake-target file — drop entries whose app-server
-    // socket is positively dead (crashed prior launches), mirroring the
-    // socket-dir pruneStaleSockets. Best-effort; never blocks the launch.
-    void pruneDeadCodexWakeTargets((sock) => checkCodexBridgeHealthy(sock));
-  }
-
   agentProcess.on('error', (err: NodeJS.ErrnoException) => {
     if (codexServerCleanup) {
       try {

package/src/codex-app-server.ts

@@ -7,6 +7,10 @@ export interface CodexThreadSummary {
   preview: string;
   status: { type: string };
   updatedAt: number;
+  source?: unknown;
+  ephemeral?: boolean;
+  threadSource?: string;
+  turns?: unknown[];
 }
 
 interface PendingRequest {
@@ -85,6 +89,10 @@ export class CodexAppServerClient {
       preview: thread.preview,
       status: thread.status,
       updatedAt: thread.updatedAt,
+      source: thread.source,
+      ephemeral: thread.ephemeral,
+      threadSource: thread.threadSource,
+      turns: thread.turns,
     };
   }
 
@@ -159,31 +167,6 @@ export class CodexAppServerClient {
   }
 }
 
-export async function findLoadedCodexThread(options: {
-  socketPath: string;
-  cwd: string;
-  previewIncludes: string;
-  updatedAfter: number;
-}): Promise<string | null> {
-  const client = new CodexAppServerClient(options.socketPath);
-  await client.connect();
-  try {
-    const ids = await client.loadedThreadIds();
-    let best: CodexThreadSummary | null = null;
-    for (const id of ids) {
-      const thread = await client.readThread(id);
-      if (!thread) continue;
-      if (thread.cwd !== options.cwd) continue;
-      if (!thread.preview.includes(options.previewIncludes)) continue;
-      if (thread.updatedAt < options.updatedAfter) continue;
-      if (!best || thread.updatedAt > best.updatedAt) best = thread;
-    }
-    return best?.id ?? null;
-  } finally {
-    client.close();
-  }
-}
-
 function encodeWebSocketTextFrame(text: string): Buffer {
   const payload = Buffer.from(text);
   let header: Buffer;

package/src/codex-app-wake.ts

@@ -1,11 +1,11 @@
 import {
   getActiveCube,
-  getCodexWakeTarget,
-  setCodexWakeTarget,
   type ActiveCube,
 } from './cubes.js';
+import { existsSync } from 'node:fs';
 import { CodexAppServerClient } from './codex-app-server.js';
 import { checkCodexBridgeHealthy } from './codex-remote.js';
+import { debugLog } from './debug.js';
 import { hasPendingWakeActivity, hasPendingWakeEntry } from './remote-client.js';
 import {
   BORG_CODEX_REMOTE_WAKE_ENV,
@@ -14,7 +14,6 @@ import {
 import {
   codexAppServerSocketFromEnv,
   pickFreshThread,
-  wakeTargetChanged,
   wakeRetryBackoffMs,
   wakeRetryExpired,
   WAKE_RETRY_MAX_ATTEMPTS,
@@ -69,26 +68,25 @@ export function resolveCodexWakeTarget(env: NodeJS.ProcessEnv = process.env): Co
  * (which is false-by-design for codex and falsely flagged them, gh#633).
  *
  * Tri-state (boolean|null; caller maps null→armed for false-deaf-avoidance):
- *   - false ONLY on a positively-dead bridge: no wake target registered (the
- *     bridge cannot deliver wakes), OR the app-server pid is dead.
- *   - true when the wake target resolves AND the app-server pid is alive.
- *   - null when the bridge health is indeterminate (target read or pid check
- *     could not resolve) → armed (don't false-flag on uncertainty).
+ *   - false when this child has no live socket, the socket file is missing, or
+ *     the app-server pid is dead.
+ *   - true when the env socket exists and the app-server pid is alive.
+ *   - null when the pidfile cannot be read or parsed.
  */
 export async function probeCodexBridgeArmed(
-  active: { cubeId: string; droneId: string },
+  _active: { cubeId: string; droneId: string },
   deps: {
-    getCodexWakeTarget?: typeof getCodexWakeTarget;
+    env?: NodeJS.ProcessEnv;
+    socketExists?: (socketPath: string) => boolean;
     checkBridge?: typeof checkCodexBridgeHealthy;
   } = {}
 ): Promise<boolean | null> {
   try {
-    const resolve = deps.getCodexWakeTarget ?? getCodexWakeTarget;
-    const target = await resolve(active.cubeId, active.droneId);
-    // No registered wake target → the bridge cannot deliver a wake → not armed.
-    if (!target) return false;
+    const socketPath = codexAppServerSocketFromEnv(deps.env ?? process.env);
+    if (!socketPath) return false;
+    if (!(deps.socketExists ?? existsSync)(socketPath)) return false;
     const check = deps.checkBridge ?? checkCodexBridgeHealthy;
-    return check(target.socketPath);
+    return check(socketPath);
   } catch {
     return null;
   }
@@ -280,9 +278,6 @@ function defaultSleep(ms: number): Promise<void> {
 
 export interface CodexWakeDeps {
   getActiveCube?: typeof getActiveCube;
-  getCodexWakeTarget?: typeof getCodexWakeTarget;
-  // gh#855: self-heal write of the freshly-resolved target (write-only-on-change).
-  setCodexWakeTarget?: typeof setCodexWakeTarget;
   createClient?: (
     socketPath: string
   ) => Pick<CodexAppServerClient, 'connect' | 'readThread' | 'startTurn' | 'loadedThreadIds' | 'close'>;
@@ -320,12 +315,9 @@ export interface CodexWakeDeps {
 /**
  * gh#855: FRESH wake-target resolution. Prefer THIS drone's live app-server
  * socket (pinned into the child's env at spawn) and re-resolve the loaded thread
- * NOW (loadedThreadIds is re-runnable) — so a missed/stale launch probe or a
- * thread change can never cause permanent deafness. Self-heals the file cache
- * (write-only-on-change) so other readers (probeCodexBridgeArmed / health-beat)
- * stay current. Falls back to the launch-recorded file when the env socket is
- * absent (un-upgraded launch) — no regression. Returns the resolved target, or
- * null (caller skips this wake; the next one retries). Does NOT keep a
+ * NOW (loadedThreadIds is re-runnable), so a thread change cannot cause
+ * permanent deafness. The live env socket is the sole source. Returns the
+ * resolved target, or null when the socket/thread is unavailable. Does NOT keep a
  * connection open — the env path opens a short-lived probe client to re-resolve
  * the thread, then closes it, so the caller can dedup BEFORE opening the wake
  * connection (no reconnect on an already-delivered wake).
@@ -338,52 +330,31 @@ function makeCodexClient(
 }
 
 async function resolveFreshCodexWakeTarget(
-  active: { cubeId: string; droneId: string },
+  _active: { cubeId: string; droneId: string },
   deps: CodexWakeDeps
 ): Promise<{ socketPath: string; threadId: string } | null> {
   const envSocket = codexAppServerSocketFromEnv(deps.env ?? process.env);
-  if (envSocket) {
-    const probe = makeCodexClient(envSocket, deps);
-    await probe.connect();
-    try {
-      const ids = await probe.loadedThreadIds();
-      const summaries: CodexThreadInfo[] = [];
-      for (const id of ids) {
-        const t = await probe.readThread(id);
-        if (t) summaries.push({ id: t.id, cwd: t.cwd, updatedAt: t.updatedAt });
-      }
-      const threadId = pickFreshThread(summaries, { cwd: (deps.cwd ?? (() => process.cwd()))() });
-      if (!threadId) return null; // no loaded thread yet — next wake retries (no permanent fail)
-      await maybePersistWakeTarget(active, { socketPath: envSocket, threadId }, deps);
-      return { socketPath: envSocket, threadId };
-    } finally {
-      probe.close();
-    }
+  if (!envSocket) {
+    debugLog('codex wake target unavailable: BORG_CODEX_APP_SERVER_SOCKET is absent');
+    return null;
   }
-
-  // Fallback: the launch-recorded file (un-upgraded launch / env absent) — no
-  // connect needed to resolve, so the caller dedups before opening any socket.
-  const target = await (deps.getCodexWakeTarget ?? getCodexWakeTarget)(active.cubeId, active.droneId);
-  if (!target) return null;
-  return { socketPath: target.socketPath, threadId: target.threadId };
-}
-
-/** Self-healing cache write — only when the resolved target actually changed. */
-async function maybePersistWakeTarget(
-  active: { cubeId: string; droneId: string },
-  fresh: { socketPath: string; threadId: string },
-  deps: CodexWakeDeps
-): Promise<void> {
+  const probe = makeCodexClient(envSocket, deps);
+  await probe.connect();
   try {
-    const get = deps.getCodexWakeTarget ?? getCodexWakeTarget;
-    const set = deps.setCodexWakeTarget ?? setCodexWakeTarget;
-    const existing = await get(active.cubeId, active.droneId);
-    const prev = existing ? { socketPath: existing.socketPath, threadId: existing.threadId } : null;
-    if (wakeTargetChanged(prev, fresh)) {
-      await set(active.cubeId, active.droneId, fresh);
+    const ids = await probe.loadedThreadIds();
+    const summaries: CodexThreadInfo[] = [];
+    for (const id of ids) {
+      try {
+        const thread = await probe.readThread(id);
+        if (thread) summaries.push(thread);
+      } catch {
+        // A loaded thread may disappear before its read; keep other candidates.
+      }
     }
-  } catch {
-    // best-effort cache write; never break the wake path
+    const threadId = pickFreshThread(summaries, { cwd: (deps.cwd ?? (() => process.cwd()))() });
+    return threadId ? { socketPath: envSocket, threadId } : null;
+  } finally {
+    probe.close();
   }
 }
 
@@ -396,7 +367,12 @@ export function wakeCodexViaAppServer(
 ): void {
   const target = resolveCodexWakeTarget(env);
   if (!target.enabled) return;
-  pendingWakeRequests.push({ reason, deliveryIdentity, sourceEntryId, deps });
+  pendingWakeRequests.push({
+    reason,
+    deliveryIdentity,
+    sourceEntryId,
+    deps: deps.env ? deps : { ...deps, env },
+  });
   if (wakeInFlight) return;
 
   wakeInFlight = true;
@@ -432,17 +408,14 @@ async function wakeCodexTargeted(
     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.
+    // Resolve fresh from this child’s live env socket and loaded threads.
     const resolved = await resolveFreshCodexWakeTarget(active, deps);
     if (!resolved) {
-      // client#89: a scoped entry passed the pending check above but no target
-      // resolves — undeliverable, and this path does NOT schedule a retry-drain
-      // (the design leaves it to the next wake / the heartbeat backstop). Mark
-      // the deferral live so health reads degraded rather than armed. An
-      // unscoped wake carries no authoritative pending signal, so it does not
-      // set the marker. Retry behavior is unchanged.
+      // A scoped entry passed the pending check but its TUI thread is not loaded
+      // yet. Keep it in the coalesced retry-drain instead of waiting for another
+      // inbound event or the heartbeat.
       if (sourceEntryId) deliveryDeferred = true;
+      scheduleRetryDrain(deps, sourceEntryId);
       return;
     }
     const { socketPath, threadId } = resolved;