borgmcp 5.1.2 → 5.3.0

package/src/codex-launch.ts

@@ -2,6 +2,13 @@ import type { BorgCli } from './cubes.js';
 import type { AgentKind } from './agent-runtime.js';
 import { wakePathArming } from './regen-format.js';
 import { OPENCODE_WAKE_PATH_GUIDANCE } from './opencode-wake-copy.js';
+import { withCodexCwdArg, type CodexRemoteReadyLaunch } from './codex-remote.js';
+import { codexBorgSessionConfigArgs } from './launch-gate.js';
+import {
+  codexAgentKindConfigArgs,
+  codexRemoteWakeConfigArgs,
+  codexStateRootConfigArgs,
+} from './agent-runtime.js';
 
 /**
  * The claude kickoff prompt's wake-path section (gh#929) — the SAME shared
@@ -29,25 +36,9 @@ export function buildKickoffWakePathClause(
   return '';
 }
 
-export interface CodexWakeTargetDeps {
-  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>;
-}
-
 export function buildAgentKickoffPrompt(options: {
   cli: BorgCli;
-  codexWakeNonce: string | null;
   monitorClause: string;
-  codexWakePathClause?: string;
 }): string {
   // gh#929: compacted to the load-bearing launch essentials (lean/explicit/
   // imperative, #914 treatment). STRIPPED: the read-log-triage paragraph (the
@@ -55,13 +46,9 @@ export function buildAgentKickoffPrompt(options: {
   // clause (Coordinator/Queen-only; belongs in role-text, not injected for
   // ALL). KEPT: core call + MCP-disconnect recovery + the wake-path arming
   // (claude via the shared monitorClause = buildKickoffWakePathClause; codex
-  // via codexWakePathClause) + the claude/codex/opencode cli-branching.
-  const codexNonceClause = options.codexWakeNonce
-    ? `Wake target nonce: ${options.codexWakeNonce}. `
-    : '';
+  // via the Borg-owned remote socket clause) + the cli-specific branching.
   const codexWakePathClause =
-    options.codexWakePathClause ??
-    `Codex Borg wakeups use remote-control when available; if no wake arrives, run borg_regen manually when returning to the session.`;
+    'Codex Borg wakeups use the Borg-owned remote-control socket for this session.';
   const opencodeWakePathClause = OPENCODE_WAKE_PATH_GUIDANCE;
   const wakeClause = options.cli === 'claude'
     ? options.monitorClause
@@ -70,7 +57,6 @@ export function buildAgentKickoffPrompt(options: {
       : opencodeWakePathClause;
   return (
     `Call borg_regen and follow the playbook in its response. ` +
-    codexNonceClause +
     `Note: at session start the borg MCP server is still spinning up in ` +
     `parallel — if a system reminder claims "MCP server disconnected" or ` +
     `the borg tools are not yet registered, do NOT bail. Make one recovery attempt via ` +
@@ -82,61 +68,42 @@ export function buildAgentKickoffPrompt(options: {
   );
 }
 
-export function socketPathFromRemoteArgs(args: string[]): string | null {
-  const index = args.indexOf('--remote');
-  if (index < 0) return null;
-  const value = args[index + 1];
-  if (!value?.startsWith('unix://')) return null;
-  return value.slice('unix://'.length);
-}
+export type CodexLaunchArgsResult =
+  | { ready: true; args: string[] }
+  | { ready: false; reason: string };
 
-export function threadIdFromPassthroughArgs(args: string[]): string | null {
-  if (args[0] === 'resume' && args[1] && !args[1].startsWith('-')) return args[1];
-  const resumeIndex = args.indexOf('--resume');
-  if (resumeIndex >= 0 && args[resumeIndex + 1]) return args[resumeIndex + 1];
-  return null;
-}
-
-export async function recordCodexWakeTarget(options: {
-  deps: CodexWakeTargetDeps;
-  cubeId: string;
-  droneId: string;
-  socketPath: string;
+export function buildCodexLaunchArgs(options: {
+  remote: CodexRemoteReadyLaunch;
   cwd: string;
-  previewNeedle: string;
-  launchedAtSeconds: number;
+  kickoff: string;
+  approvalArgs?: string[];
+  accessArgs?: string[];
+  seatExpectationArgs?: string[];
   passthroughArgs?: string[];
-}): Promise<void> {
-  try {
-    const explicitThreadId = options.passthroughArgs
-      ? threadIdFromPassthroughArgs(options.passthroughArgs)
-      : null;
-    if (explicitThreadId) {
-      await options.deps.setCodexWakeTarget(options.cubeId, options.droneId, {
-        threadId: explicitThreadId,
-        socketPath: options.socketPath,
-      });
-      return;
-    }
-
-    const deadline = Date.now() + 15_000;
-    while (Date.now() < deadline) {
-      const threadId = await options.deps.findLoadedCodexThread({
-        socketPath: options.socketPath,
-        cwd: options.cwd,
-        previewIncludes: options.previewNeedle,
-        updatedAfter: options.launchedAtSeconds - 5,
-      });
-      if (threadId) {
-        await options.deps.setCodexWakeTarget(options.cubeId, options.droneId, {
-          threadId,
-          socketPath: options.socketPath,
-        });
-        return;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-  } catch {
-    // Best-effort mapping: launch still succeeds and manual regen remains available.
+}): CodexLaunchArgsResult {
+  const passthroughArgs = options.passthroughArgs ?? [];
+  if (passthroughArgs.some((arg) => arg === '--remote' || arg.startsWith('--remote='))) {
+    return {
+      ready: false,
+      reason: 'Borg owns Codex remote control; remove the passthrough --remote option and retry.',
+    };
+  }
+  const remoteValue = `unix://${options.remote.server.socketPath}`;
+  if (options.remote.args.length !== 2 || options.remote.args[0] !== '--remote' || options.remote.args[1] !== remoteValue) {
+    return { ready: false, reason: 'The Borg-owned Codex remote socket is unavailable.' };
   }
+  return {
+    ready: true,
+    args: [
+      ...(options.accessArgs ?? []),
+      ...(options.approvalArgs ?? []),
+      ...codexBorgSessionConfigArgs(),
+      ...codexAgentKindConfigArgs(),
+      ...codexRemoteWakeConfigArgs(),
+      ...codexStateRootConfigArgs(),
+      ...(options.seatExpectationArgs ?? []),
+      ...options.remote.args,
+      ...withCodexCwdArg([...passthroughArgs, options.kickoff], options.cwd),
+    ],
+  };
 }

package/src/codex-remote.ts

@@ -35,14 +35,22 @@ export interface CodexAppServerHandle {
   cleanup: () => void;
 }
 
-export interface CodexRemoteLaunch {
+export interface CodexRemoteReadyLaunch {
+  ready: true;
   args: string[];
   env: Record<string, string>;
-  warning?: string;
-  /** Present when borg owns a per-launch app-server that must be cleaned up on TUI exit. */
-  server?: CodexAppServerHandle;
+  /** Borg owns this per-launch app-server and must clean it up on TUI exit. */
+  server: CodexAppServerHandle;
 }
 
