@assuredloop/orca-bot-kit 0.16.0 → 0.18.0

package/SETUP.md

@@ -199,7 +199,7 @@ waiting for:
 | Codex's `/new`: `Where should the new conversation run?` | `\r` | return: its selection starts on **Current checkout** (bot home) | Codex 0.158.0 |
 | Codex's update offer, `1. Update now` | `\r` | return: its selection starts on **Update now**, which accepts it | Codex 0.156.1; seen on 0.157.1 (offering 0.158.0) with the selection on **Update now**, not pressed; 0.158.0 has had no newer release to offer |
 | `[oh-my-zsh] Would you like to update?` | `n` | they update their own shell | oh-my-zsh bf77e35 |
-| Claude Code's `Teach auto mode about your environment?` | `\x1b` | Esc, which cancels it. On 2.1.283 it is a form, not a list: `How you use Claude here`, `Also scan shell history`, `Also scan your other repos`, `Continue`, and `Enter to continue · Esc to cancel`. **Never send a return**: Enter is **Continue**, which starts a scan of the project, recent Claude sessions and, by default, the machine's shell history | Not yet proven: Esc cancels in Claude Code 2.1.283's code, not yet seen live (#370); the form was seen live on 2.1.283 (#416); 2.1.278 showed a numbered list, answered with 2. Not now |
+| Claude Code's `Teach auto mode about your environment?` | `\x1b` | Esc, which cancels it (**Not now**). On 2.1.283 it is a form, not a list: `How you use Claude here`, `Also scan shell history`, `Also scan your other repos`, `Continue`, and `Enter to continue · Esc to cancel`. **Never send a return**: Enter is **Continue**, which starts a scan of the project, recent Claude sessions and, by default, the machine's shell history | Not yet proven: Esc cancels in Claude Code 2.1.283's code, not yet seen live (#370); the form was seen live twice on 2.1.283, in #261's live test and #239's live run 1 (#416); 2.1.278 showed a numbered list, answered with 2. Not now |
 
 Each key counts on where the selection starts, as it did on the version named.
 Read the screen in front of you before you send: if the selection is somewhere

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assuredloop/orca-bot-kit",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/rules/limits.md

@@ -18,5 +18,5 @@ When something you were told to use is missing (a model, a tool, a file), say
 so and ask. Quietly using a different one hides the change.
 
 Permission rules in a harness's settings or rules files are the kit's to write,
-after the user's yes to the exact rules: `obk bot change --allow <rule>` or
+after the user's yes to the exact rules: `"${OBK_CLI:-obk}" bot change --allow <rule>` or
 `--disallow <rule>`. Never edit one in or out yourself, Bot Father included.

package/rules/mail.md

@@ -12,5 +12,8 @@ Mail is queued, not an interruption. Read it when you finish what you are on.
 
 Ask for a reply when you need one, and send one when you were asked for one.
 
+A message sent is queued, not read or acted on: the reply, or the work done,
+is what shows it arrived. Look for one before you send it again.
+
 Write to the session that needs it, not to several in the hope that one of
 them is right.

package/skills/obk-bot-building/SKILL.md

@@ -19,6 +19,10 @@ own commands write them.
 These are defaults for work where nothing says otherwise. A user who asks for
 something else gets what they asked for; say which of these you left and why.
 
+Where this skill says `obk`, run the kit that started your tab, `"${OBK_CLI:-obk}"`,
+in its place: in a tab the kit launched that is the kit's own path, and anywhere
+else it is plain `obk`.
+
 ## Ask whether this wants a new bot
 
 Look at the fleet before you add to it. Where a bot already there could own
@@ -289,7 +293,7 @@ otherwise `/Applications/Orca.app/Contents/Resources/bin/orca`. A bare
 | Codex's `Where should the new conversation run?` | `\r` | **Current checkout** | Codex 0.158.0 |
 | Codex's update offer, `1. Update now` | `\r` | **Update now**, where it starts | Codex 0.156.1 |
 | `[oh-my-zsh] Would you like to update?` | `n` | no: the user updates it | oh-my-zsh bf77e35 |
-| Claude Code's `Teach auto mode…` | `\x1b` | Esc cancels; no return | Not yet proven, below |
+| Claude Code's `Teach auto mode…` | `\x1b` | Esc: Not now; no return | Not yet proven, below |
 
 Each key counts on where the selection starts on the version named. Read the
 screen before you send: if the selection is elsewhere or the options have
