@kira905/dsh-memory-toolkit 0.1.3 → 0.2.0

package/memory-engine/lib/sweep.mjs

@@ -1,159 +1,136 @@
-// 记忆引擎 v2 · 离线层 —— 兜底：全表 text_hash 段轮转校验（方案 §3.1 兜底 / §6.2 ②）
+// 兜底轮转：把全表按 id 段切开，一段一段核对「正文哈希」与「向量库里存的那份」是否还一致。
 //
-// 为什么必须有（A7 实测）：41 处外部 `UPDATE memories SET text=?` 中，
-// apply-pinned-refine.mjs:110 改 text **不动 updated_at** ⇒ 这类勘误永远进不了增量窗口。
-// 兜底外置、不与增量主路径共用候选集；按 id 段轮转，累计若干轮覆盖全表。
+// 为什么非它不可：外部脚本改正文时未必顺手更新 updated_at（真实写口里就有一批这样的），
+// 这类勘误永远落在增量窗口之外。所以兜底单列一条路，不与增量主路径共用候选集，
+// 靠一圈一圈轮转最终覆盖整张表。
+
 import { textHash } from './hashes.mjs';
-import { META_KEYS, getMetaFor, setMetaFor, getHashes, upsertVectors } from './vectors-store.mjs';
-// 【S3c 挂钩（2026-09-21）】轮转发现的"正文变了"差异**必须落 `memories_dirty` 台账**：
-//   本函数发现差异后会**立刻重编码并更新 `vectors.text_hash`** ⇒ 差异信号当场消失。
-//   若此刻只用于重编码而不留痕，被外部改过 text 的条（A7 的 41 处写口）就再也没人知道要提炼它们。
-//   台账是**只加不改**的旁路；`recordDirty` 幂等（同一条重复扫到只 hits+1，不复活已消费项）。
+import * as vectors from './vectors-store.mjs';
 import { recordDirty } from './dirty-ledger.mjs';
 
+// 台账的语义是「哪条记忆的正文被外部改过」，因此只对记忆源记账；
+// 其它来源（例如坑源的十六位十六进制 id）一律不往台账塞，免得污染提炼侧输入。
+const LEDGER_SOURCE = 'memory';
+
+const noteOf = (stage, e) => ({ stage, message: e && e.message ? e.message : String(e) });
+
 /**
  * @param {object} p
- * @param {object} p.source
- * @param {object} p.store
- * @param {object} p.embedder
- * @param {number} p.segments  全表分几段（默认 20）
- * @param {number} p.rounds    本次跑几段（默认 1；--all 传 segments = 一轮完整覆盖）
- * @param {string} [p.sourceName='memory'] 向量来源名
- *   ⚠️ 轮转语义按来源不同：memory = **id 段**；pitfall = `segment()` 内部按 `lastSeen` 排序后切片
- *      （`idRange()` 给的是排序下标区间 ⇒ 同一段轮转代码对两个来源都成立，不必分支）。
+ * @param {object} p.source   数据源（idRange / segment）
+ * @param {object} p.store    向量库（{ db }）
+ * @param {object} p.embedder 编码器
+ * @param {string} p.modelId
+ * @param {number} p.dim
+ * @param {string} [p.sourceName='memory'] 来源名（决定写哪一列、游标落哪个命名空间）
+ * @param {number} [p.segments=20] 全表切几段
+ * @param {number} [p.rounds=1] 本次走几段（传 segments 即一整圈）
  */
