borgmcp 5.2.0 → 5.3.0

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 });
-}

package/src/log-stream.ts

@@ -906,10 +906,13 @@ 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(
+        const openCodeDelivered = await injectOpenCode(
           formatOpenCodeWakePrompt(line), deliveryId, true, ev.id,
           () => hasPendingWakeEntry(active, ev.id),
         );
+        if (!openCodeDelivered) {
+          wakeCodex(formatCodexWakePrompt(line), ev.wake_nonce, ev.id);
+        }
       }
       markEventPersisted(ev.id, ev.data?.created_at ?? '');
       return 'persisted-skip';