claude-mem-lite 3.7.0 → 3.8.0

package/lib/doctor-benchmark.mjs

@@ -16,7 +16,7 @@ import { sanitizeFtsQuery, OBS_BM25 } from '../utils.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SERVER_PATH = join(__dirname, '..', 'server.mjs');
-const SERVER_INTERNALS_PATH = join(__dirname, '..', 'server-internals.mjs');
+const SEARCH_SCORING_PATH = join(__dirname, '..', 'search-scoring.mjs');
 const BENCHMARK_VERSION = '1';
 
 function extractStringArrayBody(body) {
@@ -40,7 +40,7 @@ function extractStringArrayBody(body) {
  *   1. template literal in server.mjs:  instructions: `...`
  *   2. array-join in server.mjs:        instructions: [ '...', '...' ].join('\n')
  *   3. (v2.31.3+) builder call in server.mjs referencing INSTRUCTIONS_BASE +
- *      INSTRUCTIONS_VERBOSE arrays in server-internals.mjs. Measured at the
+ *      INSTRUCTIONS_VERBOSE arrays in search-scoring.mjs. Measured at the
  *      verbose form — this is the cost-per-turn baseline the benchmark tracks.
  * Returns '' if no shape matches (caller treats byte count as 0).
  */
@@ -56,10 +56,10 @@ function readMcpInstructions() {
   if (arr) return extractStringArrayBody(arr[1]).join('\n');
 
   // Form 3: buildServerInstructions() — reconstruct verbose form from
-  // server-internals.mjs INSTRUCTIONS_BASE + INSTRUCTIONS_VERBOSE arrays.
+  // search-scoring.mjs INSTRUCTIONS_BASE + INSTRUCTIONS_VERBOSE arrays.
   if (/instructions:\s*buildServerInstructions\(/.test(src)) {
     let internals;
-    try { internals = readFileSync(SERVER_INTERNALS_PATH, 'utf8'); } catch { return ''; }
+    try { internals = readFileSync(SEARCH_SCORING_PATH, 'utf8'); } catch { return ''; }
     const base = internals.match(/INSTRUCTIONS_BASE\s*=\s*\[([\s\S]*?)\];/);
     const verbose = internals.match(/INSTRUCTIONS_VERBOSE\s*=\s*\[([\s\S]*?)\];/);
     const parts = [];

package/lib/release-digest.mjs

@@ -0,0 +1,106 @@
+// lib/release-digest.mjs — shared release-signing core (P1 supply-chain hardening).
+//
+// One source of truth for BOTH sides of the auto-update authenticity check so the
+// CI signer and the runtime verifier can never drift:
+//   * scripts/sign-release.mjs (CI) — builds the manifest, serializes it, signs
+//     the EXACT serialized bytes with an Ed25519 private key (a GitHub secret),
+//     and uploads release-manifest.json (+ .sig) as GitHub Release assets.
+//   * hook-update.mjs (client) — downloads those assets, verifies the signature
+//     over the downloaded manifest bytes with an EMBEDDED public key, then checks
+//     each extracted file's sha256 against the signed manifest.
+//
+// Why content hashes, not a tarball-byte hash: GitHub's on-the-fly git-archive
+// tarballs are not guaranteed byte-stable over time, but the FILE CONTENTS at a
+// tag are (they are the git blobs). Hashing the extracted files sidesteps the
+// archive-byte-stability problem entirely.
+//
+// Why verify over the downloaded file bytes (not a re-serialization): the client
+// verifies the signature against the manifest bytes exactly as downloaded and
+// only THEN parses it — so there is no canonical-JSON drift between signer and
+// verifier. serializeManifest() exists so CI writes precisely what it signs.
+//
+// Pure Node built-ins (node:crypto Ed25519) — zero dependencies, no `gh`/cosign
+// needed on the user's machine, works in the silent SessionStart hook.
+
+import { createHash, verify as cryptoVerify } from 'node:crypto';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const PACKAGE_NAME = 'claude-mem-lite';
+
+export function sha256Hex(buf) {
+  return createHash('sha256').update(buf).digest('hex');
+}
+
+export function sha256File(absPath) {
+  return sha256Hex(readFileSync(absPath));
+}
+
+/**
+ * Build a release manifest: { name, version, algo, files: { <relPath>: <sha256> } }.
+ * Only files that exist under rootDir are listed; keys are sorted so the
+ * serialization is deterministic regardless of fileList order.
+ *
+ * @param {string} rootDir   Extracted release root (or CI checkout root)
+ * @param {string[]} fileList Relative paths to hash (typically SOURCE_FILES)
+ * @param {string} version   Release version (for the manifest body)
+ */
+export function buildReleaseManifest(rootDir, fileList, version) {
+  const files = {};
+  for (const rel of [...fileList].sort()) {
+    const abs = join(rootDir, rel);
+    if (existsSync(abs)) files[rel] = sha256File(abs);
+  }
+  return { name: PACKAGE_NAME, version, algo: 'sha256', files };
+}
+
+/**
+ * Deterministic byte serialization. CI writes EXACTLY this to
+ * release-manifest.json and signs these bytes; the client verifies the signature
+ * against the downloaded file bytes (it does not re-serialize), so signer and
+ * verifier cannot disagree on canonical form.
+ */
+export function serializeManifest(manifest) {
+  return JSON.stringify(manifest, null, 2) + '\n';
+}
+
+/**
+ * Verify every file the manifest lists matches its signed sha256 on disk.
+ * Returns { ok, mismatches: string[], missing: string[] }.
+ * A content change → mismatches; a manifest-listed file absent → missing.
+ * Both are failures (ok=false).
+ */
+export function verifyReleaseFiles(rootDir, manifest) {
+  const mismatches = [];
+  const missing = [];
+  const files = (manifest && manifest.files) || {};
+  for (const [rel, expected] of Object.entries(files)) {
+    const abs = join(rootDir, rel);
+    if (!existsSync(abs)) { missing.push(rel); continue; }
+    if (sha256File(abs) !== expected) mismatches.push(rel);
+  }
+  return { ok: mismatches.length === 0 && missing.length === 0, mismatches, missing };
+}
+
+/**
+ * Verify an Ed25519 signature over the manifest bytes. Never throws — a malformed
+ * key/signature/algorithm returns false so callers can treat "can't verify" the
+ * same as "invalid" without a try/catch at every call site.
+ *
+ * @param {Buffer|string} manifestBytes The EXACT manifest bytes that were signed
+ * @param {string} signatureB64         Base64-encoded Ed25519 signature
+ * @param {string} publicKeyPem         SPKI PEM public key
+ * @returns {boolean}
+ */
+export function verifyManifestSignature(manifestBytes, signatureB64, publicKeyPem) {
+  try {
+    if (!publicKeyPem || !signatureB64) return false;
+    const data = Buffer.isBuffer(manifestBytes) ? manifestBytes : Buffer.from(manifestBytes);
+    const sig = Buffer.from(signatureB64, 'base64');
+    if (sig.length === 0) return false;
+    // `null` algorithm = Ed25519 (the key type carries the algorithm in Node).
+    return cryptoVerify(null, data, publicKeyPem, sig);
+  } catch {
+    return false;
+  }
+}

package/lib/search-core.mjs

@@ -1,26 +1,33 @@
-// Shared cross-source search core (query build / source queries / scoring
-// normalization / sort / pagination math).
+// Shared cross-source search core for cmdSearch (CLI) and mem_search (MCP).
 //
-// Single source of truth for cmdSearch (CLI) and mem_search (MCP). The
-// observation path already converged in search-engine.mjs (#8198/#8212); the
-// sessions/prompts FTS queries, CJK precision + LIKE fallback, cross-source
-// score normalization, user-sort, over-fetch sizing, and date-bound parsing
-// were still copy-pasted and synced by "paired-path" comments — the drift
-// class compress-core (ARCH-1), recall-core, and timeline-core were extracted
-// to close. Call sites keep what legitimately differs: flag/schema parsing,
-// result-row dialect (CLI `_source`+raw columns vs MCP `source`+mapped
-// fields), error-message wording, and output rendering.
+// coreRunSearchPipeline (below) is the SINGLE orchestration body — deep /
+// auto-escalation → per-source query (obs hybrid + sessions + prompts) →
+// cross-source normalize+sort → context re-rank + supersede → tier filter →
+// user sort → count+paginate. The two ~180-line bodies that cmdSearch and
+// runSearchPipeline used to keep hand-synced via "paired-path" comments are
+// gone (audit P1-2); each surface is now a thin adapter that parses/validates
+// in and renders out. Cross-surface equivalence is enforced by
+// tests/search-parity.test.mjs, not by comments.
 //
-// Behavioral asymmetries that are PRESERVED, not converged (documented so a
-// future "fix" is a deliberate contract change, not an accident):
-//   • CLI forces source=observations when --type/--tier/--importance/--branch
-//     is set; MCP only forces it for obs_type.
+// Surfaces legitimately differ on a few policy points; each is an explicit opt
+// on coreRunSearchPipeline (obsTypeFallback / crossSourceEpochSortNoFts /
+// rerankPolicy / recentListingNoFts / tolerateMissingFts / tierPosition …) so
+// behavior is strictly preserved and any future convergence is a deliberate
+// change, not an accident. Notable preserved asymmetries:
+//   • CLI forces source=observations for --type/--tier/--importance/--branch;
+//     MCP only forces it for obs_type. (effectiveSource is computed per-adapter.)
 //   • CLI warns on inverted --from/--to ranges; MCP does not.
-//   • CLI wraps session/prompt FTS in try/catch for pre-FTS legacy DBs.
+//   • CLI tolerates missing session/prompt FTS (pre-FTS legacy DBs); MCP does not.
+//   • MCP lists-recent-by-type on a 0-match obs_type query; CLI does not (#8217).
+//
+// Result rows use one canonical `source` key; session/prompt rows carry dual
+// keys (date=created_at, text=prompt_text, session=content_session_id) so each
+// surface's renderer reads its own field names off a single row shape.
 
 import { sanitizeFtsQuery, relaxFtsQueryToOr, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS } from '../utils.mjs';
 import { cjkPrecisionOk, extractCjkLikePatterns } from '../nlp.mjs';
 import { computeTier } from '../tier.mjs';
+import { countSearchTotal, attachBodyTokens } from '../search-engine.mjs';
 
 /** Sanitize a user query to FTS5 syntax; optionally force OR semantics. */
 export function buildSearchFtsQuery(query, { or = false } = {}) {
@@ -198,3 +205,252 @@ export function applyTierFilter(db, results, { tier, sourceKey, currentProject }
     return full && computeTier(full, tierCtx) === tier;
   });
 }
+
+/**
+ * Finalize a merged, scored result set into one page: compute the TRUE
+ * (limit/offset-invariant) population, slice the requested page, and attach the
+ * ~Nt fetch-cost hint. Single source of truth for the count+paginate+enrich tail
+ * of cmdSearch (CLI) and runSearchPipeline (MCP) — exactly where #8635 drifted
+ * (the over-fetch cap leaked into the reported total on BOTH sides independently).
+ *
+ * `total`: every source over-fetched from offset 0 (computePerSourceWindow), so
+ * results.length is the over-fetched candidate pool, NOT the population —
+ * countSearchTotal re-derives the real MATCH+filter count. Clamp to
+ * >= results.length so vector/concept-augmented obs rows are never undercounted
+ * (#8217/#8638). For deep (explicit or auto-escalated) the population IS the fused
+ * variant set already in `results` (deepSearch is obs-only, capped at
+ * perSourceLimit); countSearchTotal would instead count the ORIGINAL query's FTS
+ * matches — wrong, and ~0 on the vocabulary-mismatch queries deep exists for (F1).
+ *
+ * Pagination always slices: single-source results can exceed SQL LIMIT via
+ * expansion (concept co-occurrence / PRF / vector), and `offset` is applied
+ * exactly ONCE here (the per-source SQL always saw offset 0).
+ *
+ * @returns {{ total: number, page: object[] }}
+ */
+export function finalizeSearchPage(db, results, {
+  isDeep, offset, limit, effectiveSource, ftsQuery, orFallbackFired,
+  project = null, obsType = null, importance = null, branch = null,
+  epochFrom = null, epochTo = null, includeNoise = false,
+}) {
+  const total = isDeep
+    ? results.length
+    : Math.max(countSearchTotal(db, {
+      effectiveSource: effectiveSource || null,
+      ftsQuery,
+      obsFtsQuery: effectiveObsFtsQuery(ftsQuery, orFallbackFired),
+      args: { project: project || null, obs_type: obsType || null, importance: importance || null, branch: branch || null },
+      project: project || null,
+      epochFrom, epochTo, includeNoise,
+    }), results.length);
+  const page = results.slice(offset, offset + limit);
+  attachBodyTokens(db, page);
+  return { total, page };
+}
+
+/**
+ * Unified cross-source search orchestrator — single source of truth for the CLI
+ * (cmdSearch) and MCP (mem_search) search bodies: deep / auto-escalation →
+ * per-source query (obs hybrid + sessions + prompts) → cross-source
+ * normalize+sort → context re-rank + supersede → tier post-filter → user sort →
+ * count+paginate. The two surfaces legitimately differ on a handful of policy
+ * points; each is a named opt so a future "fix" is a deliberate contract change,
+ * not an accident (see the per-opt comments).
+ *
+ * The core does NO flag/schema parsing, NO stdout/stderr, NO formatting — adapters
+ * validate+parse on the way in and render on the way out. Session/prompt rows
+ * carry dual keys (`date`=created_at, `text`=prompt_text, `session`=content_session_id)
+ * so both renderers read their own field names off one canonical row.
+ *
+ * #8743: `db` comes ONLY from `ctx.db` — there is no module-global fallback, so a
+ * per-source leg can never silently query the wrong database.
+ *
+ * @returns {Promise<{ page:object[], total:number, preFinalizeCount:number, isDeep:boolean,
+ *   escalated:boolean, escalatedObsCount:number, variants:object[]|null,
+ *   reranked:boolean, orFallbackFired:boolean, effectiveSource:string|null, ftsQuery:string }>}
+ */
+export async function coreRunSearchPipeline(ctx, opts) {
+  const {
+    db, currentProject = null, env = process.env,
+    searchObservationsHybrid, deepSearch, shouldEscalateToDeep,
+    autoDeepLlmReady, reRankWithContext, markSuperseded,
+    llm = null, rerankLlm = undefined,
+  } = ctx;
+  const {
+    query, ftsQuery, effectiveSource = null, deepMode = 'normal', rerank = false,
+    limit, offset, project = null, obsType = null, importance = null, branch = null,
+    includeNoise = false, epochFrom = null, epochTo = null, sort = 'relevance', tier = null,
+    // ── surface policy (strict behavior-preservation; the two surfaces differ) ──
+    obsTypeFallback = false,           // A5: list-recent-by-type when 0 matches — MCP true, CLI false (#8217 removed it from CLI)
+    crossSourceEpochSortNoFts = false, // A3: epoch-sort the cross-source set when no ftsQuery — MCP true, CLI false
+    rerankPolicy = 'mcp',              // A4: re-rank/supersede gate + re-sort condition — 'mcp' | 'cli'
+    rerankProject = null,              // reRankWithContext project — MCP currentProject, CLI project||inferProject()
+    recentListingNoFts = false,        // session/prompt recent-listing when no ftsQuery (explicit --source) — MCP true, CLI false
+    tolerateMissingFts = false,        // wrap session/prompt FTS in try/catch for pre-FTS legacy DBs — CLI true, MCP false
+    tierPosition = 'late',             // tier filter vs re-rank ordering — MCP 'late' (after re-rank), CLI 'early' (in obs block)
+    tierProject = null,                // applyTierFilter project — MCP project||currentProject, CLI project||inferProject()
+  } = opts;
+
+  const { perSourceLimit, perSourceOffset } = computePerSourceWindow(limit, offset);
+  const isCrossSource = !effectiveSource;
+  const results = [];
+  let orFallbackFired = false;
+  let deepVariants = null;
+  let deepReranked = false;
+  let isDeep = deepMode === 'deep';
+  let escalated = false;
+  let escalatedObsCount = 0;
+
+  const obsCtx = {
+    db, ftsQuery,
+    args: { project, obs_type: obsType, importance, branch, include_noise: includeNoise },
+    epochFrom, epochTo, perSourceLimit, perSourceOffset, currentProject, limit,
+    orFallbackFired: false,
+  };
+
+  const runDeep = async ({ auto = false } = {}) => {
+    const ds = await deepSearch(db, {
+      query, project, type: obsType, importance, branch, includeNoise,
+      epochFrom, epochTo, limit: perSourceLimit, currentProject,
+    }, llm ? { llm, rerank: rerank && !auto, rerankLlm } : { auto, rerank: rerank && !auto, rerankLlm });
+    deepVariants = ds.variants;
+    deepReranked = ds.reranked;
+    return ds.results;
+  };
+
+  // ── Observations (hybrid engine; deep / auto-escalation; obs rows already carry source:'obs') ──
+  if (!effectiveSource || effectiveSource === 'observations') {
+    if (deepMode === 'deep') {
+      results.push(...await runDeep());
+    } else {
+      results.push(...searchObservationsHybrid(db, obsCtx));
+      if (obsCtx.orFallbackFired) orFallbackFired = true;
+      const obsCountBefore = results.filter((r) => r.source === 'obs').length;
+      if (deepMode === 'auto' && autoDeepLlmReady(env, llm) &&
+          shouldEscalateToDeep(results.filter((r) => r.source === 'obs'), obsCtx, { db, project })) {
+        const deepRows = await runDeep({ auto: true });
+        results.length = 0;
+        results.push(...deepRows);
+        isDeep = true;
+        escalated = true;
+        escalatedObsCount = obsCountBefore;
+      }
+    }
+  }
+
+  // ── Tier post-filter, CLI position: obs-only (tier forces observations), before re-rank ──
+  if (tier && tierPosition === 'early') {
+    const filtered = applyTierFilter(db, results, { tier, sourceKey: 'source', currentProject: tierProject });
+    results.length = 0; results.push(...filtered);
+  }
+
+  // ── Sessions (FTS via shared helper; optional recent-listing when no ftsQuery) ──
+  if ((!effectiveSource || effectiveSource === 'sessions') && !isDeep) {
+    const pushSessions = () => {
+      if (ftsQuery) {
+        const rows = searchSessionsFts(db, { ftsQuery, project, projectBoost: project ? null : currentProject, epochFrom, epochTo, perSourceLimit, perSourceOffset });
+        for (const r of rows) results.push({ ...r, source: 'session', date: r.created_at });
+      } else if (recentListingNoFts && effectiveSource === 'sessions') {
+        const params = []; const wheres = [];
+        if (project) { wheres.push('project = ?'); params.push(project); }
+        if (epochFrom !== null) { wheres.push('created_at_epoch >= ?'); params.push(epochFrom); }
+        if (epochTo !== null) { wheres.push('created_at_epoch <= ?'); params.push(epochTo); }
+        const where = wheres.length ? `WHERE ${wheres.join(' AND ')}` : '';
+        params.push(perSourceLimit, perSourceOffset);
+        const rows = db.prepare(`
+          SELECT id, request, completed, project, created_at, created_at_epoch
+          FROM session_summaries ${where}
+          ORDER BY created_at_epoch DESC
+          LIMIT ? OFFSET ?
+        `).all(...params);
+        for (const r of rows) results.push({ ...r, source: 'session', date: r.created_at });
+      }
+    };
+    if (tolerateMissingFts) { try { pushSessions(); } catch { /* session FTS may not exist in older DBs */ } } else pushSessions();
+  }
+
+  // ── Prompts (FTS via shared helper incl. CJK gate; optional recent-listing) ──
+  if ((!effectiveSource || effectiveSource === 'prompts') && !isDeep) {
+    const pushPrompts = () => {
+      if (ftsQuery) {
+        const rows = searchPromptsFts(db, { query, ftsQuery, project, epochFrom, epochTo, perSourceLimit, perSourceOffset });
+        for (const r of rows) results.push({ ...r, source: 'prompt', date: r.created_at, text: r.prompt_text, session: r.content_session_id });
+      } else if (recentListingNoFts && effectiveSource === 'prompts') {
+        const params = []; const wheres = [];
+        if (project) { wheres.push('s.project = ?'); params.push(project); }
+        if (epochFrom !== null) { wheres.push('p.created_at_epoch >= ?'); params.push(epochFrom); }
+        if (epochTo !== null) { wheres.push('p.created_at_epoch <= ?'); params.push(epochTo); }
+        const where = wheres.length ? `WHERE ${wheres.join(' AND ')}` : '';
+        params.push(perSourceLimit, perSourceOffset);
+        const rows = db.prepare(`
+          SELECT p.id, p.prompt_text, p.content_session_id, p.created_at, p.created_at_epoch
+          FROM user_prompts p
+          JOIN sdk_sessions s ON p.content_session_id = s.content_session_id
+          ${where}
+          ORDER BY p.created_at_epoch DESC
+          LIMIT ? OFFSET ?
+        `).all(...params);
+        for (const r of rows) results.push({ ...r, source: 'prompt', date: r.created_at, text: r.prompt_text, session: r.content_session_id });
+      }
+    };
+    if (tolerateMissingFts) { try { pushPrompts(); } catch { /* prompt FTS may not exist in older DBs */ } } else pushPrompts();
+  }
+
+  // ── Type-list fallback (MCP): obs_type set + 0 matches → list recent of that type ──
+  if (obsTypeFallback && results.length === 0 && obsType) {
+    const typeWheres = ['COALESCE(compressed_into, 0) = 0', 'superseded_at IS NULL', 'type = ?'];
+    const typeParams = [obsType];
+    if (project) { typeWheres.push('project = ?'); typeParams.push(project); }
+    if (epochFrom !== null) { typeWheres.push('created_at_epoch >= ?'); typeParams.push(epochFrom); }
+    if (epochTo !== null) { typeWheres.push('created_at_epoch <= ?'); typeParams.push(epochTo); }
+    if (importance) { typeWheres.push('COALESCE(importance, 1) >= ?'); typeParams.push(importance); }
+    typeParams.push(limit);
+    const typeRows = db.prepare(`
+      SELECT id, type, title, subtitle, project, created_at, importance, files_modified
+      FROM observations WHERE ${typeWheres.join(' AND ')}
+      ORDER BY created_at_epoch DESC LIMIT ?
+    `).all(...typeParams);
+    for (const r of typeRows) results.push({ source: 'obs', id: r.id, type: r.type, title: r.title, subtitle: r.subtitle, project: r.project, date: r.created_at, importance: r.importance, files_modified: r.files_modified, score: 0, snippet: '' });
+  }
+
+  // ── Cross-source normalize + sort ──
+  if (isCrossSource && results.length > 0 && ftsQuery) normalizeCrossSourceScores(results, 'source');
+  if (isCrossSource && results.length > 0) {
+    if (ftsQuery) results.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+    else if (crossSourceEpochSortNoFts) results.sort((a, b) => (b.created_at_epoch ?? 0) - (a.created_at_epoch ?? 0));
+  }
+
+  // ── Context re-rank + superseded marking (markSuperseded is pure stale-tagging) ──
+  const hasObs = results.some((r) => r.source === 'obs');
+  const rerankGate = rerankPolicy === 'mcp' ? ((ftsQuery || isDeep) && hasObs) : hasObs;
+  if (rerankGate) {
+    const obsResults = results.filter((r) => r.source === 'obs');
+    const doReRank = rerankPolicy === 'mcp' ? (ftsQuery && !deepReranked) : !deepReranked;
+    if (doReRank) reRankWithContext(db, obsResults, rerankProject);
+    markSuperseded(obsResults);
+    const doReSort = rerankPolicy === 'mcp' ? (ftsQuery && !deepReranked) : isCrossSource;
+    if (doReSort) results.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+  }
+
+  // ── Tier post-filter, MCP position: after re-rank, on the merged set ──
+  if (tier && tierPosition === 'late') {
+    const filtered = applyTierFilter(db, results, { tier, sourceKey: 'source', currentProject: tierProject });
+    results.length = 0; results.push(...filtered);
+  }
+
+  // ── User-requested sort (after relevance scoring) ──
+  applyUserSort(results, sort);
+
+  // ── Count + paginate + ~Nt enrich. preFinalizeCount lets the CLI adapter
+  //    distinguish "nothing matched" from "this page is empty" (its two messages). ──
+  const preFinalizeCount = results.length;
+  const { total, page } = finalizeSearchPage(db, results, {
+    isDeep, offset, limit, effectiveSource, ftsQuery, orFallbackFired,
+    project, obsType, importance, branch, epochFrom, epochTo, includeNoise,
+  });
+
+  return {
+    page, total, preFinalizeCount, isDeep, escalated, escalatedObsCount,
+    variants: deepVariants, reranked: deepReranked, orFallbackFired, effectiveSource, ftsQuery,
+  };
+}