@@ -302,8 +306,9 @@ Update now, not pressed, and 0.158.0 has had no newer release to offer.
 Claude Code's `Teach auto mode` on 2.1.283 is a form, not a list, ending
 `Enter to continue · Esc to cancel`: never send it a return, since
 Enter is Continue, which scans the project, recent sessions and the machine's
-shell history. Esc cancels in its code; that is not yet proven live. On 2.1.278
-it was a numbered list, answered with `2. Not now`. Codex's hooks
+shell history. Esc cancels it (Not now) in its code; that is not yet proven
+live, though the form was seen live twice on 2.1.283. On 2.1.278 it was a
+numbered list, answered with `2. Not now`. Codex's hooks
 question matters most. The kit's hook is how the book learns which
 conversation the session is running, and until it is answered the
 conversation has not started. Codex's trust applies to the repository root,

package/skills/obk-finops/SKILL.md

@@ -24,6 +24,10 @@ kind that gets read once.
 These are defaults for work where nothing says otherwise. A user who asks for
 something else gets what they asked for; say which of these you left and why.
 
+Where this skill says `obk`, run the kit that started your tab, `"${OBK_CLI:-obk}"`,
+in its place: in a tab the kit launched that is the kit's own path, and anywhere
+else it is plain `obk`.
+
 ## Start from what was used, not from an impression
 
 The kit counts it for you. `obk usage` reports, per session, the conversations
@@ -60,6 +64,32 @@ than metered billing, tokens are not money at all, and the honest answer is what
 would have cost metered, and what share of the allowance it used where the
 plan shows that.
 
+## When a bill and an estimate cover the same work
+
+An invoice, a bill or the provider's usage page is better evidence than an
+estimate made from tokens and a price you looked up today. Where both cover
+the same work, report the charge and say that is where the figure came from.
+The estimate is not added to it: it measures the same spending a second time,
+and is worth keeping beside the charge only to show how far the two differ.
+
+Watch for the same thing in smaller pieces. A figure for a whole session
+already includes the calls inside it, so do not add the per-call figures to
+it, or a day's total to the sessions it is made of. Take one level and say
+which.
+
+Keep currencies apart. An invoice in euros and an estimate in dollars are two
+figures, each with its currency, until you have a rate you can name, with its
+date and its source. Converting quietly hides a guess inside a number.
+
+And an unknown stays unknown. A day with no invoice yet and no price you could
+find is a gap, not a zero: a zero says the work was free.
+
+A worked example. For 20 September the provider's invoice says 41.20 USD for
+the API, and the token estimate for the same day, at today's list price, is
+38.90 USD. Report one figure, 41.20 USD, with its source: the invoice. Add
+that the estimate came to 38.90 USD, so a reader can see the estimate runs
+about six per cent low, and leave it out of the total.
+
 ## Cost a result, not a token
 
 Tokens per day tells you nothing about whether the money bought anything. Put

package/skills/obk-fleet-review/SKILL.md

@@ -25,6 +25,10 @@ act on your own, and that is set by the charter you are working under.
 These are defaults for work where nothing says otherwise. A user who asks for
 something else gets what they asked for; say which of these you left and why.
 
+Where this skill says `obk`, run the kit that started your tab, `"${OBK_CLI:-obk}"`,
+in its place: in a tab the kit launched that is the kit's own path, and anywhere
+else it is plain `obk`.
+
 ## Start from what is on disk
 
 Read the fleet before you talk about it. `obk roster` reports what each bot

package/skills/obk-grooming/SKILL.md

@@ -22,6 +22,10 @@ reports the same thing every morning teaches its reader to stop looking.
 These are defaults for work where nothing says otherwise. A user who asks for
 something else gets what they asked for; say which of these you left and why.
 
+Where this skill says `obk`, run the kit that started your tab, `"${OBK_CLI:-obk}"`,
+in its place: in a tab the kit launched that is the kit's own path, and anywhere
+else it is plain `obk`.
+
 ## Only what has happened since last time
 
 Fix the end of the window before you read, not after. Take the moment you are

package/skills/obk-personal-facilitation/SKILL.md

