@songsid/agend 2.2.0-beta.1 → 2.2.0-beta.10

package/dist/transcript-sources.js

@@ -26,17 +26,125 @@ import { measureSyncWork } from "./sync-work-attribution.js";
  *   - Every poll re-resolves which transcript is active. Pinning to the first
  *     one found silently goes blind when the CLI starts a new session.
  */
-import { closeSync, existsSync, openSync, readSync, realpathSync } from "node:fs";
-import { readdir, readFile, stat } from "node:fs/promises";
+import { existsSync, realpathSync } from "node:fs";
+import { open as openFile, readdir, readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { sharedRolloutIndex } from "./rollout-index.js";
 import Database from "better-sqlite3";
 import { sharedKiroTranscriptLane } from "./kiro-transcript-lane.js";
 export { extractKiroAssistantStrings } from "./kiro-db-reader.js";
-import { lastLineBoundary, readNewLines } from "./transcript-jsonl.js";
+import { LINE_MAX_BYTES, LONG_HEAD_BYTES, LOOKS_PER_POLL, READ_MAX_BYTES, lastLineBoundary, readNewLines, readWholeLine, resolveLongLines } from "./transcript-jsonl.js";
 import { museSessionCwd, readFileHeadSync } from "./backend/muse.js";
 import { performance } from "node:perf_hooks";
+/**
+ * #1641 R3: the complete records in [from, to) that `keep` accepts — `to` is a line boundary (a checkpoint's), so
+ * nothing is cut. #1218 P0: read in READ_MAX_BYTES chunks (the range a checkpoint skips can be many MB), and only kept
+ * lines are held. A line over LINE_MAX_BYTES is judged by its head: kept, it is read whole (≤ WHOLE_LINE_MAX_BYTES —
+ * a turn's record must not be lost to the limit, #1786 review); otherwise it is skipped without being decoded.
+ */
+export async function readLineRange(path, from, to, keep = () => true) {
+    const fh = await openFile(path, "r");
+    const out = [];
+    const whole = async (offset, bytes, head) => {
+        if (!keep(head))
+            return;
+        const line = await readWholeLine(path, offset, bytes);
+        if (line !== null && line.trim() && keep(line))
+            out.push(line);
+    };
+    try {
+        let pos = from;
+        let long = null; // a long line that started in an earlier chunk
+        while (pos < to) {
+            const buffer = Buffer.alloc(Math.min(READ_MAX_BYTES, to - pos));
+            for (let filled = 0; filled < buffer.length;) {
+                const { bytesRead } = await fh.read(buffer, filled, buffer.length - filled, pos + filled);
+                if (bytesRead <= 0)
+                    throw new Error(`readLineRange: no progress reading ${path} at ${pos + filled}`);
+                filled += bytesRead;
+            }
+            // Up to the last line end in this chunk (the range's end is one); a chunk with none is inside one long line.
+            const complete = buffer.lastIndexOf(0x0a) + 1;
+            if (complete === 0) {
+                long ??= { start: pos, head: buffer.toString("utf8", 0, Math.min(LONG_HEAD_BYTES, buffer.length)) };
+                pos += buffer.length;
+                continue;
+            }
+            let start = 0;
+            while (start < complete) {
+                const end = buffer.indexOf(0x0a, start);
+                if (long) {
+                    await whole(long.start, pos + end - long.start, long.head);
+                    long = null;
+                }
+                else if (end - start > LINE_MAX_BYTES) {
+                    await whole(pos + start, end - start, buffer.toString("utf8", start, start + LONG_HEAD_BYTES));
+                }
+                else {
+                    const line = buffer.toString("utf8", start, end);
+                    if (line.trim() && keep(line))
+                        out.push(line);
+                }
+                start = end + 1;
+            }
+            pos += complete;
+        }
+        return out;
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** #1641 R2: how far back from the baseline a rollout is scanned for the last turn boundary (a turn writes a lot). */
+export const ROLLOUT_TURN_SCAN_MAX_BYTES = 16 * 1024 * 1024;
+const ROLLOUT_TURN_SCAN_CHUNK = 256 * 1024;
+/**
+ * #1641 R2: the last turn boundary (task_started / task_complete / turn_aborted) a codex rollout holds before `end`,
+ * scanning back at most ROLLOUT_TURN_SCAN_MAX_BYTES: `none` when the whole prefix holds none (no turn ever started),
+ * null when the bound ran out first (unknown). Nothing else is read or replayed.
+ */
+export async function lastRolloutTurnBoundary(path, end, maxBytes = ROLLOUT_TURN_SCAN_MAX_BYTES) {
+    const fh = await openFile(path, "r");
+    try {
+        const stop = Math.max(0, end - maxBytes);
+        let pos = end;
+        let carry = Buffer.alloc(0);
+        while (pos > stop) {
+            const from = Math.max(stop, pos - ROLLOUT_TURN_SCAN_CHUNK);
+            const chunk = Buffer.alloc(pos - from);
+            await fh.read(chunk, 0, chunk.length, from);
+            pos = from;
+            const buf = Buffer.concat([chunk, carry]);
+            const lines = buf.toString("utf8").split("\n");
+            // The first piece may be the tail of a line that starts in an earlier chunk (unless this is the scan's start).
+            carry = pos > stop ? Buffer.from(lines.shift() ?? "", "utf8") : Buffer.alloc(0);
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const line = lines[i];
+                if (!/"(?:task_started|task_complete|turn_aborted)"/.test(line))
+                    continue;
+                let entry;
+                try {
+                    entry = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const p = entry.payload;
+                if (entry.type !== "event_msg" || !p || typeof p.turn_id !== "string")
+                    continue;
+                if (p.type === "task_started")
+                    return { kind: "start", turnId: p.turn_id };
+                if (p.type === "task_complete" || p.type === "turn_aborted")
+                    return { kind: "end", turnId: p.turn_id };
+            }
+        }
+        return stop === 0 ? { kind: "none" } : null;
+    }
+    finally {
+        await fh.close();
+    }
+}
 const EMPTY = { toolUses: [], toolResults: [], assistantTexts: [] };
 function emptyEvents() {
     return { toolUses: [], toolResults: [], assistantTexts: [] };
@@ -51,7 +159,13 @@ export class CodexRolloutSource {
     workingDirectory;
     sessionsDir;
     currentFile = null;
+    /** #1218: the rollout followed now. */
+    currentPath() { return this.currentFile; }
     byteOffset = 0;
+    /** #1218 P0: the offset is inside a long line being skipped (readNewLines `skipping`). */
+    skipping = false;
+    /** #1218 P0: a long line being skipped that is to be read whole once its end is found. */
+    pendingLong = null;
     /** EOF snapshots taken when the monitor attaches; existing history is skipped. */
     initialOffsets = new Map();
     /** Files whose session_meta was read and did NOT match our cwd. */
@@ -71,29 +185,137 @@ export class CodexRolloutSource {
         this.index = index ?? sharedRolloutIndex(sessionsDir);
         this.snapshotExistingFiles();
     }
+    /** #1641: the last poll found this instance's rollout and read it (see TranscriptSource.following). */
+    lastPollFollowed = false;
+    /** #1641 R2: the turn open in the current file (its task_started read, no end yet), and whether that is known. */
+    openTurn = null;
+    turnKnown = false;
+    /** #1641 R2: boundaries decided at adoption (the old file's open turn ended, the new file's open turn carried in). */
+    pendingTurns = [];
+    following() {
+        return this.lastPollFollowed && this.currentFile !== null;
+    }
+    turnStateKnown() {
+        return this.turnKnown;
+    }
+    /** #1641 R3: turn records decided outside a poll (a checkpoint's adoption or skipped range), handed over now. */
+    takeTurns() {
+        return this.pendingTurns.splice(0);
+    }
     reset() {
+        this.lastPollFollowed = false;
+        this.openTurn = null;
+        this.turnKnown = false;
+        this.pendingTurns = [];
         this.currentFile = null;
         this.byteOffset = 0;
+        this.skipping = false;
+        this.pendingLong = null;
         this.openTurnId = "";
         this.rejected.clear();
         this.accepted.clear();
         this.snapshotExistingFiles();
     }
     async checkpoint() {
-        const active = this.candidateFiles(true).find(file => this.fileBelongsToUs(file.path));
+        const active = await this.firstOwned(this.candidateFiles(true));
         if (!active)
             return null;
         try {
             // A line boundary, not the size: a record being written now is read once complete (#1250).
             const offset = await lastLineBoundary(active.path);
+            if (active.path !== this.currentFile)
+                await this.adopt(active.path, offset); // a switch, whoever notices it
+            else if (offset > this.byteOffset) {
+                // #1641 R3: the range this checkpoint skips is never polled — its turn boundaries (and user records) are taken
+                // now, so the turn state stays the file's. Tool and text records stay skipped, as before.
+                for (const line of await readLineRange(active.path, this.byteOffset, offset, (l) => l.includes('"event_msg"') || l.includes('"role":"user"'))) {
+                    let entry;
+                    try {
+                        entry = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    this.turnRecord(entry, this.pendingTurns);
+                }
+            }
             this.currentFile = active.path;
             this.byteOffset = offset;
+            this.skipping = false;
+            this.pendingLong = null;
             return { path: active.path, offset, sessionId: active.path };
         }
         catch {
             return null;
         }
     }
+    /**
+     * Follow `path` from `offset` (#1641 R2). A baseline past an existing file's start skips its history — but not the
+     * state of its current turn: the last boundary before the baseline says whether a turn is running now (carried in as
+     * its start; no tool, user or text record is replayed), and none within the scan bound leaves it unknown until one is
+     * read. A turn left open in the file being replaced belongs to that file, no longer followed: its busy evidence is
+     * withdrawn (retracted, not ended — nothing says how it ended).
+     */
+    async adopt(path, offset) {
+        let baseline = null;
+        let known = offset === 0; // read from its start: every boundary will be read
+        if (offset > 0) {
+            try {
+                baseline = await lastRolloutTurnBoundary(path, offset);
+                known = baseline !== null; // `none`: the whole prefix holds no turn — known closed
+            }
+            catch {
+                known = false;
+            }
+        }
+        if (this.openTurn)
+            this.pendingTurns.push({ kind: "retract", turnId: this.openTurn });
+        this.openTurn = baseline?.kind === "start" ? baseline.turnId : null;
+        if (this.openTurn)
+            this.pendingTurns.push({ kind: "start", turnId: this.openTurn });
+        this.turnKnown = known;
+        this.currentFile = path;
+        this.byteOffset = offset;
+        this.skipping = false;
+        this.pendingLong = null;
+        this.openTurnId = this.openTurn ?? ""; // a steer after the baseline belongs to the carried-in turn
+    }
+    /**
+     * A turn record (a boundary, or a user message) into `turns`, keeping the open turn current; true when `entry` was
+     * one (or another event_msg), so the caller looks no further. #1510: codex 0.162 writes one task_started per turn and
+     * ends it with task_complete (last_agent_message null after a provider error) or turn_aborted; a steer lands inside
+     * the open turn as another user message.
+     */
+    turnRecord(entry, turns) {
+        const p = entry.payload;
+        if (!p)
+            return false;
+        if (entry.type === "event_msg") {
+            if (p.type === "task_started" && typeof p.turn_id === "string") {
+                this.openTurnId = p.turn_id;
+                this.openTurn = p.turn_id;
+                this.turnKnown = true;
+                turns.push({ kind: "start", turnId: p.turn_id });
+            }
+            else if ((p.type === "task_complete" || p.type === "turn_aborted") && typeof p.turn_id === "string") {
+                const end = p.type === "turn_aborted" ? "aborted" : p.last_agent_message == null ? "error" : "complete";
+                if (this.openTurn === p.turn_id)
+                    this.openTurn = null;
+                this.turnKnown = true;
+                turns.push({ kind: "end", turnId: p.turn_id, end });
+            }
+            return true;
+        }
+        if (entry.type === "response_item" && p.type === "message" && p.role === "user") {
+            const text = (p.content ?? [])
+                .map(block => typeof block.text === "string" ? block.text : "").join("\n");
+            const at = Date.parse(String(entry.timestamp ?? ""));
+            if (text.trim() && Number.isFinite(at))
+                turns.push({ kind: "user", turnId: this.openTurnId, text, at });
+            return true;
+        }
+        return false;
+    }
     snapshotExistingFiles() {
         this.initialOffsets = new Map(this.candidateFiles(true).map(file => [file.path, file.size]));
     }
@@ -111,23 +333,31 @@ export class CodexRolloutSource {
     candidateFiles(fresh = false) {
         return this.index.list(fresh);
     }
-    fileBelongsToUs(path) {
+    /** The first of `files` that is ours (in order), or undefined. Verdicts are cached, so a known file costs no read. */
+    async firstOwned(files) {
+        for (const file of files)
+            if (await this.fileBelongsToUs(file.path))
+                return file;
+        return undefined;
+    }
+    async fileBelongsToUs(path) {
         if (this.rejected.has(path))
             return false;
         if (this.accepted.has(path))
             return true;
         try {
             // session_meta is the first line. It can carry long instructions, so
-            // give it headroom — but never read the whole rollout.
-            const fd = openSync(path, "r");
+            // give it headroom — but never read the whole rollout. #1218 P0: read asynchronously, off the fleet loop's
+            // critical path (it was a synchronous 64 KiB read per new rollout).
+            const fh = await openFile(path, "r");
             let head;
             try {
                 const buf = Buffer.alloc(65536);
-                const bytes = readSync(fd, buf, 0, buf.length, 0);
-                head = buf.toString("utf-8", 0, bytes);
+                const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+                head = buf.toString("utf-8", 0, bytesRead);
             }
             finally {
-                closeSync(fd);
+                await fh.close();
             }
             const firstLine = head.split("\n")[0];
             const meta = JSON.parse(firstLine);
@@ -148,9 +378,13 @@ export class CodexRolloutSource {
         // Re-resolve every poll: a restarted codex writes a NEW rollout, and
         // staying pinned to the old one goes silently blind (#528 trap 1).
         const candidates = this.candidateFiles();
-        const active = candidates.find(c => this.fileBelongsToUs(c.path));
-        if (!active)
+        const active = await this.firstOwned(candidates);
+        // Cleared only by a real loss (none found, an adoption or read that failed) — never for the length of a poll's
+        // await, when a capture reading following() would drop the veto mid-turn.
+        if (!active) {
+            this.lastPollFollowed = false;
             return EMPTY;
+        }
         if (active.path !== this.currentFile) {
             // Existing rollout: continue at the EOF captured when the source was
             // created. New rollout: read from the start. Using current mtime here is
@@ -165,18 +399,43 @@ export class CodexRolloutSource {
                     offset = await lastLineBoundary(active.path, captured);
                 }
                 catch {
+                    this.lastPollFollowed = false;
                     return EMPTY;
                 }
             }
-            this.currentFile = active.path;
-            this.byteOffset = offset;
-            this.openTurnId = "";
+            await this.adopt(active.path, offset);
+        }
+        // #1218 P0: bounded looks (READ_MAX_BYTES each), a few per poll, each awaited (a sampled rollout was 322 MB).
+        const records = [];
+        for (let look = 0; look < LOOKS_PER_POLL; look++) {
+            let read;
+            try {
+                read = await readNewLines(active.path, this.byteOffset, { skipping: this.skipping });
+            }
+            catch (err) {
+                this.lastPollFollowed = false;
+                throw err;
+            }
+            this.skipping = read.skipping;
+            const moved = read.newOffset !== this.byteOffset;
+            this.byteOffset = read.newOffset;
+            // #1786 review: a long turn record (task_complete with a long final reply, a pasted prompt) is read whole — a
+            // turn's end must never be lost to the line limit. Long outputs stay head-only.
+            const resolved = await resolveLongLines(active.path, read, this.pendingLong, codexWholeLine);
+            this.pendingLong = resolved.pending;
+            records.push(...resolved.records);
+            if (!moved || !read.more)
+                break;
         }
-        const { lines, newOffset } = await readNewLines(this.currentFile, this.byteOffset);
-        this.byteOffset = newOffset;
+        this.lastPollFollowed = true;
         const events = emptyEvents();
-        const turns = [];
-        for (const line of lines) {
+        const turns = this.pendingTurns.splice(0);
+        for (const record of records) {
+            if ("long" in record) {
+                codexLongHead(record.long.head, events);
+                continue;
+            }
+            const line = record.line;
             let entry;
             try {
                 entry = JSON.parse(line);
@@ -187,29 +446,10 @@ export class CodexRolloutSource {
             const p = entry.payload;
             if (!p)
                 continue;
-            // #1510: codex 0.162 writes one task_started per turn and ends it with task_complete (last_agent_message null
-            // after a provider error) or turn_aborted; a steer lands inside the open turn as another user message.
-            if (entry.type === "event_msg") {
-                if (p.type === "task_started" && typeof p.turn_id === "string") {
-                    this.openTurnId = p.turn_id;
-                    turns.push({ kind: "start", turnId: p.turn_id });
-                }
-                else if ((p.type === "task_complete" || p.type === "turn_aborted") && typeof p.turn_id === "string") {
-                    const end = p.type === "turn_aborted" ? "aborted" : p.last_agent_message == null ? "error" : "complete";
-                    turns.push({ kind: "end", turnId: p.turn_id, end });
-                }
+            if (this.turnRecord(entry, turns))
                 continue;
-            }
             if (entry.type !== "response_item")
                 continue;
-            if (p.type === "message" && p.role === "user") {
-                const text = (p.content ?? [])
-                    .map(block => typeof block.text === "string" ? block.text : "").join("\n");
-                const at = Date.parse(String(entry.timestamp ?? ""));
-                if (text.trim() && Number.isFinite(at))
-                    turns.push({ kind: "user", turnId: this.openTurnId, text, at });
-                continue;
-            }
             if (p.type === "function_call") {
                 let input = p.arguments;
                 if (typeof input === "string") {
@@ -244,6 +484,25 @@ export class CodexRolloutSource {
         return events;
     }
 }
+/** #1786 review: the long rollout lines read whole — turn records (event_msg) and messages (a pasted prompt, a long reply). */
+function codexWholeLine(head) {
+    return head.includes('"type":"event_msg"') || (head.includes('"type":"response_item"') && /"payload":\{"type":"message"/.test(head));
+}
+/**
+ * #1218 P0: a rollout line too long to parse (an output of MBs, a huge call input) — what its head still says, so the
+ * bubble keeps the step: a call by its name, or an output. Turn records and messages are read whole (codexWholeLine).
+ */
+function codexLongHead(head, events) {
+    if (!head.includes('"type":"response_item"'))
+        return;
+    const type = /"payload":\{[^{}]{0,400}?"type":"(function_call|custom_tool_call|function_call_output|custom_tool_call_output)"/.exec(head)?.[1];
+    if (type === "function_call" || type === "custom_tool_call") {
+        const name = /"name":"([^"]{1,200})"/.exec(head)?.[1];
+        events.toolUses.push({ name: name ?? "unknown", input: undefined });
+    }
+    else if (type)
+        events.toolResults.push({ name: "unknown" });
+}
 /* -------------------------------------------------------------------- muse */
 /**
  * #1510: muse's turn boundaries, from its session logs (`<root>/<YYYY>/<MM>/<DD>/<id>/session.jsonl`, recorded on
@@ -277,6 +536,9 @@ export class MuseSessionSource {
     baselineComplete = false;
     rejected = new Set();
     sizes = new Map();
+    /** #1218 P0: per log, whether its offset is inside a long line being skipped, and a long turn record held for its end. */
+    skipping = new Map();
+    pendingLong = new Map();
     listedAt = Number.NEGATIVE_INFINITY;
     baselined = false;
     /** intent_id → its text and time, until it materializes (bounded). */
@@ -293,6 +555,8 @@ export class MuseSessionSource {
         this.rejected.clear();
         this.sizes.clear();
         this.intents.clear();
+        this.skipping.clear();
+        this.pendingLong.clear();
         this.listedAt = Number.NEGATIVE_INFINITY;
         this.baselined = false;
         this.baselineComplete = false;
@@ -352,22 +616,45 @@ export class MuseSessionSource {
                     continue;
                 }
             }
-            let read;
-            try {
-                read = await readNewLines(path, from);
-            }
-            catch {
-                continue;
-            }
-            this.files.set(path, read.newOffset);
-            this.sizes.set(path, size);
-            // One record at a time: a record of an unexpected shape is skipped, never the batch it came in.
-            for (const line of read.lines) {
+            // #1218 P0 (#1786 review): bounded looks, as the other sources; the size is remembered only once the log has been
+            // read to it, so the rest of a delta over the look budget is read next poll, not when the log grows again.
+            let caughtUp = false;
+            for (let look = 0; look < LOOKS_PER_POLL; look++) {
+                let read;
                 try {
-                    this.parse(line, turns);
+                    read = await readNewLines(path, from, { skipping: this.skipping.get(path) ?? false });
+                }
+                catch {
+                    break;
+                }
+                this.skipping.set(path, read.skipping);
+                const moved = read.newOffset !== from;
+                from = read.newOffset;
+                this.files.set(path, from);
+                // A long turn record (a pasted prompt in user_intent.accepted) is read whole, bounded.
+                const resolved = await resolveLongLines(path, read, this.pendingLong.get(path) ?? null, (head) => head.includes('"payload_type":"runtime.'));
+                if (resolved.pending)
+                    this.pendingLong.set(path, resolved.pending);
+                else
+                    this.pendingLong.delete(path);
+                // One record at a time: a record of an unexpected shape is skipped, never the batch it came in.
+                for (const record of resolved.records) {
+                    if (!("line" in record))
+                        continue;
+                    try {
+                        this.parse(record.line, turns);
+                    }
+                    catch { /* skipped */ }
                 }
-                catch { /* skipped */ }
+                if (!read.more) {
+                    caughtUp = !read.skipping;
+                    break;
+                }
+                if (!moved)
+                    break;
             }
+            if (caughtUp)
+                this.sizes.set(path, size);
         }
         const events = emptyEvents();
         if (turns.length)
@@ -564,6 +851,10 @@ export class KiroSessionSource {
     lane;
     currentFile = null;
     byteOffset = 0;
+    /** #1218 P0: the offset is inside a long line being skipped (readNewLines `skipping`). */
+    skipping = false;
+    /** #1218 P0: a long line being skipped that is to be read whole once its end is found. */
+    pendingLong = null;
     createdAt;
     generation = 0;
     cursor;
@@ -597,6 +888,8 @@ export class KiroSessionSource {
         this.close();
         this.currentFile = null;
         this.byteOffset = 0;
+        this.skipping = false;
+        this.pendingLong = null;
         this.cursor = undefined;
         this.needsBaseline = true;
         void this.initialize();
@@ -734,6 +1027,8 @@ export class KiroSessionSource {
             if (active.createdAtMs >= this.createdAt) {
                 this.currentFile = active.jsonlPath;
                 this.byteOffset = 0; // our own fresh session — observable from the start
+                this.skipping = false;
+                this.pendingLong = null;
             }
             else {
                 // An older session is attached at its last line boundary. If that cannot be read now, nothing is adopted
@@ -749,23 +1044,39 @@ export class KiroSessionSource {
                     return EMPTY;
                 this.currentFile = active.jsonlPath;
                 this.byteOffset = offset;
+                this.skipping = false;
+                this.pendingLong = null;
                 return EMPTY;
             }
         }
-        const { lines, newOffset } = await readNewLines(this.currentFile, this.byteOffset);
-        if (generation !== this.generation)
-            return EMPTY;
-        this.byteOffset = newOffset;
+        // #1218 P0: bounded looks, as the other JSONL sources. Kiro's nesting needs the whole record: a long line is read
+        // whole up to WHOLE_LINE_MAX_BYTES (as every line was before), and skipped beyond it.
         const events = emptyEvents();
-        for (const line of lines) {
-            let entry;
-            try {
-                entry = JSON.parse(line);
-            }
-            catch {
-                continue;
+        for (let look = 0; look < LOOKS_PER_POLL; look++) {
+            const read = await readNewLines(this.currentFile, this.byteOffset, { skipping: this.skipping });
+            if (generation !== this.generation)
+                return EMPTY;
+            this.skipping = read.skipping;
+            const moved = read.newOffset !== this.byteOffset;
+            this.byteOffset = read.newOffset;
+            const resolved = await resolveLongLines(this.currentFile, read, this.pendingLong, () => true);
+            if (generation !== this.generation)
+                return EMPTY;
+            this.pendingLong = resolved.pending;
+            for (const record of resolved.records) {
+                if (!("line" in record))
+                    continue;
+                let entry;
+                try {
+                    entry = JSON.parse(record.line);
+                }
+                catch {
+                    continue;
+                }
+                collectKiroEvents(entry, events);
             }
-            collectKiroEvents(entry, events);
+            if (!moved || !read.more)
+                break;
         }
         return events;
     }