@agfpd/iapeer 0.4.32 → 0.4.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.32",
+  "version": "0.4.33",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/launch/adapters/codex.ts

@@ -37,8 +37,8 @@
 
 import { homedir } from 'os'
 import { join } from 'path'
-import { readFileSync, readdirSync, realpathSync, statSync } from 'fs'
-import { lastTimestampedEntryMs } from './transcriptTail.ts'
+import { readdirSync, realpathSync, statSync } from 'fs'
+import { codexSessionCwd, lastTimestampedEntryMs } from './transcriptTail.ts'
 import type { ControlCommand, ControlPlan, LaunchAdapterConfig, LaunchSpec, RuntimeAdapter } from '../types.ts'
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -75,26 +75,8 @@ function codexHooksReviewActive(pane: string): boolean {
 // Session activity proxy + resume preflight (watcher / spawner port)
 // ─────────────────────────────────────────────────────────────────────────────
 
-/**
- * The cwd a codex session was opened in, read from the first jsonl line's
- * `session_meta.payload.cwd` (watcher.codexSessionCwd, 200-212). null when the
- * file is missing, unreadable, not a session_meta record, or carries no cwd.
- */
-function codexSessionCwd(file: string): string | null {
-  try {
-    const firstLine = readFileSync(file, 'utf8').split(/\r?\n/, 1)[0]
-    if (!firstLine) return null
-    const entry = JSON.parse(firstLine) as {
-      type?: unknown
-      payload?: { cwd?: unknown }
-    }
-    return entry.type === 'session_meta' && typeof entry.payload?.cwd === 'string'
-      ? entry.payload.cwd
-      : null
-  } catch {
-    return null
-  }
-}
+// codexSessionCwd (bounded first-line read + path-memoized) is shared from transcriptTail.ts —
+// the old full-file readFileSync here read tens of MB per session file on every hot-path scan.
 
 /** realpath a path so a symlinked cwd compares equal to the dir codex recorded;
  *  a stale/missing path falls through to the original string (the canonicalPath

package/src/launch/adapters/transcriptTail.ts

@@ -30,6 +30,73 @@ import { openSync, readSync, closeSync, statSync } from 'fs'
  * the newline-bounded segments after it. Reaching byte 0 makes every segment complete, including the
  * first — and terminates the growth.
  */
+/**
+ * The FIRST newline-terminated line of a file, read with an ADAPTIVE growing window — NEVER the whole
+ * file. A codex `session_meta` first line carries the full instruction payload (measured 29–73 KB on the
+ * live host), so a fixed small chunk would miss the terminating `\n` and return a truncated line; the
+ * window doubles (capped at file size) until a `\n` is seen or the whole file is read. Returns null when
+ * the file is unreadable/empty. Cheap for the common case (one read covers it), bounded otherwise.
+ */
+export function readFirstLine(path: string, chunkBytes = 65536): string | null {
+  let fd: number
+  try {
+    fd = openSync(path, 'r')
+  } catch {
+    return null
+  }
+  try {
+    const size = statSync(path).size
+    if (size <= 0) return null
+    let window = Math.max(chunkBytes, 1)
+    for (;;) {
+      const len = Math.min(window, size)
+      const buf = Buffer.allocUnsafe(len)
+      let read = 0
+      while (read < len) {
+        const n = readSync(fd, buf, read, len - read, read)
+        if (n <= 0) break
+        read += n
+      }
+      const text = buf.subarray(0, read).toString('utf8')
+      const nl = text.indexOf('\n')
+      if (nl >= 0) return text.slice(0, nl).replace(/\r$/, '')
+      if (len >= size) return text.replace(/\r$/, '') // whole file, no trailing newline → the single line
+      window *= 2
+    }
+  } catch {
+    return null
+  } finally {
+    closeSync(fd)
+  }
+}
+
+/** Memoized path→cwd. session_meta is written ONCE at session start (immutable) and session-file paths
+ *  are unique, so caching a DEFINITIVE parse is sound. Only the unreadable/empty case (readFirstLine
+ *  null) is NOT cached — that can become readable. */
+const codexCwdCache = new Map<string, string | null>()
+
+/**
+ * The cwd a codex session was opened in — the `session_meta.payload.cwd` of the FIRST jsonl line — read
+ * via the bounded readFirstLine and memoized by path. Replaces the old full-file readFileSync that ran
+ * per-file on every hot-path scan (superviseTick, ready-gate, delivery baseline). Returns null when the
+ * file is missing/unreadable or carries no session_meta cwd.
+ */
+export function codexSessionCwd(file: string): string | null {
+  const cached = codexCwdCache.get(file)
+  if (cached !== undefined) return cached
+  const firstLine = readFirstLine(file)
+  if (firstLine === null) return null // unreadable/empty — do NOT cache (may become readable)
+  let cwd: string | null = null
+  try {
+    const entry = JSON.parse(firstLine) as { type?: unknown; payload?: { cwd?: unknown } }
+    if (entry.type === 'session_meta' && typeof entry.payload?.cwd === 'string') cwd = entry.payload.cwd
+  } catch {
+    cwd = null
+  }
+  codexCwdCache.set(file, cwd)
+  return cwd
+}
+
 export function lastTimestampedEntryMs(path: string, tailBytes = 65536): number | null {
   let fd: number
   try {

package/src/launch/ptyHost.ts

@@ -121,7 +121,7 @@ export async function startPtyHost(b: {
 }): Promise<HostStartResult> {
   try {
     const { startSupervisorDaemon } = await import('../supervisor/index.ts')
-    const r = startSupervisorDaemon({
+    const r = await startSupervisorDaemon({
       session: b.identity,
       runtime: b.runtime,
       runDir: hostRunDir(),

package/src/lifecycle/index.ts

@@ -1445,7 +1445,14 @@ export async function drainEphemeralQueue(
   )
   const wake = deps.wakeFn ?? wakeOrSpawn
   const result = await wake({ personality, runtime, topic: item.topic, task: item.task }, { cfg, env })
-  if (result.status === 'READY') removeEphemeralTask(cfg, identity, item.seq)
+  // Remove ONLY when THIS wake actually delivered the task. On the live-session fast
+  // path (READY, taskDelivered:false) a CONCURRENT wake delivered ITS OWN task — ours
+  // was NOT delivered. Deleting it here would silently drop a queued task (the loss the
+  // contract forbids); leaving it at the head lets the next drain (after that session
+  // reaps) deliver it into a fresh session — invariant "one task = one fresh session".
+  if (result.status === 'READY' && result.taskDelivered !== false) {
+    removeEphemeralTask(cfg, identity, item.seq)
+  }
   return result
 }
 

package/src/lifecycle/queue.ts

@@ -43,6 +43,30 @@ export function ephemeralQueueDir(cfg: LifecycleConfig, identity: string): strin
 }
 
 const SEQ_PAD = 6
+const HWM_FILE = '.hwm'
+
+/** High-water mark of seqs ever ISSUED for this queue — the monotonic floor that
+ *  makes names never repeat, even after the queue drains empty (`max(existing)+1`
+ *  alone resets to 1 once empty, so a concurrent drain still holding the OLD seq
+ *  could delete a fresh task that got the reused name). 0 when absent/unreadable. */
+function readHwm(dir: string): number {
+  try {
+    const n = parseInt(readFileSync(join(dir, HWM_FILE), 'utf8'), 10)
+    return Number.isFinite(n) && n >= 0 ? n : 0
+  } catch {
+    return 0
+  }
+}
+
+/** Raise the high-water mark (monotonic; only ever rises). Best-effort — a lost
+ *  bump merely risks a reuse after a FULL drain, the same rare window we harden. */
+function bumpHwm(dir: string, seq: number): void {
+  try {
+    if (seq > readHwm(dir)) writeFileSync(join(dir, HWM_FILE), String(seq), { mode: 0o600 })
+  } catch {
+    /* best-effort */
+  }
+}
 
 function listSeqs(dir: string): string[] {
   let entries: string[]
@@ -79,16 +103,19 @@ export function enqueueEphemeralTask(
     mode: 0o600,
   })
   try {
-    // Next seq = max existing + 1; on an EEXIST race, advance and retry.
+    // Next seq = max(existing items, ever-issued high-water) + 1 — MONOTONIC: never
+    // reuse a name after the queue empties. On an EEXIST race, advance and retry.
     let seq = (() => {
       const seqs = listSeqs(dir)
-      return seqs.length ? parseInt(seqs[seqs.length - 1]!, 10) + 1 : 1
+      const maxExisting = seqs.length ? parseInt(seqs[seqs.length - 1]!, 10) : 0
+      return Math.max(maxExisting, readHwm(dir)) + 1
     })()
     // Bounded retry: a competitor can win a name at most once per its own enqueue.
     for (let attempt = 0; attempt < 1000; attempt++, seq++) {
       const target = join(dir, String(seq).padStart(SEQ_PAD, '0'))
       try {
         linkSync(tmp, target) // atomic exclusive-create (EEXIST when taken)
+        bumpHwm(dir, seq) // record the issued name so it is never reused
         return listSeqs(dir).length
       } catch (e) {
         if ((e as NodeJS.ErrnoException).code !== 'EEXIST') throw e

package/src/supervisor/index.ts

@@ -5,7 +5,7 @@
 // serving is productionized (a later block) the daemon-spawn argv is repointed at the installed
 // binary; for now it self-spawns from source (bun + this file), which is what the tests exercise.
 import { spawn as nodeSpawn } from 'node:child_process'
-import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs'
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { runSupervisorClient, sessionAlive } from './client.ts'
 import { defaultRunDir, logPath, pidPath, servePath, sockPath } from './paths.ts'
@@ -86,8 +86,10 @@ export function resolveDaemonSelfArgv(execPath: string, selfPath: string): strin
 }
 const selfArgv = (): string[] => resolveDaemonSelfArgv(process.execPath, fileURLToPath(import.meta.url))
 
-/** Start a detached supervisor daemon and wait until its socket is live. Idempotent. */
-export function startSupervisorDaemon(opts: StartDaemonOptions): StartDaemonResult {
+/** Start a detached supervisor daemon and wait until its socket is live. Idempotent.
+ *  Async: the socket-wait yields the event loop (a sync busy-wait here froze the whole
+ *  router daemon for the bring-up window on every warm wake). */
+export async function startSupervisorDaemon(opts: StartDaemonOptions): Promise<StartDaemonResult> {
   const { session, runtime, runDir } = opts
   if (sessionAlive(runDir, session)) return { state: 'already-running' }
   mkdirSync(runDir, { recursive: true })
@@ -111,13 +113,21 @@ export function startSupervisorDaemon(opts: StartDaemonOptions): StartDaemonResu
     detached: true,
     stdio: ['ignore', out, out],
   })
+  // The child dup'd `out` at spawn — close the PARENT copy immediately. This function
+  // runs inside the always-on router daemon on EVERY warm wake; an unclosed fd here bled
+  // the daemon ~1 fd/wake toward EMFILE (live-observed) → eventual full routing outage.
+  try {
+    closeSync(out)
+  } catch {
+    /* */
+  }
   child.unref()
   const deadline = Date.now() + (opts.timeoutMs ?? 5000)
   while (Date.now() < deadline) {
     if (existsSync(sockPath(runDir, session)) && sessionAlive(runDir, session)) {
       return { state: 'started', pid: Number(readFileSync(pidPath(runDir, session), 'utf8')) }
     }
-    Bun.sleepSync(80)
+    await Bun.sleep(80) // yield the loop — never a sync block in the daemon's wake path
   }
   // Failed to come up — drop the serve-spec we wrote so it can't mislead a later read.
   if (opts.serve)
@@ -192,7 +202,7 @@ export async function runSupervisorCli(argv: string[]): Promise<number> {
       return 0 // unreachable
     }
     case 'start': {
-      const r = startSupervisorDaemon({ session: a!, runtime: b || 'claude', runDir })
+      const r = await startSupervisorDaemon({ session: a!, runtime: b || 'claude', runDir })
       console.log(`${r.state}${r.pid ? ` pid=${r.pid}` : ''}${r.detail ? ` — ${r.detail}` : ''}: ${a}`)
       return r.state === 'failed' ? 1 : 0
     }
@@ -200,7 +210,7 @@ export async function runSupervisorCli(argv: string[]): Promise<number> {
       await runSupervisorClient(runDir, a!)
       return 0
     case 'up': {
-      const r = startSupervisorDaemon({ session: a!, runtime: b || 'claude', runDir })
+      const r = await startSupervisorDaemon({ session: a!, runtime: b || 'claude', runDir })
       if (r.state === 'failed') {
         console.error(r.detail)
         return 1

package/src/transport/index.ts

@@ -13,7 +13,7 @@
 // runtime's adapter.deliveryMarkers. The poll/re-press logic is untouched; only the
 // marker SOURCE moved, so the timing behaviour is identical.
 
-import { readFileSync, readdirSync, realpathSync, statSync } from 'fs'
+import { closeSync, fstatSync, openSync, readSync, readdirSync, realpathSync, statSync } from 'fs'
 import { join } from 'path'
 import { homedir } from 'os'
 import {
@@ -40,6 +40,7 @@ import type { ResolvedCaller } from '../identity/index.ts'
 // reads them from getAdapter(target.runtime) for the tui submit path. One-way
 // dependency: launch does NOT import transport, so no cycle.
 import { getAdapter } from '../launch/index.ts'
+import { codexSessionCwd } from '../launch/adapters/transcriptTail.ts'
 import type { ControlCommand } from '../launch/types.ts'
 // Spawn-flip Ф0b-2: warm-deliver is HOST-AWARE. hostSessionAlive (runtime-state host detect, an
 // @xterm-free pid-file check) + deliverHosted (the pure-protocol socket leaf, Ф0a) come from
@@ -234,7 +235,11 @@ async function deliverViaHost(
   // Baseline the transcript/session-jsonl file SIZES BEFORE delivery (per-runtime candidate files).
   // The landed-confirm reads ONLY the bytes appended past this baseline, so a record carrying our
   // envelope can only be one written in RESPONSE to this delivery — never a pre-existing copy.
-  const baseline = cwd ? compactDoneBaseline(target.runtime, cwd) : null
+  // LAZY: only 'transcript'-confirm runtimes (claude) use the baseline; router (socket-ack) and
+  // socket-ack runtimes (codex) return before it — computing it for them recursively scanned all of
+  // ~/.codex/sessions (full-file read per session) on every delivery for nothing.
+  const usesBaseline = adapter.kind !== 'router' && adapter.deliveryConfirm !== 'socket-ack'
+  const baseline = cwd && usesBaseline ? compactDoneBaseline(target.runtime, cwd) : null
   const send = seam.deliverHosted ?? deliverHosted
   const sent = await send(target.address, envelope)
   if (!sent.ok) {
@@ -374,14 +379,36 @@ function claudeTranscriptDirForCwd(cwd: string, env?: NodeJS.ProcessEnv): string
   return join(envHome(env), '.claude', 'projects', slug)
 }
 
-function codexSessionCwd(file: string): string | null {
+// codexSessionCwd (bounded first-line read + path-memoized) is shared from launch/adapters/transcriptTail.ts —
+// the old full-file readFileSync here scanned tens of MB per session file on every warm delivery baseline.
+
+/** Read ONLY the bytes of `path` past `offset` (the appended tail), without loading the whole file.
+ *  O(added bytes) instead of O(entire history) — the transcript files this scans grow to hundreds of MB.
+ *  Returns '' on any fs error / empty tail. */
+function readFileTailFrom(path: string, offset: number): string {
+  let fd: number
   try {
-    const firstLine = readFileSync(file, 'utf8').split(/\r?\n/, 1)[0]
-    if (!firstLine) return null
-    const entry = JSON.parse(firstLine) as { type?: unknown; payload?: { cwd?: unknown } }
-    return entry.type === 'session_meta' && typeof entry.payload?.cwd === 'string' ? entry.payload.cwd : null
+    fd = openSync(path, 'r')
   } catch {
-    return null
+    return ''
+  }
+  try {
+    const size = fstatSync(fd).size
+    const start = Math.min(Math.max(0, offset), size)
+    const len = size - start
+    if (len <= 0) return ''
+    const buf = Buffer.allocUnsafe(len)
+    let read = 0
+    while (read < len) {
+      const n = readSync(fd, buf, read, len - read, start + read)
+      if (n <= 0) break
+      read += n
+    }
+    return buf.subarray(0, read).toString('utf8')
+  } catch {
+    return ''
+  } finally {
+    closeSync(fd)
   }
 }
 
@@ -478,14 +505,8 @@ export function compactTranscriptHasDone(
   }
 
   for (const [path, offset] of offsets) {
-    let buf: Buffer
-    try {
-      buf = readFileSync(path)
-    } catch {
-      continue
-    }
-    const start = Math.min(Math.max(0, offset), buf.length)
-    const tail = buf.subarray(start).toString('utf8')
+    const tail = readFileTailFrom(path, offset) // tail-only read (see transcriptCarriesEnvelope)
+    if (!tail) continue
     for (const line of tail.split(/\r?\n/)) {
       if (!line.trim()) continue
       let obj: unknown
@@ -537,14 +558,11 @@ export function transcriptCarriesEnvelope(baseline: CompactDoneBaseline, envelop
   const needle = envelope.replace(/\r/g, '')
   if (!needle) return false
   for (const { path, size: offset } of baseline.files) {
-    let buf: Buffer
-    try {
-      buf = readFileSync(path)
-    } catch {
-      continue
-    }
-    const start = Math.min(Math.max(0, offset), buf.length)
-    const tail = buf.subarray(start).toString('utf8')
+    // Read ONLY the tail past the baseline offset — a full readFileSync here re-read the ENTIRE
+    // transcript (hundreds of MB for a long-running peer) on every ~100ms confirm-poll, stalling the
+    // single-threaded router event loop for the whole fleet.
+    const tail = readFileTailFrom(path, offset)
+    if (!tail) continue
     for (const line of tail.split(/\r?\n/)) {
       if (!line.trim()) continue
       let obj: unknown