mio-agent-runtime 0.11.0 → 0.13.0

package/server/memory-store.js

@@ -29,9 +29,63 @@ function readJsonl(file) {
     .filter(Boolean)
 }
 
+// --- cross-call read cache ------------------------------------------------
+// The MCP server is long-lived and re-reads the same append-only logs on every
+// tool call. On a 1094-record store that is ~7 ms to read+parse memory.jsonl
+// and ~13 ms more to rebuild every record's tokenized haystack -- about 20 ms
+// per query, against ~0.4 ms when both are warm.
+//
+// Validity: (size, mtimeMs) is checked on every call, and every write that goes
+// through appendJsonl/writeJsonl drops the entry explicitly. The one window
+// left is an outside process rewriting a file in the same millisecond to the
+// exact same byte count; the consequence is a single stale query, not corrupt
+// data. `mio prune` (retention.js) now writes through this module's writeJsonl
+// (or calls dropCache directly), so its prunes invalidate the cache explicitly
+// instead of relying on the size check.
+const readCache = new Map()
+
+// Haystacks are memoized against the record objects the cache hands out, so a
+// fresh parse produces fresh objects and rebuilds them. Reassigned (not just
+// cleared) on every write because mergeMemory() mutates `survivor.tags` in
+// place, and tags are part of the haystack -- a WeakMap cannot be cleared, so
+// it is replaced.
+let haystackCache = new WeakMap()
+
+function dropCache(file) {
+  readCache.delete(file)
+  haystackCache = new WeakMap()
+}
+
+function readJsonlCached(file) {
+  let st
+  try {
+    st = fs.statSync(file)
+  } catch (_) {
+    dropCache(file)
+    return []
+  }
+  const hit = readCache.get(file)
+  if (hit !== undefined && hit.size === st.size && hit.mtimeMs === st.mtimeMs) {
+    return hit.records
+  }
+  const records = readJsonl(file)
+  readCache.set(file, { size: st.size, mtimeMs: st.mtimeMs, records })
+  return records
+}
+
+function haystackFor(record) {
+  let hay = haystackCache.get(record)
+  if (hay === undefined) {
+    hay = splitHaystack(`${record.content || ''} ${(record.tags || []).join(' ')} ${record.kind || ''}`)
+    haystackCache.set(record, hay)
+  }
+  return hay
+}
+
 function appendJsonl(file, value) {
   fs.mkdirSync(path.dirname(file), { recursive: true })
   fs.appendFileSync(file, `${JSON.stringify(value)}\n`, 'utf8')
+  dropCache(file)
 }
 
 function writeJsonl(file, values) {
@@ -41,6 +95,7 @@ function writeJsonl(file, values) {
     values.length > 0 ? values.map((value) => JSON.stringify(value)).join('\n') + '\n' : '',
     'utf8'
   )
+  dropCache(file)
 }
 
 // --- Duplicate / quality analysis (mio.memory.analyze) ---------------------
@@ -165,27 +220,60 @@ function cjkBigrams(text) {
   return bigrams
 }
 