-export async function runHashSweep({
-  source,
-  store,
-  embedder,
-  modelId,
-  dim,
-  sourceName = 'memory',
-  segments = 20,
-  rounds = 1,
-  dryRun = false,
-  log = () => {},
-  now = () => Date.now(),
-}) {
-  const db = store.db;
-  const src = String(sourceName || 'memory');
-  // ⚠️ `memories_dirty` 台账的语义是「哪条**记忆**的正文被外部改过、待提炼」——
-  //    坑源跑兜底时**不得**把 16 位 hex 的坑 id 记进去（会污染提炼侧输入）。故只对 memory 源落台账。
-  const useDirtyLedger = src === 'memory';
-  const startedAt = now();
-  const range = source.idRange();
+export async function runHashSweep({ source, store, embedder, modelId, dim, sourceName = 'memory', segments = 20, rounds = 1, dryRun = false, log = () => {}, now = () => Date.now() }) {
+  const conn = store.db;
+  const origin = String(sourceName || 'memory');
+  const ledgerApplies = origin === LEDGER_SOURCE;
+  const openedAt = now();
+  const bounds = source.idRange();
+  const slotCount = Math.max(1, segments);
   const stats = {
-    source: src,
-    mode: 'hash-sweep',
-    segments,
-    rounds,
-    range,
-    cursorStart: Number(getMetaFor(db, META_KEYS.hashSweepCursor, src) || 0) % Math.max(1, segments),
-    cursorEnd: 0,
-    scanned: 0,
-    mismatched: 0,
-    missing: 0,
-    fixed: 0,
-    dirtyRecorded: 0,
-    segmentReports: [],
-    completedFullSweep: false,
-    elapsedMs: 0,
-    failures: [],
+    source: origin, mode: 'hash-sweep', segments, rounds, range: bounds,
+    cursorStart: Number(vectors.getMetaFor(conn, vectors.META_KEYS.hashSweepCursor, origin) || 0) % slotCount,
+    cursorEnd: 0, scanned: 0, mismatched: 0, missing: 0, fixed: 0, dirtyRecorded: 0,
+    segmentReports: [], completedFullSweep: false, elapsedMs: 0, failures: [],
   };
-  if (range.lo == null) {
-    stats.cursorEnd = stats.cursorStart;
+  const closeBook = () => {
     stats.finishedAt = now();
-    stats.elapsedMs = stats.finishedAt - startedAt;
-    log(`[sweep] ${src} 源为空，跳过`);
+    stats.elapsedMs = stats.finishedAt - openedAt;
+  };
+
+  // 空表：游标原地不动，直接收工（一个 meta 都不写）
+  if (bounds.lo == null) {
+    stats.cursorEnd = stats.cursorStart;
+    closeBook();
+    log(`[sweep] ${origin} 源为空，跳过`);
     return stats;
   }
 
-  const width = Math.max(1, Math.ceil((range.hi - range.lo + 1) / Math.max(1, segments)));
-  let cursor = stats.cursorStart;
+  const width = Math.max(1, Math.ceil((bounds.hi - bounds.lo + 1) / slotCount));
+  let slot = stats.cursorStart;
 
-  try {
-    for (let i = 0; i < rounds; i += 1) {
-      const lo = range.lo + cursor * width;
-      const hi = Math.min(range.hi, lo + width - 1);
-      const rows = source.segment(lo, hi);
-      const hashes = getHashes(db, src, rows.map((r) => r.id));
-      const need = [];
-      // 【S3c】差异明细（只收 "mismatch"：正文哈希与向量库不符 = 被外部改过 text）
-      const dirtyItems = [];
-      let missing = 0;
-      let mismatched = 0;
-      for (const r of rows) {
-        const h = textHash(r.text);
-        const prev = hashes.get(String(r.id));
-        if (prev === undefined) {
-          missing += 1;
-          need.push({ row: r, hash: h });
-        } else if (prev !== h) {
-          mismatched += 1;
-          need.push({ row: r, hash: h });
-          dirtyItems.push({ refId: r.id, kind: 'mismatch', oldHash: prev, newHash: h });
-        }
+  // 单段作业：先对哈希，再落台账，最后重编码 —— 顺序不能换。
+  // 重编码会把旧的 text_hash 覆盖掉，差异就再也说不清了。
+  const runSegment = async (lo, hi, index) => {
+    const rows = source.segment(lo, hi);
+    const known = vectors.getHashes(conn, origin, rows.map((row) => row.id));
+    const redo = [];
+    const drifted = [];
+    let absent = 0;
+    let stale = 0;
+    for (const row of rows) {
+      const digest = textHash(row.text);
+      const stored = known.get(String(row.id));
+      if (stored === digest) continue;
+      if (stored === undefined) {
+        absent += 1;
+      } else {
+        stale += 1;
+        drifted.push({ refId: row.id, kind: 'mismatch', oldHash: stored, newHash: digest });
       }
-      // 先落台账、再重编码（顺序不能反：重编码会把 old_hash 覆盖掉，差异就再也说不清了）
-      if (!dryRun && useDirtyLedger && dirtyItems.length) {
-        try {
-          recordDirty(db, dirtyItems, { now: now() });
-          stats.dirtyRecorded = (stats.dirtyRecorded ?? 0) + dirtyItems.length;
-        } catch (e) {
-          // 台账写失败**不得**影响主路径（它只是提炼侧的补充输入源）
-          stats.failures.push({ stage: 'dirty-ledger', message: String(e && e.message ? e.message : e) });
-        }
+      redo.push({ row, digest });
+    }
+
+    if (drifted.length && ledgerApplies && !dryRun) {
+      try {
+        recordDirty(conn, drifted, { now: now() });
+        stats.dirtyRecorded += drifted.length;
+      } catch (e) {
+        // 台账只是提炼侧的补充输入源 ⇒ 它写失败绝不许拖垮主路径
+        stats.failures.push(noteOf('dirty-ledger', e));
       }
-      if (need.length) {
-        const vecs = await embedder.encodeBatch(need.map((n) => n.row.text));
-        if (!dryRun) {
-          upsertVectors(
-            db,
-            need.map((n, k) => ({
-              source: src,
-              refId: n.row.id,
-              model: modelId,
-              dim: vecs[k].length,
-              vec: vecs[k],
-              textHash: n.hash,
-              updatedAt: n.row.updated_at,
-            })),
-          );
-        }
+    }
+
+    if (redo.length) {
+      const encoded = await embedder.encodeBatch(redo.map((item) => item.row.text));
+      if (!dryRun) {
+        vectors.upsertVectors(conn, redo.map((item, at) => ({
+          source: origin,
+          refId: item.row.id,
+          model: modelId,
+          dim: encoded[at].length,
+          vec: encoded[at],
+          textHash: item.digest,
+          updatedAt: item.row.updated_at,
+        })));
       }
-      stats.scanned += rows.length;
-      stats.missing += missing;
-      stats.mismatched += mismatched;
-      stats.fixed += need.length;
-      stats.segmentReports.push({
-        segment: cursor,
-        lo,
-        hi,
-        rows: rows.length,
-        missing,
-        mismatched,
-        fixed: need.length,
-      });
-      log(
-        `[sweep] 段 ${cursor}（id ${lo}-${hi}）：${rows.length} 条，缺失 ${missing}，哈希不符 ${mismatched} ⇒ 重编码 ${need.length}`,
-      );
-      cursor = (cursor + 1) % Math.max(1, segments);
-      if (cursor === 0) stats.completedFullSweep = true;
+    }
+
+    stats.scanned += rows.length;
+    stats.missing += absent;
+    stats.mismatched += stale;
+    stats.fixed += redo.length;
+    stats.segmentReports.push({ segment: index, lo, hi, rows: rows.length, missing: absent, mismatched: stale, fixed: redo.length });
+    log(`[sweep] 段 ${index}（id ${lo}-${hi}）：${rows.length} 条，缺失 ${absent}，哈希不符 ${stale} ⇒ 重编码 ${redo.length}`);
+  };
+
+  try {
+    for (let step = 0; step < rounds; step += 1) {
+      const from = bounds.lo + slot * width;
+      const until = Math.min(bounds.hi, from + width - 1);
+      await runSegment(from, until, slot);
+      slot = (slot + 1) % slotCount;
+      if (slot === 0) stats.completedFullSweep = true;
     }
   } catch (e) {
-    stats.failures.push({ stage: 'sweep', message: String(e && e.message ? e.message : e) });
+    stats.failures.push(noteOf('sweep', e));
     stats.error = stats.failures[0].message;
   }
 
-  stats.cursorEnd = cursor;
+  stats.cursorEnd = slot;
   if (!dryRun) {
-    setMetaFor(db, META_KEYS.hashSweepCursor, src, String(cursor));
+    vectors.setMetaFor(conn, vectors.META_KEYS.hashSweepCursor, origin, String(slot));
     if (stats.completedFullSweep) {
       stats.lastFullHashSweepAt = now();
-      setMetaFor(db, META_KEYS.lastFullHashSweepAt, src, String(stats.lastFullHashSweepAt));
+      const fullAt = vectors.META_KEYS.lastFullHashSweepAt;
+      vectors.setMetaFor(conn, fullAt, origin, String(stats.lastFullHashSweepAt));
     }
   }
-  stats.finishedAt = now();
-  stats.elapsedMs = stats.finishedAt - startedAt;
+  closeBook();
   return stats;
 }

package/memory-engine/lib/sync.mjs

@@ -1,180 +1,150 @@
-// 记忆引擎 v2 · 离线层 —— 增量同步（方案 §3.1 主路径）
+// 增量同步：按 updated_at 水位，把新增或改过的条目编码进独立向量库。
 //
-// 主路径：memories.updated_at > meta.lastIncrementalSyncAt 增量扫描（只读 memory.db，不写）
-// 批 50；失败保留进度、下轮续跑；换模型 / 维度变化 → 全量重建。
-// ⚠ 兜底（外置，不与本路径共用候选集）见 sweep.mjs。
+// 这条路只读源库、只写向量库；一批一批往前推，某一批炸了就停在那儿 ——
+// 之前跑完的批次进度已经落盘，下一轮从断点接着编即可。
+// 换模型 / 换维度 / 显式全量都会转成"先清掉该来源、再整份重建"。
+// 那种「改正文却不改时间戳」的盲区不归这里管，另有兜底轮转那条路。
+
 import { textHash } from './hashes.mjs';
-import {
-  META_KEYS,
-  getMetaFor,
-  setMetaFor,
-  getMeta,
-  setMeta,
-  getHashes,
-  upsertVectors,
-  countVectors,
-  deleteSource,
-} from './vectors-store.mjs';
+import * as vectors from './vectors-store.mjs';
+
+const errText = (e) => (e && e.message ? e.message : String(e));
+
+// 重建判据：模型变了、维度变了、或者调用方明确要全量。
+function decideMode({ knownModel, knownDim, modelId, dim, full }) {
+  const causes = [];
+  if (knownModel && knownModel !== modelId) causes.push(`模型变更 ${knownModel} → ${modelId}`);
+  if (knownDim && Number(knownDim) !== Number(dim)) causes.push(`维度变更 ${knownDim} → ${dim}`);
+  if (full) causes.push('显式 --full');
+  return { causes, rebuild: causes.length > 0 };
+}
+
+// 一批里真正要编码的那些：哈希与库里存的一致就跳过（幂等全靠这一步）。
+function splitBatch(rows, stored) {
+  const pending = [];
+  let skipped = 0;
+  for (const row of rows) {
+    const digest = textHash(row.text);
+    if (stored.get(String(row.id)) === digest) {
+      skipped += 1;
+      continue;
+    }
+    pending.push({ row, digest });
+  }
+  return { pending, skipped };
+}
 
 /**
  * @param {object} p
- * @param {object} p.source   memory-source / pitfall-source（只读）
- * @param {object} p.store    vectors-store { db }
- * @param {object} p.embedder 编码器（encode/encodeBatch）
+ * @param {object} p.source  记忆源 / 坑源（只读）
+ * @param {object} p.store   向量库（{ db }）
+ * @param {object} p.embedder 编码器（encodeBatch）
  * @param {string} p.modelId
  * @param {number} p.dim
- * @param {string} [p.sourceName='memory'] 向量来源名（写入 `vectors.source` 与 meta 命名空间）
+ * @param {string} [p.sourceName='memory'] 来源名（同时决定 vectors.source 与 meta 命名空间）
  */
-export async function runIncrementalSync({
-  source,
-  store,
-  embedder,
-  modelId,
-  dim,
-  sourceName = 'memory',
-  batchSize = 50,
-  full = false,
-  dryRun = false,
-  log = () => {},
-  now = () => Date.now(),
-  untilEmpty = true,
-}) {
-  const db = store.db;
-  const src = String(sourceName || 'memory');
-  const startedAt = now();
-  // ⚠️ 水位/模型/维度键一律**按来源**读写（共库不串味：方案 §A.6 首要风险 / §1.3-③.1）
-  const metaModel = getMetaFor(db, META_KEYS.modelId, src);
-  const metaDim = getMetaFor(db, META_KEYS.dim, src);
-  const metaHost = getMeta(db, META_KEYS.hostId);
-
-  const reasons = [];
-  if (metaModel && metaModel !== modelId) reasons.push(`模型变更 ${metaModel} → ${modelId}`);
-  if (metaDim && Number(metaDim) !== Number(dim)) reasons.push(`维度变更 ${metaDim} → ${dim}`);
-  if (full) reasons.push('显式 --full');
-
-  let rebuild = reasons.length > 0;
-  let watermark = 0;
-  let cleared = 0;
+export async function runIncrementalSync({ source, store, embedder, modelId, dim, sourceName = 'memory', batchSize = 50, full = false, dryRun = false, log = () => {}, now = () => Date.now(), untilEmpty = true }) {
+  const conn = store.db;
+  const origin = String(sourceName || 'memory');
+  const openedAt = now();
+  // 水位/模型/维度一律按来源读写：两个来源共用一只库，键位串味会表现成"某来源静默漏编码"。
+  const knownModel = vectors.getMetaFor(conn, vectors.META_KEYS.modelId, origin);
+  const knownDim = vectors.getMetaFor(conn, vectors.META_KEYS.dim, origin);
+  const hostKnown = vectors.getMeta(conn, vectors.META_KEYS.hostId);
+  const { causes, rebuild } = decideMode({ knownModel, knownDim, modelId, dim, full });
 
+  let level = 0;
+  let purged = 0;
   if (rebuild) {
     if (!dryRun) {
-      cleared = deleteSource(db, src);
-      setMetaFor(db, META_KEYS.modelId, src, modelId);
-      setMetaFor(db, META_KEYS.dim, src, String(dim));
-      setMetaFor(db, META_KEYS.lastIncrementalSyncAt, src, '0');
+      purged = vectors.deleteSource(conn, origin);
+      vectors.setMetaFor(conn, vectors.META_KEYS.modelId, origin, modelId);
+      vectors.setMetaFor(conn, vectors.META_KEYS.dim, origin, String(dim));
+      vectors.setMetaFor(conn, vectors.META_KEYS.lastIncrementalSyncAt, origin, '0');
     }
-    log(`[sync] 全量重建：${reasons.join(' / ')}（清空 ${cleared} 条向量）`);
+    log(`[sync] 全量重建：${causes.join(' / ')}（清空 ${purged} 条向量）`);
   } else {
-    watermark = Number(getMetaFor(db, META_KEYS.lastIncrementalSyncAt, src) || 0);
+    level = Number(vectors.getMetaFor(conn, vectors.META_KEYS.lastIncrementalSyncAt, origin) || 0);
   }
 
   const stats = {
-    source: src,
-    mode: rebuild ? 'rebuild' : 'incremental',
-    reasons,
-    watermarkStart: watermark,
-    watermarkEnd: watermark,
-    scanned: 0,
-    encoded: 0,
-    skippedSameHash: 0,
-    upserted: 0,
-    batches: 0,
-    failures: [],
-    cleared,
-    vectorsBefore: countVectors(db, src),
-    vectorsAfter: 0,
-    elapsedMs: 0,
-    startedAt,
-    finishedAt: 0,
+    source: origin, mode: rebuild ? 'rebuild' : 'incremental', reasons: causes,
+    watermarkStart: level, watermarkEnd: level,
+    scanned: 0, encoded: 0, skippedSameHash: 0, upserted: 0, batches: 0,
+    failures: [], cleared: purged,
+    vectorsBefore: vectors.countVectors(conn, origin), vectorsAfter: 0,
+    elapsedMs: 0, startedAt: openedAt, finishedAt: 0,
   };
 
   let afterId = 0;
-  let maxSeenUpdatedAt = watermark;
+  let high = level;
+
+  // 每批成功后把四类键一起前移（主机的键只在库里没有时补一次）。
+  const advanceLevel = (value) => {
+    vectors.setMetaFor(conn, vectors.META_KEYS.modelId, origin, modelId);
+    vectors.setMetaFor(conn, vectors.META_KEYS.dim, origin, String(dim));
+    if (!hostKnown) vectors.setMeta(conn, vectors.META_KEYS.hostId, String(store.hostId || ''));
+    vectors.setMetaFor(conn, vectors.META_KEYS.lastIncrementalSyncAt, origin, String(value));
+  };
 
   try {
-    for (;;) {
-      const page = source.incrementalPage(watermark, afterId, batchSize);
-      if (!page.length) break;
+    let page = source.incrementalPage(level, afterId, batchSize);
+    while (page.length) {
       stats.batches += 1;
-      afterId = page[page.length - 1].id;
+      const tailId = page[page.length - 1].id;
       stats.scanned += page.length;
-      for (const r of page) if (r.updated_at > maxSeenUpdatedAt) maxSeenUpdatedAt = r.updated_at;
+      for (const row of page) if (row.updated_at > high) high = row.updated_at;
 
-      const hashes = getHashes(db, src, page.map((r) => r.id));
-      const need = [];
-      for (const r of page) {
-        const h = textHash(r.text);
-        if (hashes.get(String(r.id)) === h) {
-          stats.skippedSameHash += 1;
-          continue;
-        }
-        need.push({ row: r, hash: h });
-      }
+      const { pending, skipped } = splitBatch(page, vectors.getHashes(conn, origin, page.map((row) => row.id)));
+      stats.skippedSameHash += skipped;
 
-      if (need.length) {
-        const vecs = await embedder.encodeBatch(need.map((n) => n.row.text));
-        if (vecs.length !== need.length) {
-          throw new Error(`编码器返回数量不符：期望 ${need.length}，实际 ${vecs.length}`);
+      if (pending.length) {
+        const encoded = await embedder.encodeBatch(pending.map((item) => item.row.text));
+        if (encoded.length !== pending.length) {
+          throw new Error(`编码器返回数量不符：期望 ${pending.length}，实际 ${encoded.length}`);
         }
         if (!dryRun) {
-          upsertVectors(
-            db,
-            need.map((n, i) => ({
-              source: src,
-              refId: n.row.id,
-              model: modelId,
-              dim: vecs[i].length,
-              vec: vecs[i],
-              textHash: n.hash,
-              updatedAt: n.row.updated_at,
-            })),
-          );
+          vectors.upsertVectors(conn, pending.map((item, at) => ({
+            source: origin,
+            refId: item.row.id,
+            model: modelId,
+            dim: encoded[at].length,
+            vec: encoded[at],
+            textHash: item.digest,
+            updatedAt: item.row.updated_at,
+          })));
         }
-        stats.encoded += need.length;
-        stats.upserted += need.length;
+        stats.encoded += pending.length;
+        stats.upserted += pending.length;
       }
 
-      // 进度前移（失败保留进度可续跑）：用「本批已扫到的最大 updated_at」，重扫边界条幂等
-      if (!dryRun) {
-        setMetaFor(db, META_KEYS.modelId, src, modelId);
-        setMetaFor(db, META_KEYS.dim, src, String(dim));
-        if (!metaHost) setMeta(db, META_KEYS.hostId, String(store.hostId || ''));
-        setMetaFor(db, META_KEYS.lastIncrementalSyncAt, src, String(maxSeenUpdatedAt));
-      }
-      log(
-        `[sync] 批 ${stats.batches}：扫 ${page.length} 条（新编码 ${need.length} / 同哈希跳过 ${
-          page.length - need.length
-        }）水位=${maxSeenUpdatedAt}`,
-      );
+      // 进度前移取「本批扫到的最大 updated_at」：边界条下轮会再扫一遍，靠同哈希幂等兜住。
+      if (!dryRun) advanceLevel(high);
+      log(`[sync] 批 ${stats.batches}：扫 ${page.length} 条（新编码 ${pending.length} / 同哈希跳过 ${page.length - pending.length}）水位=${high}`);
       if (!untilEmpty) break;
+      afterId = tailId;
+      page = source.incrementalPage(level, afterId, batchSize);
     }
-    stats.watermarkEnd = maxSeenUpdatedAt;
+    stats.watermarkEnd = high;
   } catch (e) {
-    stats.failures.push({ stage: 'sync', message: String(e && e.message ? e.message : e), atBatch: stats.batches });
-    stats.watermarkEnd = maxSeenUpdatedAt; // 已成功批次的水位已落盘
+    stats.failures.push({ stage: 'sync', message: errText(e), atBatch: stats.batches });
+    // 已成功批次的进度早就落盘了，这里只是把读数对齐
+    stats.watermarkEnd = high;
     stats.error = stats.failures[0].message;
   }
 
-  stats.vectorsAfter = countVectors(db, src);
-  stats.finishedAt = now();
-  stats.elapsedMs = stats.finishedAt - stats.startedAt;
+  stats.vectorsAfter = vectors.countVectors(conn, origin);
+  const finishedAt = now();
+  stats.finishedAt = finishedAt;
+  stats.elapsedMs = finishedAt - stats.startedAt;
   if (!dryRun) {
-    setMetaFor(
-      db,
-      META_KEYS.lastSyncStats,
-      src,
-      JSON.stringify({
-        source: src,
-        mode: stats.mode,
-        scanned: stats.scanned,
-        encoded: stats.encoded,
-        skippedSameHash: stats.skippedSameHash,
-        watermarkEnd: stats.watermarkEnd,
-        elapsedMs: stats.elapsedMs,
-        failures: stats.failures.length,
-        at: new Date(stats.finishedAt).toISOString(),
-      }),
-    );
+    const brief = {
+      source: origin, mode: stats.mode, scanned: stats.scanned,
+      encoded: stats.encoded, skippedSameHash: stats.skippedSameHash,
+      watermarkEnd: stats.watermarkEnd, elapsedMs: stats.elapsedMs,
+      failures: stats.failures.length, at: new Date(finishedAt).toISOString(),
+    };
+    vectors.setMetaFor(conn, vectors.META_KEYS.lastSyncStats, origin, JSON.stringify(brief));
   }
   return stats;
 }