@@ -33,6 +33,36 @@ they actually gave you: no invented deadline, priority, category or detail.
 Where an item is too vague to carry a next action, keep it and ask. Do what you
 can first, then ask once, in your reply rather than in a file.
 
+## When the list comes from several places
+
+Chats, mail and trackers are full of questions to a group, answered later by
+someone else, or overtaken since. Read only the sources they gave you, and put
+on the list only what is theirs.
+
+An item is theirs when it was addressed to them, by name or directly, or when
+they took it on ("I'll look at it"). A question to a group they are in is not
+theirs for being in the group.
+
+Before you add one, read what came after it: a later reply may have answered
+it, or someone else may have taken it. Where a tracker keeps its own state,
+that state wins over an old message about it: a closed issue is closed,
+whatever the thread said last week.
+
+Tell three kinds apart. Something they have to do goes on the list. A quick
+question they can answer in a line goes to them now, with the answer ready if
+you have it. Information that asks nothing of them does not go on the list at
+all.
+
+And their own word beats every source. An item they took off or rewrote stays
+as they left it, even where the chat still says otherwise: do not put it back.
+
+For example: on Monday someone asks the team chat "can anyone look at the
+failing build?". They are in the team, and nobody names them. On Tuesday a
+colleague replies "fixed, it was the cache". That is not their item: it was not
+addressed to them, and someone else has answered it. Had it said "@them, can
+you look at the build?" with no reply since, it would be an action on their
+list, with the message as where it came from.
+
 ## Change the entry, do not add another
 
 When they revise something, edit the entry that is there and leave every other

package/skills/obk-tdd/SKILL.md

@@ -410,6 +410,36 @@ check, untested guard clauses and early returns, error branches, boundaries
 mutable state, order dependence, the clock, the timezone, the real network, a
 sleep, an assertion on the order of something unordered.
 
+## Generated inputs: is there one the code gets wrong?
+
+The mutation check asks whether the tests would notice if the code were wrong.
+This asks the other question: is there an input the code gets wrong? Example
+tests only try the inputs someone thought of. Generated ones try many more.
+
+They earn their place where the inputs are many and a rule holds for all of
+them: parsers, encoders and decoders, anything with a round trip, normalisers,
+sorting and merging, and code with an invariant. A function with three cases
+is better served by three example tests.
+
+State the property first, as a sentence true of every input: decoding what was
+encoded gives the input back; the output is sorted and holds the same elements;
+running it twice gives what running it once gave; it agrees with a slow, obvious
+version of itself. A property that restates the implementation proves nothing.
+
+Generate the inputs with a small loop and a seeded generator. No library is
+needed, and none should become a dependency for this. Weight them towards the
+edges (empty, one element, the largest, odd characters, the boundaries the
+requirement names), bound the count and the time, and print the seed, so a
+failure can be run again exactly.
+
+When one fails, make the input as small as it will go while it still fails, and
+keep it as an ordinary example test: red first, then the fix. The generated test
+stays too, but the example is what guards that bug from now on.
+
+Report what was generated, how many, the seed, and the property. Say what failed
+and which example tests it became. "Two thousand inputs, seed 7, no failure" is
+evidence for those inputs, not a proof, so say it that way.
+
 ## The mutation check before you call it done
 
 The question is the whole point: if a real mistake were made in this code,
@@ -424,9 +454,17 @@ make a test fail, each one put back. Stop when another break would add no
 evidence, and say why the set you ran was enough: two meaningful breaks beat five
 padded ones. Reported in three lines.
 