+export interface CodexRemoteLaunchRefusal {
+  ready: false;
+  reason: string;
+  stderr: string;
+}
+
+export type CodexRemoteLaunch = CodexRemoteReadyLaunch | CodexRemoteLaunchRefusal;
+
 export interface CodexChild {
   pid: number | undefined;
   kill: () => void;
@@ -69,15 +77,17 @@ export interface PrepareCodexRemoteDeps {
   runtimeDir?: string;
   /** Unique socket id generator (default 32-hex). Injected for deterministic tests. */
   socketId?: () => string;
-  /** Readiness timeout (default 30000ms) + poll interval (default 250ms). */
+  /** Readiness timeout (default 60000ms) + poll interval (default 250ms). */
   readyTimeoutMs?: number;
   pollIntervalMs?: number;
+  /** Wall clock used to enforce the readiness budget. */
+  now?: () => number;
   /** Whether a pid is alive (default process.kill(pid, 0)). Injected for tests. */
   isAlive?: (pid: number) => boolean;
 }
 
 export const DEFAULT_CODEX_REMOTE_DIR = join(borgConfigRoot(), 'codex-remote');
-const DEFAULT_CODEX_REMOTE_READY_TIMEOUT_MS = 30_000;
+const DEFAULT_CODEX_REMOTE_READY_TIMEOUT_MS = 60_000;
 const MAX_CODEX_APP_SERVER_STDERR_CHARS = 16_384;
 
 /**
@@ -266,8 +276,8 @@ function pruneStaleSockets(runtimeDir: string, isAlive: (pid: number) => boolean
   }
 }
 
-function failLoud(reason: string): CodexRemoteLaunch {
-  return { args: [], env: {}, warning: reason };
+function refuse(reason: string, stderr = ''): CodexRemoteLaunchRefusal {
+  return { ready: false, reason, stderr: sanitizeCodexDiagnostic(stderr).trim() };
 }
 
 function formatExitReason(diagnostics: CodexChildDiagnostics): string {
@@ -277,16 +287,10 @@ function formatExitReason(diagnostics: CodexChildDiagnostics): string {
   return 'unknown exit status';
 }
 
-function formatStderr(stderr: string): string {
-  const trimmed = sanitizeCodexDiagnostic(stderr).trim();
-  return trimmed ? ` Stderr: ${trimmed}` : '';
-}
-
 /**
  * Start a borg-owned per-launch Codex app-server, probe it for readiness, and
- * return the `--remote` launch args + an owned handle (or a fail-loud warning).
- * Async + lifecycle-owning: the caller MUST call `result.server?.cleanup()` on
- * TUI exit.
+ * return the `--remote` launch args + an owned handle, or a typed refusal after
+ * one retry. The caller MUST call `result.server.cleanup()` on TUI exit.
  */
 export async function prepareCodexRemoteLaunch(
   deps: PrepareCodexRemoteDeps
@@ -295,6 +299,7 @@ export async function prepareCodexRemoteLaunch(
   const isAlive = deps.isAlive ?? defaultIsAlive;
   const readyTimeoutMs = deps.readyTimeoutMs ?? DEFAULT_CODEX_REMOTE_READY_TIMEOUT_MS;
   const pollIntervalMs = deps.pollIntervalMs ?? 250;
+  const now = deps.now ?? Date.now;
 
   // 1. 0700 owned dir + prune crashed prior sockets (concurrent-safe via pid liveness).
   try {
@@ -302,89 +307,92 @@ export async function prepareCodexRemoteLaunch(
     chmodSync(runtimeDir, 0o700); // enforce 0700 even if it pre-existed with looser perms
     pruneStaleSockets(runtimeDir, isAlive);
   } catch (err: any) {
-    return failLoud(
-      `Codex remote-wake disabled: could not prepare ${runtimeDir} (${err?.message ?? err}); run borg_regen manually.`
-    );
+    return refuse(`could not prepare the Codex app-server runtime directory (${sanitizeCodexDiagnostic(String(err?.message ?? err))})`);
   }
 
-  // 2. unique, non-predictable socket path inside the owned dir.
-  const id = (deps.socketId ?? (() => randomBytes(16).toString('hex')))();
-  const socketPath = join(runtimeDir, `${id}.sock`);
-  const pidPath = join(runtimeDir, `${id}.pid`);
-
-  // 3. spawn the long-lived app-server.
-  let child: CodexChild;
-  try {
-    child = deps.spawnAppServer(socketPath);
-  } catch (err: any) {
-    safeRm(socketPath);
-    return failLoud(
-      `Codex remote-wake disabled: could not start \`codex app-server\` (${sanitizeCodexDiagnostic(String(err?.message ?? err))}) — ` +
-        `confirm the Codex executable is installed and available on PATH. ` +
-        `Remote wake is unavailable for this session; run borg_regen manually to catch up.`
-    );
-  }
-  if (child.pid != null) {
+  let lastRefusal = refuse('the Codex app-server did not become ready');
+  for (let launchAttempt = 0; launchAttempt < 2; launchAttempt += 1) {
+    // Each retry owns a fresh, non-predictable socket and pidfile.
+    const id = (deps.socketId ?? (() => randomBytes(16).toString('hex')))();
+    const socketPath = join(runtimeDir, `${id}.sock`);
+    const pidPath = join(runtimeDir, `${id}.pid`);
+    let child: CodexChild;
     try {
-      writeFileSync(pidPath, String(child.pid));
-    } catch {
-      // pidfile is only for stale-prune; launch still proceeds.
+      child = deps.spawnAppServer(socketPath);
+    } catch (err: any) {
+      safeRm(socketPath);
+      safeRm(pidPath);
+      lastRefusal = refuse(
+        `could not start \`codex app-server\` (${sanitizeCodexDiagnostic(String(err?.message ?? err))}); confirm the Codex executable is installed and available on PATH`
+      );
+      continue;
     }
-  }
-
-  const cleanup = () => {
-    try {
-      child.kill();
-    } catch {
-      // best-effort
+    if (child.pid != null) {
+      try {
+        writeFileSync(pidPath, String(child.pid));
+      } catch {
+        // pidfile is only for stale-prune; launch still proceeds.
+      }
     }
-    safeRm(socketPath);
-    safeRm(pidPath);
-  };
 
-  // 4. readiness via a real protocol round-trip — bounded attempts (no clock dep).
-  const attempts = Math.max(1, Math.ceil(readyTimeoutMs / pollIntervalMs));
-  let ready = false;
-  let exitDiagnostics: CodexChildDiagnostics | undefined;
-  for (let i = 0; i < attempts && !ready; i++) {
-    try {
-      ready = await deps.probeReady(socketPath);
-    } catch {
-      ready = false;
-    }
-    if (!ready) {
+    const cleanup = () => {
+      try {
+        child.kill();
+      } catch {
+        // best-effort
+      }
+      safeRm(socketPath);
+      safeRm(pidPath);
+    };
+
+    // Readiness is bounded by elapsed wall time, so slow protocol probes count
+    // against the same cold-start budget as the poll sleeps.
+    const startedAt = now();
+    let ready = false;
+    let exitDiagnostics: CodexChildDiagnostics | undefined;
+    for (;;) {
+      try {
+        ready = await deps.probeReady(socketPath);
+      } catch {
+        ready = false;
+      }
+      if (ready) break;
       const diagnostics = child.diagnostics?.();
       if (diagnostics?.exited) {
         exitDiagnostics = diagnostics;
         break;
       }
+      const remainingMs = readyTimeoutMs - (now() - startedAt);
+      if (remainingMs <= 0) break;
+      await deps.sleep(Math.min(pollIntervalMs, remainingMs));
     }
-    if (!ready && i < attempts - 1) await deps.sleep(pollIntervalMs);
-  }
 
-  if (!ready) {
     const diagnostics = exitDiagnostics ?? child.diagnostics?.();
-    cleanup();
-    if (diagnostics?.exited) {
-      return failLoud(
-        `Codex remote-wake disabled: \`codex app-server\` exited before becoming ready ` +
-          `(${formatExitReason(diagnostics)}).${formatStderr(diagnostics.stderr)} ` +
-          `Run borg_regen manually to catch up.`
-      );
+    if (!ready) {
+      cleanup();
+      if (diagnostics?.exited) {
+        lastRefusal = refuse(
+          `\`codex app-server\` exited before becoming ready (${formatExitReason(diagnostics)})`,
+          diagnostics.stderr,
+        );
+      } else {
+        lastRefusal = refuse(
+          `\`codex app-server\` remained running but did not become ready within ${readyTimeoutMs}ms`,
+          diagnostics?.stderr ?? '',
+        );
+      }
+      continue;
     }
-    return failLoud(
-      `Codex remote-wake disabled: \`codex app-server\` remained running but did not become ready ` +
-        `at ${sanitizeCodexDiagnostic(socketPath)} within ${readyTimeoutMs}ms.${formatStderr(diagnostics?.stderr ?? '')} ` +
-        `Run borg_regen manually to catch up.`
-    );
+
+    return {
+      ready: true,
+      args: ['--remote', `unix://${socketPath}`],
+      env: { [BORG_CODEX_REMOTE_WAKE_ENV]: '1' },
+      server: { pid: child.pid, socketPath, cleanup },
+    };
   }
 
-  // 5. ready → owned remote launch.
-  return {
-    args: ['--remote', `unix://${socketPath}`],
-    env: { [BORG_CODEX_REMOTE_WAKE_ENV]: '1' },
-    server: { pid: child.pid, socketPath, cleanup },
-  };
+  return lastRefusal;
 }
 
 /**

package/src/codex-wake-resolve.ts

@@ -1,10 +1,9 @@
 /**
  * gh#855 — pure helpers for FRESH codex wake-target re-resolution.
  *
- * Root cause of codex deaf-when-idle: the wake target (socket + thread) was
- * resolved once at launch and never refreshed, so a missed/stale launch probe
- * left the drone permanently deaf. Phase 1 makes the waking borg-mcp child
- * authoritative about its OWN live app-server socket — the socket is injected
+ * Root cause of codex deaf-when-idle: stale thread selection could leave the
+ * drone permanently deaf. The waking borg-mcp child is authoritative about its
+ * OWN live app-server socket — the socket is injected
  * into the child's pinned env at spawn (codex-remote.ts, via the #851 `-c
  * mcp_servers.borg.env.X` channel) — and re-resolves the loaded thread FRESH on
  * every wake (loadedThreadIds is a re-runnable RPC).
@@ -15,7 +14,7 @@
 /** Pinned-env var carrying THIS drone's live app-server socket (set at spawn). */
 export const BORG_CODEX_APP_SERVER_SOCKET_ENV = 'BORG_CODEX_APP_SERVER_SOCKET';
 
-/** The live app-server socket for this borg-mcp child, or null (un-upgraded launch). */
+/** The live app-server socket for this borg-mcp child. */
 export function codexAppServerSocketFromEnv(env: NodeJS.ProcessEnv = process.env): string | null {
   const v = env[BORG_CODEX_APP_SERVER_SOCKET_ENV];
   return v && v.length > 0 ? v : null;
@@ -37,6 +36,16 @@ export interface CodexThreadInfo {
   id: string;
   cwd?: string;
   updatedAt?: number;
+  source?: unknown;
+  ephemeral?: boolean;
+  threadSource?: string;
+  preview?: string;
+  turns?: unknown[];
+}
+
+export function isCodexSubagentSource(source: unknown): boolean {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return false;
+  return 'subagent' in source || 'subAgent' in source;
 }
 
 /**
@@ -44,15 +53,22 @@ export interface CodexThreadInfo {
  * is fresh-per-launch / single-session, so the common case is exactly one loaded
  * thread. When more than one is loaded, prefer the thread whose cwd matches this
  * drone's working directory (sibling worktrees have distinct cwds), then the
- * newest by updatedAt — always deterministic. No loaded thread → null (no wake
+ * newest by updatedAt, without preferring an empty thread over one with turns.
+ * System, ephemeral and subagent threads are never candidates. No loaded thread → null (no wake
  * this cycle; the next wake retries, so a transient empty list never causes
  * permanent deafness).
  */
 export function pickFreshThread(threads: CodexThreadInfo[], opts: { cwd: string }): string | null {
-  if (threads.length === 0) return null;
-  if (threads.length === 1) return threads[0].id;
-  const cwdMatches = threads.filter((t) => t.cwd === opts.cwd);
-  const pool = cwdMatches.length > 0 ? cwdMatches : threads;
+  const rootThreads = threads.filter((thread) =>
+    !isCodexSubagentSource(thread.source) && thread.ephemeral !== true &&
+    (thread.threadSource === undefined || thread.threadSource === 'user'));
+  if (rootThreads.length === 0) return null;
+  if (rootThreads.length === 1) return rootThreads[0].id;
+  const cwdMatches = rootThreads.filter((t) => t.cwd === opts.cwd);
+  let pool = cwdMatches.length > 0 ? cwdMatches : rootThreads;
+  if (pool.some((thread) => (thread.turns?.length ?? 0) > 0)) {
+    pool = pool.filter((thread) => (thread.turns?.length ?? 0) > 0 || !!thread.preview);
+  }
   let best = pool[0];
   for (const t of pool) {
     if ((t.updatedAt ?? 0) > (best.updatedAt ?? 0)) best = t;
@@ -60,43 +76,6 @@ export function pickFreshThread(threads: CodexThreadInfo[], opts: { cwd: string
   return best.id;
 }
 
-/**
- * Pure prune: drop wake-target entries whose app-server socket is positively
- * dead (liveness === false), so the file self-heals. Keeps alive (true) and
- * indeterminate (null) entries — false-deaf-avoidance, mirroring
- * checkCodexBridgeHealthy's tri-state. Returns the surviving map + whether
- * anything changed (so the caller writes only on change).
- */
-export function pruneDeadWakeTargets<T extends { socketPath: string }>(
-  targets: Record<string, T>,
-  socketLiveness: (socketPath: string) => boolean | null
-): { targets: Record<string, T>; changed: boolean } {
-  const out: Record<string, T> = {};
-  let changed = false;
-  for (const [key, t] of Object.entries(targets)) {
-    if (socketLiveness(t.socketPath) === false) {
-      changed = true;
-      continue;
-    }
-    out[key] = t;
-  }
-  return { targets: out, changed };
-}
-
-/**
- * Whether the freshly-resolved target differs from what's already recorded —
- * so the self-healing cache write happens only on change (no file thrash on a
- * busy cube re-resolving the same socket+thread every wake).
- */
-export function wakeTargetChanged(
-  existing: { socketPath: string; threadId: string } | null,
-  fresh: { socketPath: string; threadId: string }
-): boolean {
-  return (
-    !existing || existing.socketPath !== fresh.socketPath || existing.threadId !== fresh.threadId
-  );
-}
-
 // ─── gh#857 Phase 2: durable retry + heartbeat (pure helpers) ───────────────
 
 /** Base backoff for the first retry of a dropped/deferred wake. */

package/src/config-utils.ts

@@ -1293,8 +1293,8 @@ export function addCodexMcpServer(): void {
     // Codex MCP config when the operator has explicitly set it.
     const apiUrl = process.env.BORG_API_URL;
     // Identity is durable configuration; remote wake is a per-launch
-    // transport capability. Do not persist a transport marker here: a future
-    // Codex child may launch without a live --remote socket.
+    // transport capability pinned by the Borg-owned app-server. Do not persist
+    // that transport marker in the user's static Codex configuration.
     const apiUrlEnvArg = apiUrl ? ` --env BORG_API_URL=${shellQuote(apiUrl)}` : '';
     const stateRoot = process.env[BORG_STATE_ROOT_ENV];
     const stateRootEnvArg = stateRoot

package/src/cubes.ts

@@ -18,7 +18,6 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
-import { pruneDeadWakeTargets } from './codex-wake-resolve.js';
 import { borgConfigRoot } from './private-root.js';
 import {
   getActiveSeatCredential,
@@ -38,15 +37,14 @@ import {
 // The unified 0600 seat store (seats.ts / seats.json) is now the SOLE home of the
 // per-worktree ACTIVE-CUBE seat map: each seat = credential + worktree binding +
 // display as ONE atomic record. cubes.json no longer holds a seat map — the
-// functions below are thin adapters over seats.ts. Only launch.json,
-// codex-wake-targets.json, and the inbox tree remain owned by this module.
+// functions below are thin adapters over seats.ts. Only launch.json and the
+// inbox tree remain owned by this module.
 
 /** Re-exported from seats.ts for call-site parity (the retired cross-store name). */
 export type { SeatExpectation as ExpectedBinding } from './seats.js';
 
 const CUBES_DIR = borgConfigRoot();
 const LAUNCH_FILE = join(CUBES_DIR, 'launch.json');
-const CODEX_WAKE_TARGETS_FILE = join(CUBES_DIR, 'codex-wake-targets.json');
 const INBOX_DIR = join(CUBES_DIR, 'inboxes');
 
 export type BorgCli = 'claude' | 'codex' | 'opencode';
@@ -206,16 +204,6 @@ function unreadableStateError(filePath: string): Error {
   return new Error(`Borg state file is unreadable; refusing to overwrite it: ${filePath}`);
 }
 
-export interface CodexWakeTargetRecord {
-  threadId: string;
-  socketPath: string;
-  updatedAt: string;
-}
-
-interface CodexWakeTargetsFile {
-  targets: Record<string, CodexWakeTargetRecord>;
-}
-
 /**
  * Walk up from cwd looking for a .git directory. If found, return that
  * directory. If not found by filesystem root, return the original cwd.
@@ -369,44 +357,6 @@ async function writeLaunchFile(data: LaunchFile): Promise<void> {
   await atomicWriteFile(LAUNCH_FILE, JSON.stringify(data, null, 2) + '\n');
 }
 
-function codexWakeTargetKey(cubeId: string, droneId: string): string {
-  if (!UUID_RE.test(cubeId)) throw new Error(`Invalid cubeId: ${cubeId}`);
-  if (!UUID_RE.test(droneId)) throw new Error(`Invalid droneId: ${droneId}`);
-  return `${cubeId}:${droneId}`;
-}
-
-function isCodexWakeTargetsFile(data: any): data is CodexWakeTargetsFile {
-  return (
-    data !== null &&
-    typeof data === 'object' &&
-    typeof data.targets === 'object' &&
-    data.targets !== null &&
-    !Array.isArray(data.targets)
-  );
-}
-
-async function readCodexWakeTargetsFile(): Promise<StateFileRead<CodexWakeTargetsFile>> {
-  let raw: string;
-  try {
-    raw = await readFile(CODEX_WAKE_TARGETS_FILE, 'utf8');
-  } catch (error: any) {
-    if (error?.code === 'ENOENT') return null;
-    throw error;
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return isCodexWakeTargetsFile(parsed) ? parsed : UNREADABLE_STATE;
-  } catch {
-    return UNREADABLE_STATE;
-  }
-}
-
-async function writeCodexWakeTargetsFile(data: CodexWakeTargetsFile): Promise<void> {
-  // atomicWriteFile handles the mkdir + 0o600 mode, and the temp+rename keeps
-  // a concurrent reader from seeing a half-written file (gh#894, gh#901).
-  await atomicWriteFile(CODEX_WAKE_TARGETS_FILE, JSON.stringify(data, null, 2) + '\n');
-}
-
 /**
  * Get the currently-active cube for the current project, or null if not
  * assimilated in this project. Entries written by older client versions
@@ -749,51 +699,3 @@ export async function setProjectCliPreference(cli: BorgCli, dir?: string): Promi
   next.projects[findProjectRoot(dir)] = { cli };
   await writeLaunchFile(next);
 }
-
-export async function setCodexWakeTarget(
-  cubeId: string,
-  droneId: string,
-  target: Omit<CodexWakeTargetRecord, 'updatedAt'>
-): Promise<void> {
-  const existing = await readCodexWakeTargetsFile();
-  if (existing === UNREADABLE_STATE) throw unreadableStateError(CODEX_WAKE_TARGETS_FILE);
-  const next = existing ?? { targets: {} };
-  next.targets[codexWakeTargetKey(cubeId, droneId)] = {
-    ...target,
-    updatedAt: new Date().toISOString(),
-  };
-  await writeCodexWakeTargetsFile(next);
-}
-
-export async function getCodexWakeTarget(
-  cubeId: string,
-  droneId: string
-): Promise<CodexWakeTargetRecord | null> {
-  const existing = await readCodexWakeTargetsFile();
-  if (existing === UNREADABLE_STATE) throw unreadableStateError(CODEX_WAKE_TARGETS_FILE);
-  if (!existing) return null;
-  const target = existing.targets[codexWakeTargetKey(cubeId, droneId)];
-  if (!target || typeof target.threadId !== 'string' || typeof target.socketPath !== 'string') {
-    return null;
-  }
-  return target;
-}
-
-/**
- * gh#855: drop wake-target entries whose app-server socket is positively dead,
- * so the file self-heals (stale dead-socket entries from crashed prior launches
- * don't linger and mislead probeCodexBridgeArmed / health-beat). Pure prune
- * decision lives in codex-wake-resolve.ts (false-deaf-avoidance: keeps alive +
- * indeterminate); this is the thin read → prune → write-only-on-change glue.
- * The liveness check is injected (claude.ts wires checkCodexBridgeHealthy) so
- * cubes.ts stays free of the codex-remote dependency.
- */
-export async function pruneDeadCodexWakeTargets(
-  socketLiveness: (socketPath: string) => boolean | null
-): Promise<void> {
-  const existing = await readCodexWakeTargetsFile();
-  if (existing === UNREADABLE_STATE) throw unreadableStateError(CODEX_WAKE_TARGETS_FILE);
-  if (!existing) return;
-  const { targets, changed } = pruneDeadWakeTargets(existing.targets, socketLiveness);
-  if (changed) await writeCodexWakeTargetsFile({ ...existing, targets });
-}