mio-agent-runtime 0.11.0 → 0.12.0

package/observe/observer.js

@@ -39,8 +39,19 @@ function cleanText(text) {
 function projectFromDirName(dirName) {
   // WorkBuddy project dirs encode the workspace path with dashes, e.g.
   // "d-work-code-douyin_store" -> "douyin_store"
+  //
+  // Hosts that munge a timestamped workspace path produce a trailing numeric
+  // segment, e.g. "c-Users-me-WorkBuddy-2026-08-27-17-37-10" -> "10". Using
+  // the seconds field as a project name funnels unrelated sessions into
+  // colliding 2-digit buckets that recall never resolves to, so fall back to
+  // the whole directory name in that case.
+  //
+  // ⚠️ The test must be /^\d+$/ (one backslash). An earlier revision wrote
+  // /^\\d+$/ -- that matches a literal backslash followed by "d", so it never
+  // fires and every numeric segment becomes the project (fixed 2026-09-20).
+  // Keep the escaping as-is; do not "tidy" it into a double backslash.
   const parts = String(dirName || '').split('-').filter(Boolean)
-  if (parts.length > 1 && /^\\d+$/.test(parts[parts.length - 1])) {
+  if (parts.length > 1 && /^\d+$/.test(parts[parts.length - 1])) {
     return dirName || 'unknown'
   }
   return parts.length > 1 ? parts[parts.length - 1] : dirName || 'unknown'
@@ -689,9 +700,20 @@ function opencodeDbPath() {
   return path.join(opencodeDataDir(), 'opencode.db')
 }
 
+// Resolved once per observer process: the bin does not move mid-run, and
+// re-running `where`/`which` on every query doubled the subprocess count of
+// every cycle for zero information. Re-resolves only when the cached path
+// vanishes from disk. A null result is deliberately NOT cached so an opencode
+// installed mid-run is still picked up.
+let resolvedOpencodeBin
+
 function findOpencodeBin() {
+  if (resolvedOpencodeBin && fs.existsSync(resolvedOpencodeBin)) {
+    return resolvedOpencodeBin
+  }
   if (process.env.OPENCODE_BIN && fs.existsSync(process.env.OPENCODE_BIN)) {
-    return process.env.OPENCODE_BIN
+    resolvedOpencodeBin = process.env.OPENCODE_BIN
+    return resolvedOpencodeBin
   }
   const exeDir = path.dirname(process.execPath)
   const candidates = [
@@ -708,18 +730,51 @@ function findOpencodeBin() {
   // stray files (e.g. "WHERE p.rowid > 0" -> a file named "0").
   try {
     const finder = process.platform === 'win32' ? 'where' : 'which'
-    const res = spawnSync(finder, ['opencode'], { encoding: 'utf8', windowsHide: true, timeout: 15000 })
+    // stdio[0] must not be a pipe: a piped stdin makes spawnSync fail with
+    // EBUSY before the child starts (status null, empty stderr), which would
+    // read as "opencode is not on PATH". `where` reads no stdin.
+    const res = spawnSync(finder, ['opencode'], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 15000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
     if (res.status === 0 && res.stdout) {
       const lines = res.stdout
         .split(/\r?\n/)
         .map((s) => s.trim())
         .filter(Boolean)
+      // ⚠️ Known dead end on Windows, recorded by decision rather than "fixed"
+      // (measured 2026-09-24). This filter prefers .cmd/.bat, but
+      // runOpencodeQuery() spawns the result WITHOUT shell:true, and Node
+      // refuses to spawn a .cmd/.bat without a shell:
+      //
+      //   spawn opencode.cmd   no shell    status=null  error=EINVAL
+      //   spawn opencode.cmd   shell:true  status=0     stdout="1.15.12"
+      //
+      // So when the only thing on PATH is an npm shim (e.g. `opencode.cmd`),
+      // findOpencodeBin() returns a path that can never be executed, every
+      // query below returns null, and the opencode observer silently ingests
+      // nothing. On a machine where `where opencode` yields only `opencode`
+      // and `opencode.cmd`, neither is spawnable without a shell.
+      //
+      // Adding shell:true is NOT the fix: cmd.exe would then parse '>' in the
+      // SQL as output redirection, which is precisely what the comment above
+      // this block exists to prevent. The two constraints really do conflict.
+      //
+      // Net behaviour is identical either way (null before and after), so it is
+      // left alone. The bundled opencode-ai .exe path above is unaffected and
+      // does work. If you change this, write the test that proves the payload
+      // survives -- not just that status === 0.
       const preferred =
         process.platform === 'win32'
           ? lines.filter((p) => /\.(exe|cmd|bat)$/i.test(p))
           : lines
       const first = (preferred.length > 0 ? preferred : lines).find((p) => fs.existsSync(p))
-      if (first) return first
+      if (first) {
+        resolvedOpencodeBin = first
+        return first
+      }
     }
   } catch (_) {}
   return null
@@ -733,7 +788,15 @@ function runOpencodeQuery(sql) {
   const args = ['db', sql, '--format', 'json']
   let res
   try {
-    res = spawnSync(bin, args, { encoding: 'utf8', timeout: 90000, windowsHide: true, maxBuffer: 256 * 1024 * 1024 })
+    // stdio[0] must not be a pipe: see findOpencodeBin above. `opencode db`
+    // takes its SQL as an argument and reads no stdin.
+    res = spawnSync(bin, args, {
+      encoding: 'utf8',
+      timeout: 90000,
+      windowsHide: true,
+      maxBuffer: 256 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
   } catch (_) {
     return null
   }
@@ -938,16 +1001,20 @@ function runOpencodeCycle(home, state, sinks, opts) {
   const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
 
   // First run: seed the rowid cursor to the first part written within the
-  // backfill window so ancient history never floods MIO_HOME.
+  // backfill window so ancient history never floods MIO_HOME. One round trip:
+  // the scalar subselects return NULL for first_rid when nothing was written
+  // inside the window, which maps to the same "fall back to MAX(rowid)" branch
+  // the previous two-query version had.
   if (!state.ocSeeded) {
     const ts = Date.now() - maxAgeMs
-    const first = runOpencodeQuery('SELECT rowid FROM part WHERE time_created >= ' + ts + ' ORDER BY rowid LIMIT 1')
+    const seed = runOpencodeQuery(
+      'SELECT (SELECT rowid FROM part WHERE time_created >= ' + ts + ' ORDER BY rowid LIMIT 1) AS first_rid, ' +
+        '(SELECT COALESCE(MAX(rowid), 0) FROM part) AS max_rid'
+    )
     let rid = 0
-    if (Array.isArray(first) && first.length > 0) {
-      rid = Number(first[0].rowid) || 0
-    } else {
-      const maxRow = runOpencodeQuery('SELECT COALESCE(MAX(rowid), 0) AS rid FROM part')
-      if (Array.isArray(maxRow) && maxRow.length > 0) rid = Number(maxRow[0].rid) || 0
+    if (Array.isArray(seed) && seed.length > 0) {
+      const firstRid = Number(seed[0].first_rid)
+      rid = Number.isFinite(firstRid) && firstRid > 0 ? firstRid : Number(seed[0].max_rid) || 0
     }
     state.ocLastRowid = rid
     state.ocSeeded = true
@@ -1703,4 +1770,7 @@ module.exports = {
   stopBackground,
   isRunning,
   readPid,
+  // exported for tests: the numeric-segment guard here was silently dead for
+  // several releases because nothing exercised it (see __tests__/observer-project.test.js)
+  projectFromDirName,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",

package/scripts/check-syntax.cjs

@@ -52,8 +52,22 @@ if (files.length === 0) {
 
 const failures = []
 for (const file of files) {
-  const result = spawnSync(process.execPath, ['--check', file], { encoding: 'utf8' })
-  if (result.status !== 0) {
+  // stdio[0] must not be a pipe. On Windows a piped stdin makes spawnSync fail
+  // with EBUSY before the child starts: status is null and stderr is empty, so
+  // every file reads as a syntax error and this gate is red 100% of the time.
+  // `node --check` never reads stdin, so 'ignore' costs nothing.
+  const result = spawnSync(process.execPath, ['--check', file], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  // "the checker did not run" and "the file does not parse" must stay separate:
+  // collapsing them is how a dead gate gets mistaken for a broken codebase.
+  if (result.error) {
+    failures.push({
+      file,
+      message: `could not run the syntax checker: ${result.error.code || result.error.message}`,
+    })
+  } else if (result.status !== 0) {
     failures.push({ file, message: (result.stderr || '').trim().split('\n')[0] })
   }
 }

package/server/agent-store.js

@@ -13,7 +13,7 @@
 // agents.jsonl. `mio agents list` / `report` are about the latter.
 
 const path = require('path')
-const { createId, readJsonl, appendJsonl, writeJsonl } = require('./memory-store.js')
+const { createId, readJsonlCached, appendJsonl, writeJsonl } = require('./memory-store.js')
 
 function createAgentStore(options) {
   const dataDir = options.dataDir
@@ -26,7 +26,7 @@ function createAgentStore(options) {
 
   function listAgents(args = {}) {
     const project = args.project || null
-    let agents = readJsonl(agentsPath)
+    let agents = readJsonlCached(agentsPath)
     if (project) agents = agents.filter((a) => a.project === project)
     return {
       count: agents.length,
@@ -49,13 +49,13 @@ function createAgentStore(options) {
   function reportAgent(args = {}) {
     const targetAgent = args.agentId || null
     const project = args.project || projectName()
-    const agents = readJsonl(agentsPath)
+    const agents = readJsonlCached(agentsPath)
     const filtered = agents.filter(
       (a) => (!targetAgent || a.agentId === targetAgent) && (!project || a.project === project)
     )
-    const traces = readJsonl(tracePath)
-    const memories = readJsonl(memoryPath)
-    const reuses = readJsonl(experienceReusePath)
+    const traces = readJsonlCached(tracePath)
+    const memories = readJsonlCached(memoryPath)
+    const reuses = readJsonlCached(experienceReusePath)
     const reports = filtered.map((agent) => {
       const agentTraces = traces.filter((t) => t.agent === agent.agentId)
       const outcomes = agentTraces.filter((t) => t.event_type === 'task_outcome')
@@ -101,7 +101,7 @@ function createAgentStore(options) {
     const hostType = args.hostType || 'mcp'
     const capabilities = Array.isArray(args.capabilities) ? args.capabilities : []
     const now = new Date().toISOString()
-    const agents = readJsonl(agentsPath)
+    const agents = readJsonlCached(agentsPath)
     const existing = agents.find((a) => a.agentId === agentId && a.project === project)
     let result
     if (existing) {

package/server/digest.js

@@ -7,22 +7,7 @@
 
 const fs = require('fs')
 const path = require('path')
-
-function readJsonl(file) {
-  if (!fs.existsSync(file)) return []
-  return fs
-    .readFileSync(file, 'utf8')
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line)
-      } catch (_) {
-        return null
-      }
-    })
-    .filter(Boolean)
-}
+const { readJsonlCached } = require('./memory-store.js')
 
 function isVerifiedReuse(record) {
   return (
@@ -42,7 +27,7 @@ function createDigest(options = {}) {
     const atTime = now()
     const cutoff = atTime - days * 86400000
 
-    const traces = readJsonl(path.join(home, 'traces.jsonl')).filter((trace) => {
+    const traces = readJsonlCached(path.join(home, 'traces.jsonl')).filter((trace) => {
       if (!trace || typeof trace !== 'object') return false
       const ts = Date.parse(trace.timestamp || '')
       if (!(Number.isFinite(ts) && ts >= cutoff)) return false
@@ -126,7 +111,7 @@ function createDigest(options = {}) {
       .sort((a, b) => b.tasks - a.tasks)
 
     // --- reuse evidence ---
-    const reuseRecords = readJsonl(path.join(home, 'experience_reuse.jsonl')).filter((record) => {
+    const reuseRecords = readJsonlCached(path.join(home, 'experience_reuse.jsonl')).filter((record) => {
       if (!record || typeof record !== 'object') return false
       if (project && record.project !== project) return false
       const ts = Date.parse(record.timestamp || '')

package/server/evaluation-store.js

@@ -0,0 +1,244 @@
+'use strict'
+
+// ADR-017 evaluation-period metrics: the numbers that decide whether the Agent
+// Control Plane keeps expanding (`agent.register` / `agent.list` /
+// `agent.report` are already authorised) or the whole direction gets rolled
+// back. The ADR names four, and until now none of them had an implementation:
+// a grep for adoptionRate / behaviorChangeRate / recallQuality / routingAccuracy
+// across the CLI returned zero hits. The evaluation period was therefore
+// running on a checklist a human had to tally by hand, which is exactly the
+// kind of thing that silently stops happening.
+//
+// The four metrics, verbatim from the ADR, and how each is computed here:
+//
+//   1. 路由采纳率 (route adoption rate)
+//        "task.route 命中且被采纳的次数 / 调用次数"
+//      Denominator: `queries.jsonl` entries that carried at least one route
+//      result (i.e. routes.length > 0 -- a "hit"). Numerator: those that can be
+//      linked to a reuse record. A hit that nobody acts on is not adoption, so
+//      only routes with a correlating reuse count.
+//
+//   2. 行为改变率 (behavior change rate)
+//        "confirmed（behaviorChanged=true）数量变化"
+//      Numerator: reuse records with behaviorChanged=true and confirmed=true.
+//      Denominator: all reuse records. Kept separate from `verified` (which
+//      additionally requires outcomeImproved) because the ADR asks about the
+//      behaviour change specifically, not its benefit.
+//
+//   3. 召回质量 (recall quality)
+//        "scope=all 与混合检索是否减少无效探索"
+//      Proxied by query yield: of the queries that returned results, how many
+//      led to a confirmed reuse. A high-miss recall path shows up as a low
+//      yield and an `emptyQueryRate`, which is the "无效探索" the ADR asks about.
+//
+//   4. 数据卫生 (data hygiene)
+//        "pending auto-claim 噪声占比是否随确认纪律下降"
+//      `pendingAutoClaims / total` -- the share of reuse records that are
+//      unconfirmed auto-claims. These are invisible dead weight: they never
+//      feed ranking or routing, so a rising ratio means the confirmation
+//      discipline is slipping.
+//
+// ⚠️ TWO OF THESE METRICS READ A BUFFER THAT IS EMPTY BY DESIGN.
+//
+// Metrics 1 and 3 are derived from `queries.jsonl`, which is not an evaluation
+// log: it is the auto-claim correlation buffer (see ../query-log.js), holding
+// at most 200 entries and pruning anything past a 1-hour `expiresAt` window
+// (retention.js lists it under EXPIRY_BASED_FILES). Measured against the real
+// dataset on 2026-09-20: queries.jsonl was 0 bytes while traces.jsonl held 764
+// task_outcomes and experience_reuse.jsonl held 21 records. So in practice
+// these two metrics report "no data" almost always -- not because routing is
+// unused, but because its evidence deliberately does not survive.
+//
+// That is a real limitation of the metric definitions, not of the data, and it
+// is reported rather than hidden: `sources` below names each metric's backing
+// file and whether that file is durable, so a reader can tell "route adoption
+// is 0%" from "route adoption cannot be measured from what we keep".
+//
+// Everything is read-only. Each metric reports its own denominator so a caller
+// can tell "0%" from "no data at all" -- reporting a confident 0% on zero
+// samples is the failure mode this repo keeps rediscovering.
+
+const path = require('path')
+const { readJsonl } = require('./memory-store.js')
+const { REUSE_STATUS_FILTERS } = require('./experience-store.js')
+const { REUSE_MATCH_WINDOW_MS } = require('./query-log.js')
+
+// Reported so the client can say "this number is windowed to the last N
+// minutes". Read from the query log itself rather than hardcoded, so a change
+// to the auto-claim window cannot leave this description stale.
+const QUERY_BUFFER_MINUTES = Math.round(REUSE_MATCH_WINDOW_MS / 60000)
+
+// The ADR frames the whole evaluation period as a comparison against the Phase 0
+// baseline, and states it in its own line:
+//
+//   "对照 Phase 0 基线 2026-08-17：hosts 3/2、tasks 176/20、verified 6/5、
+//    improved 30/1"
+//
+// Each pair is `observed / threshold`, which the Phase 0 implementation
+// confirms: phase0.js declares thresholds {minHosts:2, minTaskOutcomes:20,
+// minVerifiedReuse:5, minImprovementEvidence:1} and renders them as
+// `current/required` (phase0.js:313). So `verified 6/5` means verified=6
+// against a required 5 -- passing, with one to spare.
+//
+// Without this the metrics report bare numbers with no reference point, and a
+// regression like verified 6 -> 0 reads as an unremarkable "0" instead of a
+// gate that used to pass and no longer does. Measured 2026-09-20: verified is
+// in fact 0.
+//
+// The keys match phase0's `criteria[].key` values so the two reports can be
+// read side by side.
+const PHASE0_BASELINE = Object.freeze({
+  date: '2026-08-17',
+  source: 'docs/adr-017-mio-agent-control-plane.md',
+  values: Object.freeze({
+    hosts: Object.freeze({ observed: 3, required: 2 }),
+    tasks: Object.freeze({ observed: 176, required: 20 }),
+    verified_reuse: Object.freeze({ observed: 6, required: 5 }),
+    measurable_improvement: Object.freeze({ observed: 30, required: 1 }),
+  }),
+})
+
+function ratio(numerator, denominator) {
+  return denominator > 0 ? Math.round((numerator / denominator) * 100) : null
+}
+
+function createEvaluationStore(options = {}) {
+  const dataDir = options.dataDir
+  const projectName = options.projectName || (() => null)
+
+  const queryPath = path.join(dataDir, 'queries.jsonl')
+  const reusePath = path.join(dataDir, 'experience_reuse.jsonl')
+  const tracePath = path.join(dataDir, 'traces.jsonl')
+  const agentsPath = path.join(dataDir, 'agents.jsonl')
+
+  // The query log prunes itself by expiresAt, but for an evaluation window we
+  // want the historical record, so read the file directly rather than through
+  // query-log.js (whose `load()` deliberately drops expired entries).
+  function readQueries(project) {
+    const entries = readJsonl(queryPath).filter((entry) => entry && typeof entry === 'object')
+    if (!project) return entries
+    return entries.filter((entry) => !entry.project || entry.project === project)
+  }
+
+  function evaluate(args = {}) {
+    const project = args.project || projectName()
+    const since = args.since ? Date.parse(args.since) : null
+    const inWindow = (record) => {
+      if (!Number.isFinite(since)) return true
+      const ts = Date.parse(record.timestamp || '')
+      return Number.isFinite(ts) && ts >= since
+    }
+
+    const queries = readQueries(project).filter(inWindow)
+    const reuses = readJsonl(reusePath).filter(
+      (r) => r && inWindow(r) && (!project || !r.project || r.project === project)
+    )
+    const traces = readJsonl(tracePath).filter(
+      (t) => t && inWindow(t) && (!project || !t.project || t.project === project)
+    )
+    const agents = readJsonl(agentsPath).filter(
+      (a) => a && (!project || !a.project || a.project === project)
+    )
+
+    // ---- 1. route adoption rate -------------------------------------------
+    // A query entry is a "route hit" when it came back with at least one result
+    // id to act on. `resultSources` marks which of those came from a verified
+    // experience rather than a plain memory.
+    const routeHits = queries.filter(
+      (q) => Array.isArray(q.resultIds) && q.resultIds.length > 0
+    )
+    const experienceHits = queries.filter(
+      (q) => Array.isArray(q.resultSources) && q.resultSources.some((s) => s === 'experience')
+    )
+    // Adoption: a route hit whose experience was subsequently reused. Correlate
+    // on experienceId, which both the route result and the reuse record carry.
+    const reusedIds = new Set(reuses.map((r) => r.experienceId).filter(Boolean))
+    const adopted = experienceHits.filter((q) =>
+      (q.resultIds || []).some((id) => reusedIds.has(id))
+    )
+
+    // ---- 2. behaviour change rate -----------------------------------------
+    const behaviorChanged = reuses.filter(
+      (r) => r.confirmed === true && (r.behaviorChanged === true || r.behaviorChanged === 'true')
+    )
+    const verified = reuses.filter(REUSE_STATUS_FILTERS.verified)
+
+    // ---- 3. recall quality -------------------------------------------------
+    const withResults = queries.filter((q) => (q.resultIds || []).length > 0)
+    const linkedToReuse = withResults.filter((q) =>
+      (q.resultIds || []).some((id) => reusedIds.has(id))
+    )
+    const emptyQueries = queries.filter((q) => (q.resultIds || []).length === 0)
+
+    // ---- 4. data hygiene ---------------------------------------------------
+    const pendingAutoClaims = reuses.filter(REUSE_STATUS_FILTERS.pending)
+
+    const outcomes = traces.filter((t) => t.event_type === 'task_outcome')
+    const successes = outcomes.filter((t) => t.outcome === 'success').length
+    const failures = outcomes.filter((t) => t.outcome === 'failure').length
+
+    return {
+      project,
+      since: args.since || null,
+      // Which file each metric is derived from, and whether that file survives.
+      // Metrics 1 and 3 depend on a 1-hour buffer, so their denominators decay
+      // to zero on their own; without this a reader cannot tell an unused
+      // feature from an unmeasurable one.
+      sources: {
+        routeAdoption: { file: 'queries.jsonl', durable: false, windowMinutes: QUERY_BUFFER_MINUTES },
+        behaviorChange: { file: 'experience_reuse.jsonl', durable: true },
+        recallQuality: { file: 'queries.jsonl', durable: false, windowMinutes: QUERY_BUFFER_MINUTES },
+        dataHygiene: { file: 'experience_reuse.jsonl', durable: true },
+      },
+      // The Phase 0 reference point the ADR asks these numbers to be read
+      // against. Reported verbatim, with no interpretation folded in -- a
+      // caller compares `behaviorChange.verified` to
+      // `baseline.values.verified_reuse.observed` itself. Deliberately NOT
+      // merged into the metrics above: the baseline was measured on different
+      // record shapes, so silently differencing them would be another confident
+      // number with a shaky basis.
+      baseline: PHASE0_BASELINE,
+      sample: {
+        queries: queries.length,
+        routeHits: routeHits.length,
+        reuses: reuses.length,
+        traces: traces.length,
+        agents: agents.length,
+        taskOutcomes: outcomes.length,
+      },
+      routeAdoption: {
+        routeHits: experienceHits.length,
+        adopted: adopted.length,
+        rate: ratio(adopted.length, experienceHits.length),
+      },
+      behaviorChange: {
+        confirmed: behaviorChanged.length,
+        verified: verified.length,
+        total: reuses.length,
+        rate: ratio(behaviorChanged.length, reuses.length),
+      },
+      recallQuality: {
+        queriesWithResults: withResults.length,
+        queriesLinkedToReuse: linkedToReuse.length,
+        emptyQueries: emptyQueries.length,
+        emptyQueryRate: ratio(emptyQueries.length, queries.length),
+        yield: ratio(linkedToReuse.length, withResults.length),
+      },
+      dataHygiene: {
+        pendingAutoClaims: pendingAutoClaims.length,
+        total: reuses.length,
+        pendingRatio: ratio(pendingAutoClaims.length, reuses.length),
+      },
+      taskOutcomes: {
+        total: outcomes.length,
+        success: successes,
+        failure: failures,
+        successRate: ratio(successes, outcomes.length),
+      },
+    }
+  }
+
+  return { evaluate }
+}
+
+module.exports = { createEvaluationStore }

package/server/evolution-report.js

@@ -7,8 +7,8 @@
 // its data directory from MIO_DATA_DIR while the CLI uses MIO_HOME, and each has
 // its own projectName() -- so this module owns no path or environment policy.
 
-const fs = require('fs')
 const path = require('path')
+const { readJsonlCached } = require('./memory-store.js')
 
 const REPORT_FILES = {
   memory: 'memory.jsonl',
@@ -17,22 +17,6 @@ const REPORT_FILES = {
   agent: 'agents.jsonl',
 }
 
-function readJsonl(file) {
-  if (!fs.existsSync(file)) return []
-  return fs
-    .readFileSync(file, 'utf8')
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line)
-      } catch (_) {
-        return null
-      }
-    })
-    .filter(Boolean)
-}
-
 const PERIOD_MS = {
   '24h': 86400000,
   '7d': 604800000,
@@ -65,10 +49,10 @@ function createEvolutionReport({ dataDir, projectName }) {
     const periodMs = PERIOD_MS[period] === undefined ? Infinity : PERIOD_MS[period]
     const cutoff = periodMs === Infinity ? 0 : now - periodMs
 
-    const memories = readJsonl(files.memory).filter((m) => !project || m.project === project || !m.project)
-    const traces = readJsonl(files.trace).filter((t) => !project || t.project === project)
-    const reuses = readJsonl(files.reuse).filter((r) => !project || r.project === project)
-    const agents = readJsonl(files.agent).filter((a) => !project || a.project === project)
+    const memories = readJsonlCached(files.memory).filter((m) => !project || m.project === project || !m.project)
+    const traces = readJsonlCached(files.trace).filter((t) => !project || t.project === project)
+    const reuses = readJsonlCached(files.reuse).filter((r) => !project || r.project === project)
+    const agents = readJsonlCached(files.agent).filter((a) => !project || a.project === project)
 
     const filteredTraces = cutoff ? traces.filter((t) => new Date(t.timestamp).getTime() >= cutoff) : traces
     const filteredMemories = cutoff ? memories.filter((m) => new Date(m.timestamp).getTime() >= cutoff) : memories

package/server/experience-store.js

@@ -12,7 +12,7 @@
 // unconfirmed auto-claims are otherwise invisible dead weight.
 
 const path = require('path')
-const { createId, readJsonl, appendJsonl, writeJsonl } = require('./memory-store.js')
+const { createId, readJsonlCached, appendJsonl, writeJsonl } = require('./memory-store.js')
 
 const REUSE_STATUS_FILTERS = Object.freeze({
   pending: (record) => record.source === 'auto_claim' && record.confirmed !== true,
@@ -64,7 +64,7 @@ function createExperienceStore(options = {}) {
     const targetAgent = String(args.targetAgent || '').trim().toLowerCase()
     const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100)
 
-    let records = readJsonl(experiencePath)
+    let records = readJsonlCached(experiencePath)
     if (project) records = records.filter((record) => record.project === project)
     if (targetAgent) {
       records = records.filter(
@@ -116,7 +116,7 @@ function createExperienceStore(options = {}) {
     const confirmedBy = String(args.confirmedBy || 'agent').trim() || 'agent'
     const notes = args.notes ? String(args.notes).trim() : null
 
-    const records = readJsonl(experiencePath)
+    const records = readJsonlCached(experiencePath)
     const confirmedIds = []
     const confirmedRecords = []
     const notFound = []