-One break at a time, never two at once: note the original, apply the break, run
-the tests, record killed or survived, restore the code immediately, then the
-next one.
+Make the breaks in a disposable copy of the change, never in the working tree:
+a git worktree, or a copy of the folder, made for the check and thrown away
+after it. A run that is interrupted, a restore that fails, or a second writer in
+the same checkout would otherwise leave a planted defect in real code. Before you
+start, note what `git status` and `git diff` say about the real tree.
+
+One break at a time, never two at once: in the copy, note the original, apply
+the break, run the tests there, record killed or survived, put the code back,
+then the next one. When the check is done, remove the copy, and confirm the
+working tree is untouched: `git status` and `git diff` say what they said before
+the check.
 
 What to break, in this order: boundaries (`<` for `<=`, one off), boolean logic
 (`&&` for `||`, a dropped `not`), returned values (an empty or default return,

package/src/conversations.js

@@ -10,10 +10,12 @@
 // directory, and every session starts at its bot home. Read only, never
 // written: these are the harness's files (tech notes, sections 2 and 3).
 
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
 
+import { eachLine, firstLine } from './lines.js';
+
 /** Claude Code's transcripts: one folder per working directory, one file per session. */
 const claudeDir = (home) => path.join(homedir(), '.claude', 'projects', slug(home));
 
@@ -53,12 +55,32 @@ export function hasConversation(harness, home, id) {
   return codexRollout(id) !== undefined;
 }
 
+/** Where Codex moves a rollout the user archives: one flat folder (#396). Other ways it archives are not known. */
+const codexArchive = () => path.join(homedir(), '.codex', 'archived_sessions');
+
 /**
  * Where Codex keeps the conversation `id`, whatever folder it ran in, found by
- * the file name Codex makes from the id; `undefined` when it has none.
+ * the file name Codex makes from the id: among its sessions, or else among the
+ * ones archived; `undefined` when it has none.
  */
-export const codexRollout = (id) =>
-  rollouts(codexDir()).find((file) => path.basename(file).endsWith(`-${id}.jsonl`));
+export const codexRollout = (id) => {
+  const named = (file) => path.basename(file).endsWith(`-${id}.jsonl`);
+  return rollouts(codexDir()).find(named)
+    ?? files(codexArchive()).map((name) => path.join(codexArchive(), name)).find(named);
+};
+
+/**
+ * Where Claude Code keeps the conversation `id`, whatever folder it ran in: the
+ * `<id>.jsonl` in any of its project folders; `undefined` when it has none.
+ */
+export function claudeTranscriptAnywhere(id) {
+  const projects = path.join(homedir(), '.claude', 'projects');
+  for (const folder of files(projects)) {
+    const file = path.join(projects, folder, `${id}.jsonl`);
+    if (existsSync(file)) return file;
+  }
+  return undefined;
+}
 
 /**
  * Where Claude Code keeps the conversation `id` of this bot home, whether or
@@ -115,14 +137,19 @@ export function transcriptsIn(harness, home, since) {
  * Its AGENTS.md goes in as a `user` item too, and cannot be the text asked about.
  */
 export function heldAsUserTurn(harness, file, text) {
-  let lines;
+  const wanted = text.trim();
+  let held = false;
   try {
-    lines = readFileSync(file, 'utf8').split('\n');
+    // A line at a time, whatever the record's size (#396), and no further than
+    // the turn that holds it.
+    eachLine(file, (line) => {
+      held = line !== undefined && userTexts(harness, line).some((said) => said.trim() === wanted);
+      return held;
+    });
   } catch {
     return false;
   }
-  const wanted = text.trim();
-  return lines.some((line) => userTexts(harness, line).some((said) => said.trim() === wanted));
+  return held;
 }
 
 /** The texts of one record line, when it is a turn of the user's. */
@@ -160,8 +187,7 @@ function claudeConversations(home) {
 /** When a transcript's first line says the conversation was, if it says at all. */
 function said(file) {
   try {
-    const first = readFileSync(file, 'utf8').split('\n', 1)[0];
-    const when = Date.parse(JSON.parse(first)?.timestamp ?? '');
+    const when = Date.parse(JSON.parse(firstLine(file) ?? '')?.timestamp ?? '');
     return Number.isNaN(when) ? undefined : when;
   } catch {
     return undefined;
@@ -201,8 +227,7 @@ function rollouts(dir, depth = 0) {
 /** A rollout's first line says what the conversation is: its id, folder and time. */
 function sessionMeta(file) {
   try {
-    const first = readFileSync(file, 'utf8').split('\n', 1)[0];
-    const parsed = JSON.parse(first);
+    const parsed = JSON.parse(firstLine(file) ?? '');
     return parsed?.type === 'session_meta' ? parsed.payload : undefined;
   } catch {
     return undefined;

package/src/lines.js

@@ -0,0 +1,77 @@
+// A transcript read a line at a time, whatever its size (#396).
+//
+// A harness's record of a conversation can outgrow what one string holds: a
+// Codex rollout of 1.28 GB was seen on a live fleet, and reading it whole
+// threw, so the conversation dropped out of the book's lookup and its usage
+// without a word. So nothing here reads a file whole. The first line is read
+// from the start of the file alone, and a whole transcript goes through a
+// chunk at a time, its text decoded across the chunks so that a character
+// split between two of them stays whole.
+//
+// A line longer than any record the kit reads is not held: it comes through as
+// `undefined`, for the caller to count as a line it could not read. A file cut
+// short and padded (a sparse run of NUL bytes, one enormous "line") is read
+// through to its end without being held either.
+
+import { closeSync, openSync, readSync } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+
+/** How much is read at a time. */
+const CHUNK = 64 * 1024;
+
+/** The longest line held whole. */
+const LONGEST = 64 * 1024 * 1024;
+
+/**
+ * Each line of `file`, in order, to `onLine`: its text, or `undefined` for a
+ * line too long to hold. A line `onLine` answers `true` to is the last one
+ * read. Throws what the file system throws when the file cannot be opened or
+ * read.
+ */
+export function eachLine(file, onLine) {
+  const fd = openSync(file, 'r');
+  try {
+    const decoder = new StringDecoder('utf8');
+    const buffer = Buffer.allocUnsafe(CHUNK);
+    let pending = '';
+    let tooLong = false;
+    for (;;) {
+      const read = readSync(fd, buffer, 0, CHUNK, null);
+      const text = read === 0 ? decoder.end() : decoder.write(buffer.subarray(0, read));
+      let start = 0;
+      for (let at = text.indexOf('\n'); at !== -1; at = text.indexOf('\n', start)) {
+        const line = tooLong ? undefined : pending + text.slice(start, at);
+        pending = '';
+        tooLong = false;
+        start = at + 1;
+        if (onLine(line) === true) return;
+      }
+      const rest = text.slice(start);
+      if (!tooLong) {
+        if (pending.length + rest.length > LONGEST) {
+          tooLong = true;
+          pending = '';
+        } else {
+          pending += rest;
+        }
+      }
+      if (read === 0) {
+        if (tooLong) onLine(undefined);
+        else if (pending !== '') onLine(pending);
+        return;
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/** The first line of `file`, read from its start alone; `undefined` for an empty file or a first line too long to hold. */
+export function firstLine(file) {
+  let first;
+  eachLine(file, (line) => {
+    first = line;
+    return true;
+  });
+  return first;
+}

package/src/orca.js

@@ -65,11 +65,25 @@ function ask(args, timeoutMs) {
 
   const answer = parse(asked.stdout);
   if (answer === null || typeof answer !== 'object') {
-    throw new Error(`Orca answered ${args.join(' ')} with something that is not JSON.`);
+    // What Orca did say, so the failure shows its cause (#438): its exit, and
+    // each stream cut short and on one line, so a stack trace in it reads as
+    // text and not as the kit's own.
+    const exit = asked.status ?? `signal ${asked.signal}`;
+    throw new Error(`Orca answered ${args.join(' ')} with something that is not JSON (exit ${exit}; `
+      + `stdout ${said(asked.stdout)}; stderr ${said(asked.stderr)}).`);
   }
   return answer;
 }
 
+/** How much of each of Orca's streams an error carries. */
+const SAID = 500;
+
+/** A stream of Orca's as an error carries it: its lines folded into one, cut short with an ellipsis, in quotes. */
+const said = (text) => {
+  const one = String(text ?? '').trim().replace(/\s*\r?\n\s*/g, ' ⏎ ');
+  return `"${one.length > SAID ? `${one.slice(0, SAID)}…` : one}"`;
+};
+
 function parse(text) {
   try {
     return JSON.parse(text);

package/src/usage.js

@@ -39,11 +39,12 @@
 //      the same call can be in more than one of those files, so a call counts
 //      once across all of a conversation's files together (#371).
 
-import { readFileSync, realpathSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
 
 import { botDir, botNames, readBot } from './bot.js';
 import { readBook, sessionIdsIn } from './book.js';
-import { claudeSubagentTranscripts, codexRollout, transcriptsIn } from './conversations.js';
+import { claudeSubagentTranscripts, claudeTranscriptAnywhere, codexRollout, transcriptsIn } from './conversations.js';
+import { eachLine } from './lines.js';
 import { HARNESSES, harnessOf } from './launch.js';
 
 /** The kinds a call's tokens are reported in, the same on either harness. */
@@ -123,6 +124,20 @@ function forBot(bots, name, onlySession, window) {
 
   const claimed = sessionIdsIn(book);
 
+  // A conversation the book names is its session's wherever the harness filed
+  // it: the book says whose it is (ADR 0012). One filed under another
+  // folder, or whose record cannot be opened to say which folder it ran in, is
+  // found by its id instead, and counted or said to be unreadable (#396).
+  for (const id of claimed) {
+    if (onRecord.has(id)) continue;
+    for (const harness of harnesses) {
+      const file = harness === 'codex' ? codexRollout(id) : harness === 'claude' ? claudeTranscriptAnywhere(id) : undefined;
+      if (file === undefined) continue;
+      onRecord.set(id, { id, file, harness, subagent: false });
+      break;
+    }
+  }
+
   // Two entries can name the same conversation, one resumed after its session
   // was retired, and one entry can name it twice, now and in its history: it is
   // counted once, in the first block asked for that names it.
@@ -190,7 +205,7 @@ function counted(one, window) {
   tally.gaps.unreadable_transcripts += subagents.unreadable;
   const sources = [one.file, ...subagents.files]
     .map((file, index) => {
-      const { entries, unreadable, broken } = transcript(file);
+      const { entries, unreadable, broken } = transcript(file, countable);
       tally.gaps.unreadable_transcripts += unreadable;
       tally.gaps.broken_lines += broken;
       return { entries, subagent: index > 0 };
@@ -463,7 +478,7 @@ function originOf(entries, tally) {
   if (typeof id !== 'string' || id === '') return undefined;
 
   const file = codexRollout(id);
-  const origin = file === undefined ? { unreadable: 1 } : transcript(file);
+  const origin = file === undefined ? { unreadable: 1 } : transcript(file, countable);
   // No `info` is a note about rate limits, not a record of usage.
   const records = origin.unreadable > 0 ? [] : origin.entries
     .filter((entry) => entry.type === 'event_msg' && entry.payload?.type === 'token_count')
@@ -552,28 +567,44 @@ function count(tally, used, model, effort, when, calls = 1, subagent = false) {
 export const lines = (file) => transcript(file).entries;
 
 /**
- * The lines of a transcript that are JSON records, and how many were not. A
- * transcript that cannot be read is said to be, rather than a run that stops.
+ * The records the counting here reads: Claude Code's `assistant` and `system`
+ * lines, Codex's `session_meta`, `turn_context`, `compacted` and `event_msg`.
+ * The rest (what was said, tool calls and their output) is most of a long
+ * conversation's record and none of what it cost, so it is not held (#396).
+ */
+const COUNTED = new Set(['assistant', 'system', 'session_meta', 'turn_context', 'compacted', 'event_msg']);
+const countable = (entry) => COUNTED.has(entry.type);
+
+/**
+ * The lines of a transcript that are JSON records, and how many were not; with
+ * `keep`, only the records it takes. A transcript that cannot be read is said
+ * to be, rather than a run that stops. It is read a line at a time, whatever
+ * its size, and a line too long to hold counts as one that is not a record
+ * (#396).
  */
-function transcript(file) {
-  let text;
+function transcript(file, keep = () => true) {
+  const entries = [];
+  let broken = 0;
   try {
-    text = readFileSync(file, 'utf8');
+    eachLine(file, (line) => {
+      if (line === undefined) {
+        broken += 1;
+        return;
+      }
+      if (line.trim() === '') return;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        broken += 1;
+        return;
+      }
+      if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) broken += 1;
+      else if (keep(entry)) entries.push(entry);
+    });
   } catch {
     return { entries: [], unreadable: 1, broken: 0 };
   }
-  let broken = 0;
-  const entries = text.split('\n').flatMap((line) => {
-    if (line.trim() === '') return [];
-    try {
-      const entry = JSON.parse(line);
-      if (entry !== null && typeof entry === 'object' && !Array.isArray(entry)) return [entry];
-    } catch {
-      // Counted below with any other line that is not a record.
-    }
-    broken += 1;
-    return [];
-  });
   return { entries, unreadable: 0, broken };
 }