@agfpd/iapeer 0.4.30 → 0.4.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.30",
+  "version": "0.4.31",
   "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/transcriptTail.ts

@@ -11,12 +11,24 @@ import { openSync, readSync, closeSync, statSync } from 'fs'
 
 /**
  * Content-timestamp (epoch ms) of the LAST jsonl entry carrying a `timestamp` field, read from the
- * file's TAIL (cheap — only the last `tailBytes` are read). Metadata records without a `timestamp`
- * (claude `mode` / `ai-title` / `bridge-session`) are skipped. Returns null when the file is
- * unreadable or no timestamped entry sits in the tail (the caller then floors at wokeAt). A partial
- * FIRST line in the tail buffer is harmless: we scan from the END and return on the first complete
- * timestamped entry, so a truncated leading line is only ever reached (and skipped) when nothing
- * matched.
+ * file's TAIL. Metadata records without a `timestamp` (claude `mode` / `ai-title` / `bridge-session`)
+ * are skipped. Returns null only when the file is unreadable / empty, or genuinely carries NO
+ * timestamped entry anywhere (the caller then floors at wokeAt).
+ *
+ * ADAPTIVE WINDOW (the giant-tail fix). The reader starts at the cheap `tailBytes` window and GROWS it
+ * (doubling, capped at file size) until a complete timestamped entry is captured. A single transcript
+ * record can dwarf the default window — a browser peer appends base64 screenshots, observed up to
+ * 368 KB (5.6× the 64 KB default). When such a record is the tail, a FIXED window holds only a fragment
+ * of one line: no complete JSON → the old code returned null, the caller floored at wokeAt, and a LIVE
+ * working session was idle-reaped (incident: mrbrowser killed mid-task, last turn 7 s before the reap).
+ * Growing guarantees we eventually read the full last record (worst case: the entire file), so a present
+ * timestamp is NEVER missed. The default window already covers the common case in one read; growth only
+ * kicks in for oversized tail records, and even then is bounded (≈log2(fileSize/tailBytes) reads).
+ *
+ * A partial LEADING line is never trusted: once the window starts past byte 0, the first split segment
+ * may be the truncated tail of an earlier record (which could mis-parse as valid JSON), so we scan only
+ * the newline-bounded segments after it. Reaching byte 0 makes every segment complete, including the
+ * first — and terminates the growth.
  */
 export function lastTimestampedEntryMs(path: string, tailBytes = 65536): number | null {
   let fd: number
@@ -27,35 +39,45 @@ export function lastTimestampedEntryMs(path: string, tailBytes = 65536): number
   }
   try {
     const size = statSync(path).size
-    const start = Math.max(0, size - tailBytes)
-    const len = size - start
-    if (len <= 0) return null
-    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
-    }
-    const lines = buf.subarray(0, read).toString('utf8').split(/\r?\n/)
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const line = lines[i].trim()
-      if (!line) continue
-      let obj: unknown
-      try {
-        obj = JSON.parse(line)
-      } catch {
-        continue // partial leading line / non-json → skip
+    if (size <= 0) return null
+    let window = Math.max(tailBytes, 1)
+    for (;;) {
+      const start = Math.max(0, size - window)
+      const len = size - start
+      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
       }
-      const ts = (obj as { timestamp?: unknown })?.timestamp
-      if (typeof ts === 'string') {
-        const ms = Date.parse(ts)
-        if (!Number.isNaN(ms)) return ms
-      } else if (typeof ts === 'number' && Number.isFinite(ts)) {
-        return ts
+      const atFileStart = start === 0
+      const lines = buf.subarray(0, read).toString('utf8').split(/\r?\n/)
+      // Segment 0 is a complete record ONLY when the window reaches byte 0; otherwise it is the possibly
+      // truncated tail of an earlier record and must not be parsed (`floor` skips it).
+      const floor = atFileStart ? 0 : 1
+      for (let i = lines.length - 1; i >= floor; i--) {
+        const line = lines[i].trim()
+        if (!line) continue
+        let obj: unknown
+        try {
+          obj = JSON.parse(line)
+        } catch {
+          continue // metadata fragment / non-json → skip
+        }
+        const ts = (obj as { timestamp?: unknown })?.timestamp
+        if (typeof ts === 'string') {
+          const ms = Date.parse(ts)
+          if (!Number.isNaN(ms)) return ms
+        } else if (typeof ts === 'number' && Number.isFinite(ts)) {
+          return ts
+        }
       }
+      // No complete timestamped entry in this window. If the whole file is read, there genuinely is none.
+      // Otherwise the tail record outgrows the window → grow and retry (terminates: window hits size → start 0).
+      if (atFileStart) return null
+      window *= 2
     }
-    return null
   } catch {
     return null
   } finally {