+// Split a record's searchable text once. The scorer below used to run four
+// regex passes per record -- [a-z0-9]+ twice (tokenize + latinTokens) and
+// [\u4e00-\u9fff] twice (tokenize + cjkBigrams) -- and materialised a `cjk:`
+// string for every single CJK character, ~1200 allocations for a 600-character
+// record, on every query. One pass that keeps latin words and CJK characters
+// apart is exact: the two token kinds come from disjoint character classes, so
+// looking each up in its own collection scores identically.
+//
+// Measured on the real 1094-record store: 22.05 ms -> 18.16 ms for a full
+// scoring pass (1.21x), with 5470 (record, query) pairs scoring bit-identical.
+const HAYSTACK_PART_RE = /[a-z0-9]+|[\u4e00-\u9fff]/g
+
+function splitHaystack(content) {
+  const parts = String(content || '').toLowerCase().match(HAYSTACK_PART_RE) || []
+  const latin = []
+  const cjkChars = []
+  for (let i = 0; i < parts.length; i += 1) {
+    const part = parts[i]
+    // CJK ideographs are all above U+2000; latin words and digits are not.
+    if (part.charCodeAt(0) > 0x2000) cjkChars.push(part)
+    else latin.push(part)
+  }
+  const cjkSet = new Set(cjkChars)
+  const bigrams = new Set()
+  for (let i = 0; i + 1 < cjkChars.length; i += 1) {
+    bigrams.add(cjkChars[i] + cjkChars[i + 1])
+  }
+  return { latin, cjkSet, bigrams }
+}
+
 function scoreRecord(record, queryText, project, evidence) {
   if (project && record.project && record.project !== project) return 0
-  const content = `${record.content || ''} ${(record.tags || []).join(' ')} ${record.kind || ''}`
-  const haystackTokens = tokenize(content)
-  const haystackLatin = latinTokens(content)
+  // Memoized against the record object itself: see haystackFor above.
+  const hay = haystackFor(record)
   const queryTokens = tokenize(queryText)
   let score = 0
   for (const token of queryTokens) {
-    if (haystackTokens.includes(token)) score += 2
+    if (token.startsWith('cjk:')) {
+      if (hay.cjkSet.has(token.slice(4))) score += 2
+    } else if (hay.latin.includes(token)) {
+      score += 2
+    }
   }
   const queryLatin = queryTokens.filter((token) => !token.startsWith('cjk:'))
   for (const token of queryLatin) {
     if (
       token.length >= 3 &&
-      haystackLatin.some((item) => item.startsWith(token) || token.startsWith(item))
+      hay.latin.some((item) => item.startsWith(token) || token.startsWith(item))
     ) {
       score += 1
     }
   }
   const queryBigrams = cjkBigrams(queryText)
-  const haystackBigrams = cjkBigrams(content)
+  const haystackBigrams = hay.bigrams
   if (queryBigrams.size > 0 && haystackBigrams.size > 0) {
     let matched = 0
     for (const bigram of queryBigrams) {
@@ -255,7 +343,7 @@ function createMemoryStore(options = {}) {
 
   function loadEvidenceWeights() {
     const weights = new Map()
-    for (const record of readJsonl(experienceReusePath)) {
+    for (const record of readJsonlCached(experienceReusePath)) {
       if (!verifiedFilter(record)) continue
       const id = record.experienceId
       if (!id) continue
@@ -286,16 +374,24 @@ function createMemoryStore(options = {}) {
     const scoreFor = (record) =>
       scoreRecord(record, query, project, evidence) +
       (scope === 'all' && isGlobalRecord(record) ? 0.5 : 0)
-    const results = readJsonl(memoryPath)
-      .filter((record) => record.archived !== true)
-      .filter((record) => matchesMemoryFilters(record, kind, tags))
-      .filter((record) => matchesProjectScope(record, project, scope))
-      .filter((record) => scoreFor(record) > 0)
-      .sort((a, b) => {
-        return scoreFor(b) - scoreFor(a)
-      })
+    // Score every candidate exactly once, then sort the scored pairs. Calling
+    // scoreFor() inside the comparator re-ran the whole tokenizer + CJK bigram
+    // scan O(n log n) times instead of O(n): measured on the real 1094-record
+    // store, one query invoked the scorer 6214 times (5.7x) and spent 84 ms of
+    // its 111 ms there. Sorting precomputed pairs is behaviour-identical --
+    // Array#sort is stable, so ties keep their original file order either way.
+    const scored = []
+    for (const record of readJsonlCached(memoryPath)) {
+      if (record.archived === true) continue
+      if (!matchesMemoryFilters(record, kind, tags)) continue
+      if (!matchesProjectScope(record, project, scope)) continue
+      const score = scoreFor(record)
+      if (score > 0) scored.push({ record, score })
+    }
+    const results = scored
+      .sort((a, b) => b.score - a.score)
       .slice(0, limit)
-      .map((record) => {
+      .map(({ record }) => {
         const ev = evidence.get(record.id)
         if (!ev) return record
         return {
@@ -361,7 +457,7 @@ function createMemoryStore(options = {}) {
     const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 200)
     const includePayload = args.include_payload !== false
 
-    const all = readJsonl(tracePath)
+    const all = readJsonlCached(tracePath)
     const matched = all.filter((trace) => {
       if (!trace || typeof trace !== 'object') return false
       if (project && trace.project !== project) return false
@@ -442,7 +538,7 @@ function createMemoryStore(options = {}) {
   function analyzeMemory(args = {}) {
     const project = args.project || projectName()
     const limit = Math.min(Math.max(Number(args.limit) || 5, 1), 20)
-    const records = readJsonl(memoryPath).filter(
+    const records = readJsonlCached(memoryPath).filter(
       (record) => !project || record.project === project || !record.project
     )
     const archived = records.filter((record) => record.archived === true).length
@@ -536,7 +632,7 @@ function createMemoryStore(options = {}) {
     const project = args.project || projectName()
     const reason = args.reason ? String(args.reason).trim().slice(0, 200) : null
 
-    const records = readJsonl(memoryPath)
+    const records = readJsonlCached(memoryPath)
     const idSet = new Set(ids)
     const updated = []
     const unchanged = []
@@ -593,7 +689,7 @@ function createMemoryStore(options = {}) {
     // because "which divergence wins" is then undefined.
     const allowDivergent = args.allowDivergent === true || args.allowDivergent === 'true'
 
-    const records = readJsonl(memoryPath)
+    const records = readJsonlCached(memoryPath)
     const idSet = new Set(ids)
     // The project filter must be applied once, up front. Applying it only in the
     // archive loop let a mismatched project still rewrite the survivor's
@@ -736,7 +832,7 @@ function createMemoryStore(options = {}) {
     const restore = args.restore === true || args.restore === 'true'
     const reason = args.reason ? String(args.reason).trim().slice(0, 200) : null
 
-    const records = readJsonl(memoryPath)
+    const records = readJsonlCached(memoryPath)
     const idSet = new Set(ids)
     const archived = []
     // Ids that exist but are already in the requested state. Reported separately
@@ -795,7 +891,7 @@ function createMemoryStore(options = {}) {
     const reason = args.reason ? String(args.reason).trim().slice(0, 200) : null
     const by = args.by ? String(args.by).trim().slice(0, 80) : null
 
-    const records = readJsonl(memoryPath)
+    const records = readJsonlCached(memoryPath)
     const idSet = new Set(ids)
     const forgotten = []
     const notFound = [...ids]
@@ -875,4 +971,4 @@ function createMemoryStore(options = {}) {
 
 // Module-level exports let sibling stores (e.g. experience-store.js) reuse the
 // same JSONL primitives instead of duplicating them and drifting apart.
-module.exports = { createMemoryStore, createId, readJsonl, appendJsonl, writeJsonl }
+module.exports = { createMemoryStore, createId, readJsonl, readJsonlCached, appendJsonl, writeJsonl }

package/server/mio-intelligence-mcp/index.js

@@ -13,6 +13,7 @@ const { createMemoryStore } = require('../memory-store.js')
 const { createExperienceStore, REUSE_STATUS_FILTERS } = require('../experience-store.js')
 const { createPolicyStore } = require('../policy-store.js')
 const { createAgentStore } = require('../agent-store.js')
+const { createEvaluationStore } = require('../evaluation-store.js')
 const { createTaskStore } = require('../task-store.js')
 const { createQueryLog } = require('../query-log.js')
 const { createSubscriptionStore } = require('../subscription-store.js')
@@ -216,6 +217,10 @@ const { policyCheck } = policyStore
 const agentStore = createAgentStore({ dataDir, projectName })
 const { listAgents, reportAgent, registerAgent } = agentStore
 
+// ADR-017 evaluation metrics, same store the CLI uses (`mio agents evaluation`).
+const evaluationStore = createEvaluationStore({ dataDir, projectName })
+const evaluateAgents = (args) => evaluationStore.evaluate(args)
+
 // task.route delegates to the shared store so the CLI (`mio task route`) and
 // this MCP tool route identically. The MCP keeps feeding the query log
 // (auto-claim depends on it); the CLI passes persistQuery: false.
@@ -541,6 +546,18 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'mio.agent.evaluation',
+    description:
+      'ADR-017 evaluation-period metrics: route adoption rate, behaviour change rate, recall quality, and data hygiene (pending auto-claim ratio). Each metric reports its own denominator, so a null rate means "no samples" rather than "zero".',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        since: { type: 'string', description: 'ISO timestamp; only count records at or after it.' },
+      },
+    },
+  },
   {
     name: 'mio.evolution.report',
     description: 'Generate cross-agent evolution report: ecosystem summary, agent performance comparison, cross-agent patterns, memory health, and optimization suggestions (ADR-017 Evolution plane).',
@@ -843,6 +860,18 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'mio.observer.pipeline',
+    description: 'Run the Observer research DAG (collect -> trend -> tension -> research -> multi-brain -> compose -> world model -> publish). Heavy: network plus several LLM calls. Previews by default; pass run:true to execute.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mode: { type: 'string', description: 'Writing mode: neutral | analytical | creative (default: analytical)' },
+        run: { type: 'boolean', description: 'Execute the pipeline. Default false returns a dry-run plan without network or LLM calls.' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
   {
     name: 'mio.observer.essays',
     description: 'List published or draft essays from the Observer.',
@@ -924,6 +953,10 @@ function observerFerment(args = {}) {
   return observerStore.ferment(args)
 }
 
+function observerPipeline(args = {}) {
+  return observerStore.pipeline(args)
+}
+
 function observerEssays(args = {}) {
   return observerStore.essays(args)
 }
@@ -976,6 +1009,8 @@ async function callTool(name, args = {}) {
       return listAgents(args)
     case 'mio.agent.report':
       return reportAgent(args)
+    case 'mio.agent.evaluation':
+      return evaluateAgents(args)
     case 'mio.evolution.report':
       return evolutionReport(args)
     case 'mio.evolution.status':
@@ -1026,6 +1061,8 @@ async function callTool(name, args = {}) {
       return observerCollect(args)
     case 'mio.observer.ferment':
       return observerFerment(args)
+    case 'mio.observer.pipeline':
+      return observerPipeline(args)
     case 'mio.observer.essays':
       return observerEssays(args)
     case 'mio.observer.dag':

package/server/mio-intelligence-mcp/phase0.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const fs = require('fs')
 const path = require('path')
+const { readJsonlCached } = require('../memory-store.js')
 
 const PHASE0_THRESHOLDS = Object.freeze({
   minHosts: 2,
@@ -55,22 +55,6 @@ function normalizeEventType(value) {
   return eventType || null
 }
 
-function readJsonl(filePath) {
-  if (!fs.existsSync(filePath)) return []
-  return fs
-    .readFileSync(filePath, 'utf8')
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line)
-      } catch (_) {
-        return null
-      }
-    })
-    .filter(Boolean)
-}
-
 function filterByProject(records, project) {
   if (!project) return records
   return records.filter((record) => readString(record, 'project') === project)
@@ -279,9 +263,9 @@ function analyzePhase0(dataset) {
 
 function loadPhase0(dataDir, project) {
   const normalizedProject = project && project.trim() ? project.trim() : undefined
-  const memories = readJsonl(path.join(dataDir, 'memory.jsonl')).map(asRecord).filter(Boolean)
-  const traces = readJsonl(path.join(dataDir, 'traces.jsonl')).map(asRecord).filter(Boolean)
-  const reuseRecords = readJsonl(path.join(dataDir, 'experience_reuse.jsonl'))
+  const memories = readJsonlCached(path.join(dataDir, 'memory.jsonl')).map(asRecord).filter(Boolean)
+  const traces = readJsonlCached(path.join(dataDir, 'traces.jsonl')).map(asRecord).filter(Boolean)
+  const reuseRecords = readJsonlCached(path.join(dataDir, 'experience_reuse.jsonl'))
     .map(asRecord)
     .filter(Boolean)
 

package/server/observer-store.js

@@ -14,6 +14,19 @@
 const fs = require('fs')
 const path = require('path')
 
+// The observer pipeline is one of the LLM users, so it must read the same
+// resolved model configuration as creativity / insight. `isLlmConfigured()`
+// gates the override: when the user never configured an LLM we pass nothing and
+// let @akemi-mio/observer keep its own LLM_* / OBSERVER_* / Ollama fallback, so
+// an existing local-Ollama setup is not silently redirected to the hosted
+// default. This is the D2 fix -- the observer used to hardcode Ollama and
+// ignore `mio config llm` entirely.
+const { llmConfig, isLlmConfigured } = require('./llm-client.js')
+
+function observerLlmConfig() {
+  return isLlmConfigured() ? llmConfig() : undefined
+}
+
 // Observer research pipeline (optional -- installed via @akemi-mio/observer).
 // Loaded lazily at module level so the CLI can report availability without the
 // MCP server having to pass its own handles down.
@@ -31,10 +44,12 @@ function loadObserver() {
 
 let ObserverStore = null
 let ObserverService = null
+let ObserverLlmService = null
 try {
   const obs = loadObserver()
   ObserverStore = obs.ObserverStore
   ObserverService = obs.ObserverService
+  ObserverLlmService = obs.ObserverLlmService
 } catch {}
 
 // Subdirectories that make up the pipeline. `observerStatus` counts files in
@@ -62,6 +77,17 @@ function readJsonSafe(filePath) {
   }
 }
 
+// Today's DAG task id, matching DagStateMachine's `dag_YYYYMMDD` (LOCAL date).
+// Duplicated here rather than importing DagStateMachine because its constructor
+// mkdir's the dag directory, and the dry run below must not touch disk.
+function todayTaskId() {
+  const d = new Date()
+  const y = d.getFullYear()
+  const m = String(d.getMonth() + 1).padStart(2, '0')
+  const day = String(d.getDate()).padStart(2, '0')
+  return `dag_${y}${m}${day}`
+}
+
 function readJsonlSafe(filePath) {
   if (!fs.existsSync(filePath)) return []
   try {
@@ -184,7 +210,7 @@ function createObserverStore(options = {}) {
     // object made path.resolve() throw before any collector ran, so collect()
     // was dead on arrival for every caller. (collectorConfig was never read by
     // the package; it was invented here.)
-    const service = new ObserverService(baseDirOf(args))
+    const service = new ObserverService(baseDirOf(args), observerLlmConfig())
     const sources = args.sources || ['bilibili', 'hackernews', 'github', 'douyin', 'rss']
     const allObs = []
     for (const src of sources) {
@@ -210,7 +236,7 @@ function createObserverStore(options = {}) {
 
   async function ferment(args = {}) {
     if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
-    const service = new ObserverService(baseDirOf(args))
+    const service = new ObserverService(baseDirOf(args), observerLlmConfig())
     const session = args.session || 'afternoon'
     try {
       const fermentation = service.getFermentation()
@@ -221,6 +247,81 @@ function createObserverStore(options = {}) {
     }
   }
 
+  // Drives the full research DAG (collect → trend → tension → research →
+  // multi-brain → compose → world model → publish → self-evolve). This is the
+  // entry point D1 found missing: runPipeline/tickPipeline/forcePipeline had no
+  // caller anywhere in mio-agent-runtime, so trends/research/insights stayed
+  // empty forever unless someone hand-instantiated the service.
+  //
+  // It is heavy (network + several LLM calls) and writes files, so like every
+  // other side-effecting command here it previews by default: without
+  // `run: true` it reads today's DAG state and the resolved LLM endpoint and
+  // returns a plan without constructing the service, which would mkdir the dag
+  // directory. That keeps the README doc gate and the MCP live gate (both call
+  // with empty arguments) offline and instant.
+  async function pipeline(args = {}) {
+    if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
+    const baseDir = baseDirOf(args)
+    const mode = args.mode || 'analytical'
+    const llmConfig = observerLlmConfig()
+
+    if (!args.run) {
+      const taskId = todayTaskId()
+      const dag = readJsonSafe(path.join(baseDir, 'dag', `${taskId}.json`))
+      // Guard the diagnostic: an older published @akemi-mio/observer lacks
+      // ObserverLlmService.getInfo(), and a preview must never throw because of
+      // a package-version skew (the mio-cli side ships ahead of the package).
+      let llm = null
+      if (ObserverLlmService) {
+        try {
+          const svc = new ObserverLlmService(llmConfig)
+          if (svc && typeof svc.getInfo === 'function') llm = svc.getInfo()
+        } catch (_) {
+          llm = null
+        }
+      }
+      return {
+        dryRun: true,
+        baseDir,
+        mode,
+        observerAvailable: true,
+        taskId,
+        todayState: dag ? dag.state : null,
+        todayCompleted: Boolean(dag && dag.state === 'COMPLETED'),
+        llm,
+        hint: 'Re-run with --run (CLI) or {"run": true} (MCP) to execute the full DAG.',
+      }
+    }
+
+    const service = new ObserverService(baseDir, llmConfig)
+    const envelope = await service.forcePipeline(mode)
+    if (!envelope) {
+      return {
+        dryRun: false,
+        baseDir,
+        mode,
+        ran: true,
+        completed: false,
+        reason: 'forcePipeline returned null (today already completed, or a run is in progress)',
+      }
+    }
+    const payload = envelope.payload || {}
+    return {
+      dryRun: false,
+      baseDir,
+      mode,
+      ran: true,
+      completed: envelope.dagState && envelope.dagState.state === 'COMPLETED',
+      type: envelope.type,
+      taskId: envelope.dagState ? envelope.dagState.taskId : null,
+      topic: payload.topic || null,
+      sections: Array.isArray(payload.sections) ? payload.sections.length : 0,
+      insightId: payload.id || null,
+      durationMs: envelope.metadata ? envelope.metadata.taskDurationMs : null,
+      llmCalls: envelope.metadata ? envelope.metadata.llmCalls : null,
+    }
+  }
+
   return {
     baseDir: defaultBaseDir,
     status,
@@ -232,6 +333,7 @@ function createObserverStore(options = {}) {
     dag,
     collect,
     ferment,
+    pipeline,
   }
 }
 

package/server/policy-store.js

@@ -12,7 +12,7 @@
 
 const path = require('path')
 
-const { readJsonl } = require('./memory-store.js')
+const { readJsonlCached } = require('./memory-store.js')
 
 // Outcomes that count against an action. `retry` is included because a retried
 // action is evidence the first attempt did not simply work.
@@ -139,7 +139,7 @@ function createPolicyStore(options = {}) {
     if (!action) throw new Error('policy.check requires action')
     const project = args.project || projectName()
     const actionTokens = tokenize(action)
-    const allTraces = readJsonl(tracePath)
+    const allTraces = readJsonlCached(tracePath)
     const scopedTraces = allTraces.filter(
       (event) => !(project && event.project && event.project !== project)
     )
@@ -186,7 +186,7 @@ function createPolicyStore(options = {}) {
       suggestion = 'Low historical risk. Proceed with normal checks.'
     }
     const evidence = loadEvidenceWeights()
-    const relatedMemories = readJsonl(memoryPath)
+    const relatedMemories = readJsonlCached(memoryPath)
       .filter((record) => scoreRecord(record, action, project, evidence) > 0)
       .sort(
         (a, b) => scoreRecord(b, action, project, evidence) - scoreRecord(a, action, project, evidence)

package/server/query-log.js

@@ -12,9 +12,8 @@
 // mio-intelligence-mcp/index.js, one in task-store.js -- which had to be kept
 // equivalent by hand.
 
-const fs = require('fs')
 const path = require('path')
-const { readJsonl } = require('./memory-store.js')
+const { readJsonlCached, writeJsonl } = require('./memory-store.js')
 
 const MAX_RECENT_QUERIES = 200
 
@@ -31,7 +30,7 @@ function createQueryLog(options = {}) {
 
   function load() {
     const now = Date.now()
-    return readJsonl(queryPath)
+    return readJsonlCached(queryPath)
       .filter(
         (entry) =>
           entry &&
@@ -45,12 +44,7 @@ function createQueryLog(options = {}) {
 
   function persist(entries) {
     const limited = entries.slice(-MAX_RECENT_QUERIES)
-    fs.mkdirSync(dataDir, { recursive: true })
-    fs.writeFileSync(
-      queryPath,
-      limited.length > 0 ? limited.map((entry) => JSON.stringify(entry)).join('\n') + '\n' : '',
-      'utf8'
-    )
+    writeJsonl(queryPath, limited)
     return limited
   }
 

package/server/retention.js

@@ -8,6 +8,7 @@
 
 const fs = require('fs')
 const path = require('path')
+const { writeJsonl } = require('./memory-store.js')
 
 // Age-based JSONL stores (records carry an ISO `timestamp` field).
 const AGE_BASED_FILES = ['traces.jsonl', 'experience_reuse.jsonl']
@@ -41,15 +42,6 @@ function createRetention(options = {}) {
     return backup
   }
 
-  function writeJsonl(file, values) {
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    fs.writeFileSync(
-      file,
-      values.length > 0 ? values.map((value) => JSON.stringify(value)).join('\n') + '\n' : '',
-      'utf8'
-    )
-  }
-
   function planAgeBased(name, cutoff) {
     const file = path.join(home, name)
     const records = readJsonl(file)