agenr 0.9.81 → 0.9.83

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.9.83] - 2026-03-08
+
+### Fixed
+
+- Hardened OpenClaw session-start startup reads by preserving the `initDbForStartupReads` export in test mocks, updating startup-read assertion shapes to match the current read-safe API, aligning deferred handoff timing coverage with the current lifecycle, and eliminating a real startup PRAGMA vs `BEGIN IMMEDIATE` contention race in regression coverage.
+
+## [0.9.82] - 2026-03-08
+
+### Added
+
+- Added a GitHub Actions `Validate` workflow that runs on pull requests and `master` pushes, installs dependencies, runs `pnpm typecheck`, and then runs the full `pnpm check` gate.
+
+### Changed
+
+- Documented `pnpm check` as the canonical local validation command and called out `pnpm typecheck` as the minimum fast sanity check before trusting passing tests.
+- Hardened update-path validation and regression coverage so validation-gate checks no longer depend on ambient host project config or local previous-session state.
+
 ## [0.9.81] - 2026-03-08
 
 ### Added

package/dist/{chunk-CEPFOYOL.js → chunk-E4QJJSZI.js}

@@ -37,7 +37,7 @@ import {
   toErrorMessage,
   updateRecallMetadata,
   walCheckpoint
-} from "./chunk-3NGXMER3.js";
+} from "./chunk-LXLOBT4V.js";
 import {
   toNumber,
   toRowsAffected,
@@ -6716,8 +6716,10 @@ async function runStoreService(request, deps) {
         dedupThreshold: dedupThreshold ?? configDedupThreshold,
         llmClient,
         claimExtractionEnabled,
+        skipClaimExtraction: request.skipClaimExtraction === true,
         claimExtractionModel,
         contradictionEnabled,
+        skipContradiction: request.skipContradiction === true,
         config: config ?? void 0,
         dbPath,
         sourceFile: batch.sourceFile,

package/dist/{chunk-3NGXMER3.js → chunk-LXLOBT4V.js}

@@ -2507,7 +2507,18 @@ var walInitByClient = /* @__PURE__ */ new WeakMap();
 var didWarnVectorIndexCorruption = false;
 var WAL_CHECKPOINT_MAX_ATTEMPTS = 5;
 var WAL_CHECKPOINT_RETRY_MS = 50;
+var DEFAULT_BUSY_TIMEOUT_MS = 3e3;
 var log = createLogger("db");
+async function awaitClientStartupPragmas(client, options = {}) {
+  const walInit = walInitByClient.get(client);
+  if (!walInit) {
+    return;
+  }
+  await walInit;
+  if (options.setWalAutoCheckpoint === true) {
+    await client.execute("PRAGMA wal_autocheckpoint=1000");
+  }
+}
 function resolveDbPath(dbPath) {
   if (dbPath === ":memory:") {
     return dbPath;
@@ -2539,8 +2550,10 @@ function buildBackupPath(dbPath) {
     `${path4.basename(resolvedDbPath)}.backup-pre-reset-${timestamp2}Z`
   );
 }
-function getDb(dbPath) {
+function getDb(dbPath, options = {}) {
   const rawPath = dbPath?.trim() ? dbPath.trim() : DEFAULT_DB_PATH;
+  const busyTimeoutMs = Number.isFinite(options.busyTimeoutMs) ? Math.max(0, Math.floor(options.busyTimeoutMs)) : DEFAULT_BUSY_TIMEOUT_MS;
+  const ensureWalMode = options.ensureWalMode !== false;
   if (rawPath === ":memory:") {
     return createClient({ url: ":memory:" });
   }
@@ -2548,7 +2561,12 @@ function getDb(dbPath) {
     const client2 = createClient({ url: rawPath });
     walInitByClient.set(
       client2,
-      client2.execute("PRAGMA journal_mode=WAL").then(() => client2.execute("PRAGMA busy_timeout=3000")).then(() => void 0)
+      (async () => {
+        if (ensureWalMode) {
+          await client2.execute("PRAGMA journal_mode=WAL");
+        }
+        await client2.execute(`PRAGMA busy_timeout=${busyTimeoutMs}`);
+      })()
     );
     return client2;
   }
@@ -2556,7 +2574,12 @@ function getDb(dbPath) {
   const client = createClient({ url: `file:${resolvedPath}` });
   walInitByClient.set(
     client,
-    client.execute("PRAGMA journal_mode=WAL").then(() => client.execute("PRAGMA busy_timeout=3000")).then(() => void 0)
+    (async () => {
+      if (ensureWalMode) {
+        await client.execute("PRAGMA journal_mode=WAL");
+      }
+      await client.execute(`PRAGMA busy_timeout=${busyTimeoutMs}`);
+    })()
   );
   return client;
 }
@@ -2622,12 +2645,11 @@ async function checkAndRecoverBulkIngest(client) {
     throw error;
   }
 }
+async function initDbForStartupReads(client) {
+  await awaitClientStartupPragmas(client);
+}
 async function initDb(client, opts) {
-  const walInit = walInitByClient.get(client);
-  if (walInit) {
-    await walInit;
-    await client.execute("PRAGMA wal_autocheckpoint=1000");
-  }
+  await awaitClientStartupPragmas(client, { setWalAutoCheckpoint: true });
   await initSchema(client);
   if (opts?.checkBulkRecovery === true) {
     try {
@@ -2641,23 +2663,25 @@ async function initDb(client, opts) {
       );
     }
   }
-  try {
-    const hasEntries = await client.execute(
-      "SELECT 1 FROM entries WHERE embedding IS NOT NULL LIMIT 1"
-    );
-    if (hasEntries.rows.length > 0) {
-      await client.execute(`
-        SELECT count(*) FROM vector_top_k(
-          'idx_entries_embedding',
-          (SELECT embedding FROM entries WHERE embedding IS NOT NULL LIMIT 1),
-          1
-        )
-      `);
-    }
-  } catch {
-    if (!didWarnVectorIndexCorruption) {
-      didWarnVectorIndexCorruption = true;
-      log.warn("\u26A0\uFE0F  Vector index may be corrupted. Run `agenr db rebuild-index` to fix.");
+  if (opts?.skipVectorHealthCheck !== true) {
+    try {
+      const hasEntries = await client.execute(
+        "SELECT 1 FROM entries WHERE embedding IS NOT NULL LIMIT 1"
+      );
+      if (hasEntries.rows.length > 0) {
+        await client.execute(`
+          SELECT count(*) FROM vector_top_k(
+            'idx_entries_embedding',
+            (SELECT embedding FROM entries WHERE embedding IS NOT NULL LIMIT 1),
+            1
+          )
+        `);
+      }
+    } catch {
+      if (!didWarnVectorIndexCorruption) {
+        didWarnVectorIndexCorruption = true;
+        log.warn("\u26A0\uFE0F  Vector index may be corrupted. Run `agenr db rebuild-index` to fix.");
+      }
     }
   }
 }
@@ -3378,6 +3402,107 @@ async function retireEntries(opts) {
   return { count };
 }
 
+// src/utils/injected-context.ts
+var OPENCLAW_TIMESTAMP_PREFIX_PATTERN = /\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) \d{4}-\d{2}-\d{2} \d{2}:\d{2} (?:[A-Z]{2,5}|GMT[+-]\d{1,2})\] /g;
+var UNTRUSTED_METADATA_PATTERN = /(?:^|\r?\n)\s*(?:Conversation info|Sender) \(untrusted metadata\):\s*(?:(?:\r?\n|\s+)```(?:json)?\s*[\s\S]*?\r?\n\s*```|(?:\r?\n|\s+)\{[\s\S]*?\})(?:\s*(?=\r?\n|$))?/gim;
+var SECTION_HEADER_PATTERN = /^## (?:Session project state(?: \(authoritative\))?|Recent session|Recent memory|Relevant memory|agenr Memory Context)\b/i;
+var PREFIXED_SECTION_HEADER_PATTERN = /^(?:U:|A:|\[(?:user|assistant)\]:)\s*## (?:Session project state(?: \(authoritative\))?|Recent session|Recent memory|Relevant memory|agenr Memory Context)\b/i;
+var HANDOFF_BACKGROUND_MARKER = "=== BACKGROUND CONTEXT (DO NOT SUMMARIZE) ===";
+var HANDOFF_SUMMARIZE_MARKER = "=== SUMMARIZE THIS SESSION ONLY ===";
+var STARTUP_BOILERPLATE_PATTERN = /^(?:A new session was started via \/new or \/reset|Execute your Session Startup sequence now)\b/i;
+var SIGNAL_PATTERN = /^AGENR SIGNAL:/i;
+var SIGNAL_BULLET_PATTERN = /^\s*-\s*\[[^\n]*/i;
+var STRUCTURAL_BOUNDARY_PATTERN = /^(?:## |(?:Conversation info|Sender) \(untrusted metadata\):|=== |U:|A:|\[(?:user|assistant)\]:)/i;
+function normalizeRemainingWhitespace(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function flattenForDisplay(text) {
+  return text.split(/\r?\n+/).map((line) => line.trim()).filter((line) => line.length > 0).join(" | ").trim();
+}
+function stripStructuredLineBlocks(text) {
+  const lines = text.split(/\r?\n/);
+  const kept = [];
+  let skipSection = false;
+  let skipSignalBullets = false;
+  let skipHandoffBackground = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (skipHandoffBackground) {
+      if (trimmed === HANDOFF_SUMMARIZE_MARKER) {
+        skipHandoffBackground = false;
+      }
+      continue;
+    }
+    if (skipSection) {
+      if (!trimmed) {
+        skipSection = false;
+        continue;
+      }
+      if (trimmed && STRUCTURAL_BOUNDARY_PATTERN.test(trimmed)) {
+        skipSection = false;
+      } else {
+        continue;
+      }
+    }
+    if (skipSignalBullets) {
+      if (trimmed && SIGNAL_BULLET_PATTERN.test(trimmed)) {
+        continue;
+      }
+      skipSignalBullets = false;
+    }
+    if (!trimmed) {
+      kept.push(line);
+      continue;
+    }
+    if (trimmed === HANDOFF_BACKGROUND_MARKER) {
+      skipHandoffBackground = true;
+      continue;
+    }
+    if (trimmed === HANDOFF_SUMMARIZE_MARKER) {
+      continue;
+    }
+    if (SECTION_HEADER_PATTERN.test(trimmed) || PREFIXED_SECTION_HEADER_PATTERN.test(trimmed)) {
+      skipSection = true;
+      continue;
+    }
+    if (SIGNAL_PATTERN.test(trimmed)) {
+      skipSignalBullets = true;
+      continue;
+    }
+    if (STARTUP_BOILERPLATE_PATTERN.test(trimmed)) {
+      continue;
+    }
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
+function hasMeaningfulSanitizedText(text) {
+  const tokens = text.match(/[A-Za-z0-9]+/g) ?? [];
+  if (tokens.length >= 2) {
+    return true;
+  }
+  return tokens.join("").length >= 8;
+}
+function stripInjectedContext(text) {
+  if (!text) {
+    return "";
+  }
+  let cleaned = text.replace(OPENCLAW_TIMESTAMP_PREFIX_PATTERN, "");
+  cleaned = cleaned.replace(UNTRUSTED_METADATA_PATTERN, "\n");
+  cleaned = stripStructuredLineBlocks(cleaned);
+  return normalizeRemainingWhitespace(cleaned);
+}
+function sanitizeInjectedContextText(text, options = {}) {
+  const baseline = normalizeRemainingWhitespace(text.replace(OPENCLAW_TIMESTAMP_PREFIX_PATTERN, ""));
+  const stripped = stripInjectedContext(text);
+  const normalized = options.flatten ? flattenForDisplay(stripped) : stripped;
+  return {
+    text: normalized,
+    removed: stripped !== baseline,
+    meaningful: hasMeaningfulSanitizedText(normalized)
+  };
+}
+
 // src/utils/async.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -9765,7 +9890,7 @@ async function storeEntries(db, entries, apiKey, options = {}) {
     throw new Error("storeEntries does not support dryRun with externalTransaction.");
   }
   const preBatchEmbedChunkSize = typeof options.preBatchEmbedChunkSize === "number" && Number.isFinite(options.preBatchEmbedChunkSize) && options.preBatchEmbedChunkSize > 0 ? Math.floor(options.preBatchEmbedChunkSize) : DEFAULT_PRE_BATCH_EMBED_CHUNK_SIZE;
-  const shouldUseEntityHints = Boolean(options.llmClient) && options.claimExtractionEnabled !== false;
+  const shouldUseEntityHints = Boolean(options.llmClient) && options.claimExtractionEnabled !== false && options.skipClaimExtraction !== true;
   let entityHintsPromise = null;
   const getBatchEntityHints = async () => {
     if (!shouldUseEntityHints) {
@@ -9786,6 +9911,26 @@ async function storeEntries(db, entries, apiKey, options = {}) {
   let relationsCreated = 0;
   let llmDedupCalls = 0;
   const pendingConflictsMap = /* @__PURE__ */ new Map();
+  const sanitizedEntries = [];
+  for (const entry of entries) {
+    const sanitized = sanitizeInjectedContextText(entry.content);
+    if (sanitized.removed && !sanitized.meaningful) {
+      skipped += 1;
+      options.onDecision?.({
+        entry,
+        action: "skipped",
+        reason: "operational injected context"
+      });
+      continue;
+    }
+    sanitizedEntries.push(
+      sanitized.text === entry.content ? entry : {
+        ...entry,
+        content: sanitized.text
+      }
+    );
+  }
+  entries = sanitizedEntries;
   if (!options.force && !onlineDedup) {
     const seen = /* @__PURE__ */ new Map();
     for (let i = 0; i < entries.length; i += 1) {
@@ -9969,13 +10114,15 @@ async function storeEntries(db, entries, apiKey, options = {}) {
         llmDedupCalls += 1;
       }
     });
-    if ((processed.mutation.kind === "add" || processed.mutation.kind === "add_related") && options.llmClient && options.claimExtractionEnabled !== false) {
+    const shouldRunClaimExtraction = (processed.mutation.kind === "add" || processed.mutation.kind === "add_related") && Boolean(options.llmClient) && options.claimExtractionEnabled !== false && options.skipClaimExtraction !== true;
+    const llmClient = options.llmClient;
+    if (shouldRunClaimExtraction && llmClient) {
       const entityHints = await getBatchEntityHints();
       const claim = await extractClaim(
         normalizedEntry.content,
         normalizedEntry.type,
         normalizedEntry.subject,
-        options.llmClient,
+        llmClient,
         {
           model: options.claimExtractionModel,
           config: options.config,
@@ -10004,7 +10151,9 @@ async function storeEntries(db, entries, apiKey, options = {}) {
         };
       }
     }
-    if ((processed.mutation.kind === "add" || processed.mutation.kind === "add_related") && options.llmClient && options.contradictionEnabled !== false && processed.mutation.embedding) {
+    const shouldRunContradictionChecks = (processed.mutation.kind === "add" || processed.mutation.kind === "add_related") && Boolean(options.llmClient) && options.contradictionEnabled !== false && options.skipContradiction !== true && Boolean(processed.mutation.embedding);
+    const mutationEmbedding = processed.mutation.embedding;
+    if (shouldRunContradictionChecks && llmClient && mutationEmbedding) {
       await contradictionSubjectIndex.ensureInitialized(db);
       contradictionLog.info(
         `checking entry: type=${normalizedEntry.type} subject="${normalizedEntry.subject}" subjectKey=${normalizedEntry.subjectKey ?? "none"}`
@@ -10018,9 +10167,9 @@ async function storeEntries(db, entries, apiKey, options = {}) {
           subjectKey: normalizedEntry.subjectKey,
           importance: normalizedEntry.importance
         },
-        processed.mutation.embedding,
+        mutationEmbedding,
         contradictionSubjectIndex,
-        options.llmClient,
+        llmClient,
         {
           model: options.contradictionModel,
           config: options.config
@@ -10078,7 +10227,7 @@ async function storeEntries(db, entries, apiKey, options = {}) {
         }
         pendingConflictsMap.delete(entryIndex);
       }
-      if (options.contradictionEnabled !== false && normalizedEntry.subjectKey && applied.newEntryId) {
+      if (options.contradictionEnabled !== false && options.skipContradiction !== true && normalizedEntry.subjectKey && applied.newEntryId) {
         contradictionSubjectIndex.add(normalizedEntry.subjectKey, applied.newEntryId);
       }
       return applied;
@@ -10237,6 +10386,7 @@ export {
   DEFAULT_DB_PATH,
   buildBackupPath,
   getDb,
+  initDbForStartupReads,
   initDb,
   walCheckpoint,
   backupDb,
@@ -10312,6 +10462,8 @@ export {
   resolveHigherExpiry,
   resolveHighestExpiry,
   resolveSameSubject,
+  stripInjectedContext,
+  sanitizeInjectedContextText,
   storeEntries,
   isRecord,
   evolveQualityScores,

package/dist/{chunk-WT6HSCSO.js → chunk-TCIOL7ZL.js}

@@ -23,7 +23,7 @@ import {
   runSimpleStream,
   toErrorMessage,
   walCheckpoint
-} from "./chunk-3NGXMER3.js";
+} from "./chunk-LXLOBT4V.js";
 import {
   MILLISECONDS_PER_DAY,
   parseDaysBetween,

package/dist/cli-main.d.ts

@@ -284,10 +284,16 @@ declare function writeOutput(params: {
 
 declare function deduplicateEntries(entries: KnowledgeEntry[]): KnowledgeEntry[];
 
-declare function getDb(dbPath?: string): Client;
-declare function initDb(client: Client, opts?: {
+interface GetDbOptions {
+    busyTimeoutMs?: number;
+    ensureWalMode?: boolean;
+}
+interface InitDbOptions {
     checkBulkRecovery?: boolean;
-}): Promise<void>;
+    skipVectorHealthCheck?: boolean;
+}
+declare function getDb(dbPath?: string, options?: GetDbOptions): Client;
+declare function initDb(client: Client, opts?: InitDbOptions): Promise<void>;
 declare function closeDb(client: Client): void;
 
 declare function resolveEmbeddingApiKey(config: AgenrConfig | null | undefined, env?: NodeJS.ProcessEnv): string;

package/dist/cli-main.js

@@ -41,7 +41,7 @@ import {
   runStoreService,
   runTraceService,
   ui
-} from "./chunk-CEPFOYOL.js";
+} from "./chunk-E4QJJSZI.js";
 import {
   ConflictAlreadyResolvedError,
   REVIEW_QUEUE_PATH,
@@ -56,7 +56,7 @@ import {
   showFlaggedMerges,
   toConflictLogRow,
   toRecord
-} from "./chunk-WT6HSCSO.js";
+} from "./chunk-TCIOL7ZL.js";
 import {
   APP_VERSION,
   DEFAULT_AROUND_RADIUS_DAYS,
@@ -150,6 +150,7 @@ import {
   retireEntries,
   runShutdownHandlers,
   runSimpleStream,
+  sanitizeInjectedContextText,
   scoreEntry,
   scoreEntryWithBreakdown,
   sessionStartRecall,
@@ -163,7 +164,7 @@ import {
   walCheckpoint,
   warnIfLocked,
   writeConfig
-} from "./chunk-3NGXMER3.js";
+} from "./chunk-LXLOBT4V.js";
 import {
   getCoRecallNeighbors,
   getTopCoRecallEdges,
@@ -6197,6 +6198,8 @@ async function runConsolidateCommand(options, deps = {}) {
     getDbFn: deps.getDbFn ?? getDb,
     closeDbFn: deps.closeDbFn ?? closeDb,
     initSchemaFn: deps.initSchemaFn ?? initSchema,
+    acquireDbLockFn: deps.acquireDbLockFn ?? acquireDbLock,
+    releaseDbLockFn: deps.releaseDbLockFn ?? releaseDbLock,
     createLlmClientFn: deps.createLlmClientFn ?? createLlmClient,
     resolveEmbeddingApiKeyFn: deps.resolveEmbeddingApiKeyFn ?? resolveEmbeddingApiKey,
     showFlaggedMergesFn: deps.showFlaggedMergesFn ?? showFlaggedMerges,
@@ -6237,9 +6240,9 @@ async function runConsolidateCommand(options, deps = {}) {
   if (dbFilePath === ":memory:") {
     throw new Error("Consolidation requires a file-backed database so a backup can be created.");
   }
-  acquireDbLock();
+  resolvedDeps.acquireDbLockFn();
   onShutdown(async () => {
-    releaseDbLock();
+    resolvedDeps.releaseDbLockFn();
   });
   const db = resolvedDeps.getDbFn(configuredPath);
   try {
@@ -13781,12 +13784,12 @@ function registerMaintainCommand(program) {
     "--only <tasks>",
     "Comma-separated task names: quality,edge-decay,clusters,conflicts,consolidation,retirement,reflection"
   ).option("--prune-edges", "When edge decay runs, delete edges below the configured decay floor").option("--verbose", "Show detailed per-task output").action(async (opts) => {
-    const { runMaintainCommand } = await import("./maintain-S6ROD7SF.js");
+    const { runMaintainCommand } = await import("./maintain-YECEJSXO.js");
     const result = await runMaintainCommand(opts);
     process.exitCode = result.exitCode;
   });
   maintainCommand.command("history").description("Show past maintenance runs").option("--db <path>", "Database path override").option("--limit <n>", "Max runs to show (default: 10)", parseIntOption).option("--json", "Output as JSON").action(async (opts) => {
-    const { runMaintainHistoryCommand } = await import("./maintain-S6ROD7SF.js");
+    const { runMaintainHistoryCommand } = await import("./maintain-YECEJSXO.js");
     const result = await runMaintainHistoryCommand(opts);
     process.exitCode = result.exitCode;
   });
@@ -15840,7 +15843,7 @@ async function runUpdateCommand(options) {
     throw new Error("id is required");
   }
   const importance = options.importance;
-  if (!Number.isInteger(importance) || importance < IMPORTANCE_MIN || importance > IMPORTANCE_MAX) {
+  if (typeof importance !== "number" || !Number.isInteger(importance) || importance < IMPORTANCE_MIN || importance > IMPORTANCE_MAX) {
     throw new Error(`importance must be an integer between ${IMPORTANCE_MIN} and ${IMPORTANCE_MAX}`);
   }
   const clackOutput = { output: process.stderr };
@@ -16307,8 +16310,20 @@ async function runWatcher(options, deps) {
             ...entry,
             platform: entry.platform ?? platformTag
           })) : attributedEntries;
-          cycleResult.entriesExtracted += taggedEntries.length;
-          const deduped = resolvedDeps.deduplicateEntriesFn(taggedEntries);
+          const sanitizedEntries = taggedEntries.flatMap((entry) => {
+            const sanitized = sanitizeInjectedContextText(entry.content);
+            if (sanitized.removed && !sanitized.meaningful) {
+              return [];
+            }
+            return [
+              sanitized.text === entry.content ? entry : {
+                ...entry,
+                content: sanitized.text
+              }
+            ];
+          });
+          cycleResult.entriesExtracted += sanitizedEntries.length;
+          const deduped = resolvedDeps.deduplicateEntriesFn(sanitizedEntries);
           if (options.dryRun || deduped.length === 0) {
             return;
           }

package/dist/{maintain-S6ROD7SF.js → maintain-YECEJSXO.js}

@@ -17,7 +17,7 @@ import {
   resolveConflict,
   runConsolidationOrchestrator,
   toRecord
-} from "./chunk-WT6HSCSO.js";
+} from "./chunk-TCIOL7ZL.js";
 import {
   DEFAULT_DB_PATH,
   DEFAULT_TASK_MODEL,
@@ -43,7 +43,7 @@ import {
   resolveModelForLlmClient,
   runSimpleStream,
   walCheckpoint
-} from "./chunk-3NGXMER3.js";
+} from "./chunk-LXLOBT4V.js";
 import {
   decayCoRecallEdges,
   getLastRecallActivity,

package/dist/openclaw-plugin/index.d.ts

@@ -71,12 +71,13 @@ type PluginApi = {
     };
 };
 
+declare function stripInjectedContext(text: string): string;
+
 type HandoffMessage = {
     role: "user" | "assistant";
     content: string;
     timestamp: string;
 };
-declare function stripInjectedContext(text: string): string;
 declare function getBaseSessionPath(filePath: string): string;
 declare function readSessionsJson(sessionsDir: string): Promise<Record<string, unknown>>;
 declare function readAndParseSessionJsonl(sessionFile: string): Promise<unknown[]>;