memhouse 0.18.12 → 0.20.1

package/memhouse/shipper/adapter-capture.js

@@ -0,0 +1,756 @@
+'use strict';
+// Capture through @agent-realm/harness-session-adapters: memhouse as a sessions v0 consumer (step 3 of
+// the switch, designed 2026-10-23: the package reads and derives each store, memhouse archives what is
+// new and writes only the rows that changed).
+//
+// One store at a time. `list` names the sessions and their sources; per session, every source is
+// read from its position, the new units are archived, `derive` runs over what is new, and only the
+// rows that changed are written. The table shapes are not this module's: a `mapping` turns a
+// session's record view into rows (records-to-rows for schema 3; harness-sessions-sql's profile in step B).
+//
+// Where the state lives. The house is the truth, the local state an accelerator:
+//   a source's generation, position and known units   its `files` row (file_key = source_key,
+//                                                     fgen = generation, derive_state = {position,
+//                                                     known, ords})
+//   the units                                         archive `records`, kind 'unit', raw = the unit
+//                                                     as JSON, in 1 MiB chunks
+//   derive state, record view, row hashes, first-seen times, last rev
+//                                                     $MEMHOUSE_HOME/state/derive/<sha1>.json
+// Lost or stale local state is never a loss: the session refolds from its archived units, every
+// row is written again at a higher rev, and keys the house holds that the refold no longer
+// produces become removed versions.
+//
+// Write order, as capture.js: archive, then rows, then files, then sessions; the local state last.
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const base = require('../../editors/base').capture;
+const recordsToRows = require('../house/records-to-rows');
+const { ADAPTER: BRIDGE } = require('./log-adapter');
+
+const CHUNK = 1 << 20;
+const EPOCH_ISO = '1970-01-01T00:00:00.000Z';
+
+/**
+ * The package. MEMHOUSE_SESSION_ADAPTERS names a package root for development (a harness-skeleton
+ * checkout's packages/harness-session-adapters, kept outside git); otherwise the installed
+ * dependency. A failure to load it says where it looked (PACKAGE_UNLOADABLE), so a pass never takes
+ * it for one store's error. A package whose adapters for the harnesses memhouse reads through it
+ * (ADAPTER_HARNESSES) still name themselves @agent-realm/session-adapters/… predates the rename:
+ * their rows would read as another adapter's (profile-capture.js, adapter switch), and a pass would
+ * re-read and re-archive every session. It is refused (PACKAGE_RENAMED).
+ */
+const PACKAGE_NAME = '@agent-realm/harness-session-adapters';
+const OLD_ADAPTER_PREFIX = '@agent-realm/session-adapters';
+const ADAPTER_HARNESSES = ['claude-code', 'codex'];
+const PACKAGE_MISSING = 'harness-session-adapters missing: Claude Code and Codex are not captured on the profile layout (install @agent-realm/harness-session-adapters)';
+const PACKAGE_UNLOADABLE = 'harness-session-adapters could not be loaded, so Claude Code and Codex are not captured';
+const PACKAGE_RENAMED = 'harness-session-adapters is from before its rename, so Claude Code and Codex are not captured';
+function loadPackage(env = process.env) {
+  const root = env.MEMHOUSE_SESSION_ADAPTERS;
+  const where = root ? `MEMHOUSE_SESSION_ADAPTERS=${root}` : PACKAGE_NAME;
+  let pkg;
+  try { pkg = root ? require(path.join(path.resolve(root), 'src', 'index.js')) : require(PACKAGE_NAME); }
+  catch (e) { throw new Error(`${PACKAGE_UNLOADABLE} (${where}): ${String((e && e.message) || e).split('\n')[0]}`); }
+  const isOld = (a) => a === OLD_ADAPTER_PREFIX || a.startsWith(`${OLD_ADAPTER_PREFIX}/`);
+  const old = ADAPTER_HARNESSES.filter((h) => {
+    try { return isOld(String(pkg.adapterFor(h).describe().adapter || '')); } catch { return false; }
+  });
+  if (old.length) {
+    throw new Error(`${PACKAGE_RENAMED}: ${where} names its ${old.join(' and ')} adapter${old.length > 1 ? 's' : ''} ${OLD_ADAPTER_PREFIX}/…. ${root
+      ? 'Point MEMHOUSE_SESSION_ADAPTERS at packages/harness-session-adapters of an updated harness-skeleton checkout, or unset it to use the installed package.'
+      : `Reinstall memhouse, which depends on ${PACKAGE_NAME}.`}`);
+  }
+  return pkg;
+}
+
+/** The loaded package's version, from its package.json (1.0.0 exports none). '' when unknown. */
+function packageVersion(env = process.env) {
+  try {
+    const root = env.MEMHOUSE_SESSION_ADAPTERS;
+    if (root) return String(JSON.parse(fs.readFileSync(path.join(path.resolve(root), 'package.json'), 'utf-8')).version || '');
+    for (let dir = path.dirname(require.resolve(PACKAGE_NAME)), i = 0; i < 4; dir = path.dirname(dir), i++) {
+      const f = path.join(dir, 'package.json');
+      if (!fs.existsSync(f)) continue;
+      const p = JSON.parse(fs.readFileSync(f, 'utf-8'));
+      if (p.name === PACKAGE_NAME) return String(p.version || '');
+    }
+  } catch { /* unknown */ }
+  return '';
+}
+
+/** Whether the package loads: { ok, version } or { ok: false, error }. Never throws. */
+function packageStatus(env = process.env) {
+  try {
+    const pkg = loadPackage(env);
+    return { ok: true, version: String((pkg && pkg.version) || packageVersion(env)) };
+  } catch (e) { return { ok: false, error: String((e && e.message) || e).split('\n')[0] }; }
+}
+
+/** Whether an adapter's error is the package failing to load at all, or loading from before the rename. */
+const isPackageMissing = (msg) => String(msg || '').startsWith(PACKAGE_UNLOADABLE) || String(msg || '').startsWith(PACKAGE_RENAMED)
+  || /Cannot find module '@agent-realm\/harness-session-adapters'|MEMHOUSE_SESSION_ADAPTERS/.test(String(msg || ''))
+  || /Cannot find module '[^']*harness-session-adapters[^']*'/.test(String(msg || ''));
+
+/** What a pass or doctor says about such an error: loadPackage's own errors say what and where. */
+const packageMessage = (msg) => (String(msg || '').startsWith(PACKAGE_UNLOADABLE) || String(msg || '').startsWith(PACKAGE_RENAMED)
+  ? String(msg) : PACKAGE_MISSING);
+
+const sha1 = (s) => crypto.createHash('sha1').update(s).digest('hex');
+const sessionId = (k) => [k.host, k.harness, k.harness_path, k.session_id, k.incarnation || ''].join('\u0000');
+
+/**
+ * "0.1.0" as the UInt32 the adapter_ver columns hold: 10^9 + major·10^6 + minor·10^3 + patch. The
+ * 10^9 floor keeps every package row apart from the 0.20 engines' (Claude Code 2, Codex 3, the log
+ * derive 1005), so a session switching to the package can tell its old rows from its own.
+ */
+const PACKAGE_VER_FLOOR = 1e9;
+function verNumber(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(String(v || ''));
+  return m ? PACKAGE_VER_FLOOR + Number(m[1]) * 1e6 + Number(m[2]) * 1e3 + Number(m[3]) : 0;
+}
+const isPackageRow = (r) => Number(r.adapter_ver) >= PACKAGE_VER_FLOOR;
+
+/** JSON with object keys sorted: the canonical form for the scalars and plain objects a link key holds. */
+function canon(v) {
+  if (Array.isArray(v)) return `[${v.map(canon).join(',')}]`;
+  if (v && typeof v === 'object') return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canon(v[k])}`).join(',')}}`;
+  return JSON.stringify(v === undefined ? null : v);
+}
+/** A record's own key in its session, as `live` lists it (sessions §2). */
+function recordKey(r) {
+  switch (r.type) {
+    case 'session': return '';
+    case 'message': return String(r.message_id);
+    case 'usage': return String(r.usage_id);
+    case 'lifecycle': return String(r.lifecycle_id);
+    case 'link': return canon([r.kind, r.stated_on === 'origin' ? r.child : r.origin, r.at ?? '']);
+    default: throw new Error(`unknown record type ${r.type}`);
+  }
+}
+/** The view after one derive: `changed` upserted, then every key absent from both `live` and `held` dropped. */
+function applyDerive(view, { changed, live, held = {} }) {
+  const next = new Map(view);
+  for (const r of changed) next.set(`${r.type}\u0000${recordKey(r)}`, r);
+  const keep = new Set();
+  for (const set of [live || {}, held || {}]) for (const [type, keys] of Object.entries(set)) for (const k of keys) keep.add(`${type}\u0000${k}`);
+  for (const k of [...next.keys()]) if (!keep.has(k)) next.delete(k);
+  return next;
+}
+
+// ── local state ──────────────────────────────────────────────────────────────────────────────
+/** `ns`: the state's namespace, one per table layout ('derive' for schema 3, 'derive-profile'). */
+function statePath(home, key, ns = 'derive') { return path.join(home, 'state', ns, `${sha1(sessionId(key))}.json`); }
+function loadLocal(home, key, ns) {
+  try {
+    const s = JSON.parse(fs.readFileSync(statePath(home, key, ns), 'utf-8'));
+    return s && s.v === 1 && s.id === sessionId(key) ? s : null;
+  } catch { return null; }
+}
+function saveLocal(home, key, s, ns) {
+  const f = statePath(home, key, ns);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = `${f}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...s, v: 1, id: sessionId(key) }), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+}
+
+// ── archive ──────────────────────────────────────────────────────────────────────────────────
+/** One unit as archive rows: its JSON, chunked; `pos` orders it within its source's generation. */
+function unitRows(key, sourceKey, gen, pos, unit, capturedAt) {
+  const raw = JSON.stringify(unit);
+  const rows = [];
+  for (let i = 0, c = 0; i < raw.length || c === 0; i += CHUNK, c++) {
+    rows.push({ harness: key.harness, harness_path: key.harness_path, session_id: key.session_id, incarnation: key.incarnation || '',
+      file_key: sourceKey, fgen: gen, pos, chunk: c, sha: unit.sha256, kind: 'unit', enc: '', raw: raw.slice(i, i + CHUNK), host: key.host, captured_at: capturedAt });
+  }
+  return rows;
+}
+/** The units of one generation, back from their archive rows. */
+function unitsFromArchive(rows) {
+  const byPos = new Map();
+  for (const r of rows) {
+    if (r.kind !== 'unit') continue;
+    const k = Number(r.pos);
+    if (!byPos.has(k)) byPos.set(k, []);
+    byPos.get(k).push(r);
+  }
+  return [...byPos.keys()].sort((a, b) => a - b).map((k) => JSON.parse(byPos.get(k).sort((a, b) => a.chunk - b.chunk).map((r) => r.raw).join('')));
+}
+
+// ── rows ─────────────────────────────────────────────────────────────────────────────────────
+function tsWire(iso) { const ms = Date.parse(iso); return base.chTs(Number.isFinite(ms) ? ms : 0); }
+/** schema 3 rows from the mapping's output, every column filled. */
+function schema3Rows(mapped, key, { rev, adapterVer }) {
+  const meta = mapped.meta || {};
+  const folder = String(meta.folder || '');
+  const project = folder ? folder.replace(/\/+$/, '').split('/').pop() : '';
+  const turns = mapped.turns.map((t) => {
+    const full = base.cleanText(t.text);
+    const cap = t.kind === 'tool_result' || t.kind === 'tool_call' ? base.TOOL_RESULT_CAP : base.TEXT_CAP;
+    return {
+      harness: key.harness, harness_version: String(meta.harness_version || ''), harness_path: key.harness_path, session_id: key.session_id,
+      incarnation: key.incarnation || '', agent_id: String(t.agent_id || ''), message_id: String(t.message_id), part_id: String(t.part_id),
+      part_ord: Number(t.part_ord) || 0, parent_id: String(t.parent_id || ''), response_id: String(t.response_id || ''), ts: tsWire(t.ts),
+      ord: Number(t.ord) || 0, rev: String(rev), is_deleted: 0, removed: 0, state: String(t.state || ''), role: String(t.role), kind: String(t.kind),
+      model: String(t.model || ''), effort: String(t.effort || ''),
+      input_tokens: t.input_tokens || 0, output_tokens: t.output_tokens || 0, cache_read_tokens: t.cache_read_tokens || 0,
+      cache_write_tokens: t.cache_write_tokens || 0, reasoning_tokens: t.reasoning_tokens || 0,
+      text: base.capText(full, cap), text_len: full.length, folder, project, host: key.host, origin: 'ship',
+      extra: JSON.stringify(t.extra || {}), adapter_ver: adapterVer,
+    };
+  });
+  const byMsg = new Map(turns.map((t) => [t.message_id, t]));
+  const calls = mapped.calls.filter((c) => c.tool_name !== undefined).map((c) => ({
+    harness: key.harness, harness_path: key.harness_path, session_id: key.session_id, incarnation: key.incarnation || '',
+    agent_id: String(c.agent_id || ''), call_id: String(c.call_id), message_id: String(c.message_id),
+    ts: c.ts ? tsWire(c.ts) : (byMsg.get(String(c.message_id)) || {}).ts || base.chTs(0), rev: String(rev), is_deleted: 0, removed: 0,
+    tool_name: String(c.tool_name || ''), args: base.capText(base.cleanText(c.args || '{}'), base.ARGS_CAP),
+    result_ts: c.result_ts ? tsWire(c.result_ts) : null, is_error: !!c.is_error, result_len: Number(c.result_len) || 0,
+    model: String(c.model || ''), folder, project, host: key.host, adapter_ver: adapterVer,
+  }));
+  return { turns, calls };
+}
+/** What a row says, without its rev: equal digests mean nothing to write. */
+function rowDigest(r) { const { rev: _r, ...rest } = r; return sha1(JSON.stringify(rest)); }
+/** The session's exact totals over its rows (base's contributions), with the metadata buildSession reads. */
+function contribOf(rows, meta) {
+  const c = base.newContrib();
+  for (const t of rows.turns) base.applyTurn(c, t, 1);
+  for (const k of rows.calls) base.applyCall(c, k, 1);
+  const firstUser = rows.turns.filter((t) => t.role === 'user' && t.kind === 'text' && !t.agent_id && t.text).sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : a.ord - b.ord))[0];
+  c.meta = {
+    ...(meta && meta.folder ? { folder: meta.folder } : {}), ...(meta && meta.title ? { title: meta.title } : {}),
+    ...(meta && meta.harness_version ? { version: meta.harness_version } : {}), ...(firstUser ? { first_prompt: firstUser.text.slice(0, 200) } : {}),
+  };
+  return base.serializeContrib(c);
+}
+
+/**
+ * Which 0.20 engine rows the package's view supersedes. The two key the same content differently, so
+ * content decides: a turn by kind and text (a textless one by its message and part id), a call by its
+ * call_id. Each view row answers for one row the house holds, and a view row that replaced a row under
+ * the same key has answered already: two engine rows with one text, where the source now holds that
+ * text once, are one duplicate and one removed line. Returns (kind, row) => is it a duplicate.
+ */
+function twinsOf(rows, cur, digests) {
+  const sig = { turns: (r) => (r.text ? `${r.kind}\u0000${r.text}` : `${r.kind}\u0000\u0000${r.message_id}\u0000${r.part_id}`), calls: (r) => String(r.call_id) };
+  const bag = { turns: new Map(), calls: new Map() };
+  const take = (kind, r) => { const k = sig[kind](r); const n = bag[kind].get(k) || 0; if (!n) return false; bag[kind].set(k, n - 1); return true; };
+  for (const r of rows.turns) bag.turns.set(sig.turns(r), (bag.turns.get(sig.turns(r)) || 0) + 1);
+  for (const r of rows.calls) bag.calls.set(sig.calls(r), (bag.calls.get(sig.calls(r)) || 0) + 1);
+  for (const r of cur.turns) if (base.turnKey(r) in digests.t) take('turns', r);
+  for (const r of cur.calls) if (base.callKey(r) in digests.c) take('calls', r);
+  return take;
+}
+
+/**
+ * Capture one session. `ctx`: { house, home, host, now(), mapping? }. `ad`: the harness's adapter;
+ * `d`: its describe(). `listed`: its `list` entry. Returns what it did.
+ */
+async function captureSession(ctx, ad, d, store, listed) {
+  const key = { ...store, session_id: listed.session_id, incarnation: listed.incarnation ?? '' };
+  const ref = { harness: key.harness, host: key.host, harness_path: key.harness_path, session_id: key.session_id, incarnation: key.incarnation };
+  const out = { session_id: key.session_id, archived: 0, turns: 0, calls: 0, removed: 0, refold: false, skipped: false, more: false };
+  let local = loadLocal(ctx.home, key);
+  const H = new Map((await ctx.house.filesRows([ref])).map((r) => [r.file_key, r]));
+  // The local state counts only while it agrees with the house on every source it read.
+  if (local && (local.adapter_ver !== d.adapter_ver || local.state_ver !== d.state_ver
+    || Object.entries(local.sources || {}).some(([sk, s]) => { const h = H.get(sk); return !h || Number(h.fgen) !== s.gen || String(h.upto) !== String(s.upto); }))) local = null;
+  const reDerive = !local && [...H.values()].some((h) => h.role !== 'legacy' && h.role !== 'inherited');
+  const capturedAt = base.chTs(ctx.now());
+  const sources = {};
+  const archive = [];
+  const fresh = [];
+  let full = !local;
+  for (const src of listed.sources) {
+    const sk = src.source_key;
+    const h = H.get(sk);
+    // A files row the package wrote seeds the source. A 0.20 engine's row under the same key (its
+    // file_key can equal a source_key: a Codex rollout's base name) does not: its state is the old
+    // engine's, so the source starts from nothing in the generation past it, and the package's row
+    // (a higher fgen, so a higher ver) replaces it.
+    const pkgRow = h && isPackageRow(h);
+    const prior = local ? local.sources[sk] : (pkgRow ? { gen: Number(h.fgen), upto: String(h.upto), ...JSON.parse(h.derive_state || '{}') } : null);
+    let gen = prior ? prior.gen : (h ? Number(h.fgen) + 1 : 0);
+    const ords = { ...(prior && prior.ords) };
+    let next = Object.keys(ords).length ? Math.max(...Object.values(ords)) + 1 : 0;
+    const known = prior && prior.known && Object.keys(prior.known).length ? prior.known : null;
+    // One capped read per source per step (the package reads at most 64 MiB and says `more`). A big
+    // session is captured over several steps, each derived and written on its own, so memory holds
+    // one cap of units and that step's records, never the whole transcript.
+    const r = ad.read(store, key, sk, prior ? prior.position ?? null : null, known);
+    if (r.more) out.more = true;
+    let units = [];
+    let gone = r.gone || [];
+    let knownNext = { ...(known || {}) };
+    switch (r.continuity) {
+      case 'reset':
+        gen = prior ? gen + 1 : gen;
+        units = r.units; gone = [];
+        knownNext = {};
+        full = true;
+        for (const k of Object.keys(ords)) delete ords[k];
+        next = 0;
+        break;
+      case 'snapshot':
+        units = r.units; knownNext = {};
+        break;
+      case 'appended': case 'delta':
+        units = r.units;
+        break;
+      case 'unchanged':
+        break;
+      default: throw new Error(`${sk}: unknown continuity ${r.continuity}`);
+    }
+    for (const k of gone) delete knownNext[k];
+    for (const u of units) {
+      knownNext[u.unit_key] = u.sha256;
+      const stream = /^\d+$/.test(String(u.unit_key)) && src.mode === 'stream';
+      if (!stream && ords[u.unit_key] === undefined) ords[u.unit_key] = next++;
+      const pos = stream ? Number(u.unit_key) : ords[u.unit_key];
+      archive.push(...unitRows(key, sk, gen, pos, u, capturedAt));
+    }
+    const upto = r.position && Number.isFinite(Number(r.position.offset)) ? String(r.position.offset)
+      : String((prior ? Number(prior.upto) : 0) + (units.length || gone.length ? 1 : 0));
+    sources[sk] = { gen, upto, position: r.position ?? null, known: src.mode === 'stream' ? {} : knownNext, ords: src.mode === 'stream' ? {} : ords, role: src.role || 'main' };
+    if (units.length || gone.length) fresh.push({ source_key: sk, generation: gen, complete: false, units, gone });
+  }
+  out.archived = archive.length;
+  if (!full && !fresh.length) {
+    // Nothing new. Positions that moved without units (a held-back tail) are still kept.
+    if (local && Object.entries(sources).every(([sk, s]) => canon(s.position) === canon((local.sources[sk] || {}).position))) { out.skipped = true; return out; }
+  }
+  if (archive.length) await ctx.house.insert('records', archive);
+
+  // The input. A full refold takes every unit of every source's current generation from the archive.
+  let input = fresh;
+  if (full) {
+    input = [];
+    for (const [sk, s] of Object.entries(sources)) {
+      const units = unitsFromArchive(await ctx.house.archiveUnits(ref, sk, s.gen));
+      input.push({ source_key: sk, generation: s.gen, complete: true, units, gone: [] });
+    }
+  }
+  const res = ad.derive(key, input, full ? null : local.state);
+  const oldView = new Map(full ? [] : (local.view || []));
+  const view = applyDerive(oldView, res);
+  const firstSeen = { ...(local && local.firstSeen) };
+  // A refold reads what the house holds for the session once: first-seen times, the rev floor, and
+  // the keys to retire.
+  const cur = full ? await ctx.house.capturedRows(ref) : null;
+  if (cur) for (const r of cur.turns) if (!firstSeen[r.message_id]) firstSeen[r.message_id] = new Date(Date.parse(`${r.ts.replace(' ', 'T')}Z`)).toISOString();
+  const nowIso = new Date(ctx.now()).toISOString();
+  const tsOf = (id) => (firstSeen[id] || (firstSeen[id] = nowIso));
+  const mapped = (ctx.mapping || recordsToRows.rowsOf)([...view.values()], { tsOf });
+  // rev is at least last + 1 (harness-sessions-sql §7): the local state's last rev, or on a refold the house's
+  // greatest for the session, so a clock that went back (a restored VM) never writes below it.
+  let lastRev = BigInt(local ? local.lastRev : 0);
+  if (cur) for (const r of [...cur.turns, ...cur.calls]) if (r.rev != null && BigInt(r.rev) > lastRev) lastRev = BigInt(r.rev);
+  const rev = BigInt(ctx.now()) > lastRev ? BigInt(ctx.now()) : lastRev + 1n;
+  const adapterVer = verNumber(d.adapter_ver);
+  const rows = schema3Rows(mapped, key, { rev, adapterVer });
+
+  // What to write: rows whose digest moved; removed versions for keys the house holds and the view no longer makes.
+  const digests = { t: {}, c: {} };
+  for (const t of rows.turns) digests.t[base.turnKey(t)] = rowDigest(t);
+  for (const c of rows.calls) digests.c[base.callKey(c)] = rowDigest(c);
+  const old = local ? local.digests : null;
+  const writeT = rows.turns.filter((t) => !old || old.t[base.turnKey(t)] !== digests.t[base.turnKey(t)]);
+  const writeC = rows.calls.filter((c) => !old || old.c[base.callKey(c)] !== digests.c[base.callKey(c)]);
+  let goneT; let goneC;
+  if (old) {
+    goneT = Object.keys(old.t).filter((k) => !(k in digests.t));
+    goneC = Object.keys(old.c).filter((k) => !(k in digests.c));
+  } else {
+    // A held record (incomplete: neither written nor removed) is absent from a refold's view, so its
+    // rows are not "gone": they keep their last version (sessions §2).
+    const heldMsg = new Set((res.held && res.held.message) || []);
+    const heldUsage = new Set(((res.held && res.held.usage) || []).map((u) => `usage:${u}`));
+    const kept = (r) => { const id = String(r.message_id); return heldMsg.has(id) || heldUsage.has(id.replace(/~+$/, '')); };
+    goneT = cur.turns.filter((r) => !kept(r)).map(base.turnKey).filter((k) => !(k in digests.t));
+    goneC = cur.calls.filter((r) => !kept(r)).map(base.callKey).filter((k) => !(k in digests.c));
+  }
+  const tKeys = goneT.map((k) => { const [ts, message_id, part_id] = k.split('\u0000'); return { ts, message_id, part_id }; });
+  const cKeys = goneC.map((k) => { const [ts, call_id] = k.split('\u0000'); return { ts, call_id }; });
+  // A key the package made and no longer makes left the source: a removed version. A key the 0.20
+  // engine made (a session switching to the package) is a superseded duplicate, a tombstone, only
+  // when the view holds its content (twinsOf). Engine content the view lacks left the source before
+  // the switch, or is a kind the package does not make: kept as a removed version (sessions §4).
+  const twin = cur ? twinsOf(rows, cur, digests) : () => false;
+  const retire = (kind) => (r) => (!isPackageRow(r) && twin(kind, r) ? base.tombstoneOf(kind, r, rev) : base.removedOf(kind, r, rev));
+  const removedT = tKeys.length ? (await ctx.house.rowsByKey('turns', ref, tKeys)).map(retire('turns')) : [];
+  const removedC = cKeys.length ? (await ctx.house.rowsByKey('calls', ref, cKeys)).map(retire('calls')) : [];
+  if (writeT.length || removedT.length) await ctx.house.insert('turns', [...writeT, ...removedT]);
+  if (writeC.length || removedC.length) await ctx.house.insert('calls', [...writeC, ...removedC]);
+  out.turns = writeT.length; out.calls = writeC.length; out.refold = full; out.reDerive = reDerive;
+  out.removed = [...removedT, ...removedC].filter((r) => Number(r.removed)).length;
+  out.superseded = [...removedT, ...removedC].filter((r) => Number(r.is_deleted)).length;
+
+  // The sources' files rows: the session's totals ride on its first main source.
+  const contrib = contribOf(rows, mapped.meta);
+  const mainSk = Object.keys(sources).find((sk) => sources[sk].role === 'main') || Object.keys(sources)[0];
+  const empty = base.serializeContrib(base.newContrib());
+  const files = Object.entries(sources).map(([sk, s]) => {
+    const c = sk === mainSk ? contrib : empty;
+    const anchor = s.position && /^[0-9a-f]{64}$/.test(String(s.position.anchor_sha || '')) ? s.position.anchor_sha : sha1('').padEnd(64, '0');
+    return {
+      harness: key.harness, harness_path: key.harness_path, session_id: key.session_id, incarnation: key.incarnation || '',
+      file_key: sk, agent_id: '', role: s.role === 'agent' || s.role === 'side' ? s.role : 'main', agent_type: '', agent_desc: '',
+      fgen: s.gen, upto: s.upto, reparse_from: 0, derive_state: JSON.stringify({ position: s.position, known: s.known, ords: s.ords }),
+      adapter_ver: adapterVer, size: Number(s.position && s.position.offset) || 0, inode: Number(s.position && s.position.inode) || 0,
+      anchor_sha: anchor, prefix_sha: anchor, is_deleted: 0, contrib: JSON.stringify(c),
+      first_ts: c.first_ts || '1970-01-01 00:00:00.000', last_ts: c.last_ts || '1970-01-01 00:00:00.000', host: key.host,
+    };
+  });
+  // The 0.20 engine's files rows of this session (sources the package names otherwise) retire with
+  // their rows, or buildSession would add their totals to the package's.
+  const listedKeys = new Set(listed.sources.map((s) => s.source_key));
+  const SERVER = new Set(['ver', 'user_id']);
+  const oldFiles = [...H.values()].filter((h) => !listedKeys.has(h.file_key) && ['main', 'agent', 'side'].includes(h.role) && !Number(h.is_deleted) && !isPackageRow(h))
+    .map((h) => ({ ...Object.fromEntries(Object.entries(h).filter(([k]) => !SERVER.has(k))), is_deleted: 1, fgen: Number(h.fgen) + 1 }));
+  out.supersededFiles = oldFiles.length;
+  await ctx.house.insert('files', [...files, ...oldFiles]);
+  if (ctx.buildSession) {
+    const all = await ctx.house.filesRows([ref]);
+    await ctx.house.insert('sessions', [ctx.buildSession(key.harness, key.session_id, all, { host: key.host, hostLabel: ctx.hostLabel || '', harnessPath: key.harness_path, incarnation: key.incarnation })]);
+  }
+  if (res.checkpoint !== false) {
+    saveLocal(ctx.home, key, {
+      // The list hint is kept only once the last step is in: a pass that dies between steps must
+      // not skip the session next time.
+      adapter_ver: d.adapter_ver, state_ver: d.state_ver, hint: out.more ? null : canon(listed.updated_hint ?? null), state: res.state,
+      view: [...view.entries()], digests, firstSeen, lastRev: String(rev),
+      sources: Object.fromEntries(Object.entries(sources).map(([sk, s]) => [sk, { gen: s.gen, upto: s.upto, position: s.position, known: s.known, ords: s.ords }])),
+    });
+  }
+  return out;
+}
+
+/**
+ * The sessions of `store` the house holds, as far as `adapter` goes, on the profile layout: every
+ * session whose cursor (session_sources) names a source of `adapter` that is neither deleted nor
+ * gone, and every session `adapter` archived manifests for that has no cursor row of `adapter` at all
+ * (an anti-join): a replay from the archive alone (harness-sessions-sql §4.1), however far an interrupted one
+ * got, and a session whose first capture stopped before its first cursor write. An archive-only
+ * session whose every source's newest generation is source_gone is `allGone`: replaying it reads
+ * nothing of the store. A pass hands each one `list` no longer returns to the session capture (THE
+ * VANISH SWEEP below). One round trip, ordered by session. Another layout's house holds no such
+ * cursor: none. Returns [{ session_id, incarnation, allGone }].
+ */
+async function heldSessions(house, store, adapter) {
+  const P = house && house.P;
+  if (!P || !P.session_sources || typeof house.rows !== 'function') return [];
+  const { lit } = require('../house/convert-v3');
+  const where = `(host, harness, harness_path) = (${[store.host, store.harness, store.harness_path].map(lit).join(', ')})`;
+  const mine = `(adapter = ${lit(adapter)} OR adapter = '')`;
+  const cursored = `SELECT session_id, incarnation, max(is_deleted = 0 AND ${mine} AND NOT JSONExtractBool(state, 'gone')) AS live, toUInt8(0) AS all_gone
+      FROM ${P.session_sources} FINAL WHERE ${where} AND role != 'legacy' GROUP BY session_id, incarnation`;
+  const gone = "JSONExtractBool(raw, 'source_gone')";
+  const archived = !P.session_units ? '' : `
+    UNION ALL
+    SELECT session_id, incarnation, toUInt8(1) AS live, min(src_gone) AS all_gone FROM (
+      SELECT session_id, incarnation, source_key, toUInt8(countIf(${gone}) > 0 AND maxIf(generation, ${gone}) = max(generation)) AS src_gone
+        FROM ${P.session_units}
+        WHERE ${where} AND unit_key = '' AND enc = 'manifest' AND adapter = ${lit(adapter)}
+          AND (session_id, incarnation) NOT IN (SELECT session_id, incarnation FROM ${P.session_sources} WHERE ${where} AND role != 'legacy' AND ${mine})
+        GROUP BY session_id, incarnation, source_key)
+    GROUP BY session_id, incarnation`;
+  const rows = await house.rows(`SELECT session_id, incarnation, max(live) AS live, max(all_gone) AS all_gone FROM (${cursored}${archived})
+    GROUP BY session_id, incarnation ORDER BY session_id, incarnation`);
+  return rows.filter((r) => Number(r.live)).map((r) => ({ session_id: String(r.session_id), incarnation: String(r.incarnation || ''), allGone: !!Number(r.all_gone) }));
+}
+
+/**
+ * Capture every session of one harness store. A session whose `updated_hint` and adapter are what
+ * the local state last saw costs nothing past `list`. `ctx.captureSession` and `ctx.stateNs` swap
+ * in another layout's pass (profile-capture.js).
+ *
+ * THE VANISH SWEEP (each line is a decision)
+ *   candidates  a session the house holds (heldSessions) that `list` no longer returns. It is
+ *               captured with no source listed, so the session capture reads each source it held
+ *               and records it as vanished (profile-capture.js: a source_gone manifest with the
+ *               policy it applies, harness-sessions-sql §4.1) only when the adapter answers it is not there
+ *               (session_unknown, incarnation_gone, source_unknown); replaying an archive, a source
+ *               already gone there replays as its manifests say. The house is read before this pass
+ *               writes anything of the store
+ *   confirmed   by the adapter's own read, never by an absence: a list can come back empty or short
+ *               without throwing (a folder briefly missing, a DB file being replaced, a scan race),
+ *               and a vanish recorded from it re-archives the whole source in a new generation the
+ *               moment it is listed again. A candidate that still reads (`stillThere`) or whose read
+ *               fails (`candidateErrors`) is a refusal the pass reports. A listed session's source
+ *               the list left out that still reads is read as listed and counted `unconfirmed`, a
+ *               warning: an adapter may list a source only while it holds something (a sidebar row,
+ *               a summaries table) and still read it as empty
+ *   refused     when `list` names none of the sessions the house holds: an empty or unrelated list is
+ *               what a store that cannot be read looks like, and the adapter's read of that same store
+ *               would agree with it. Nothing of the store is taken as vanished (`vanishRefused`). An
+ *               archive-only session whose sources are all gone already is still replayed (it reads
+ *               nothing of the store)
+ *   confirmed   a store whose every session the editor deleted lists nothing, and is refused on every
+ *   empty       pass; the refusal records which sessions it refused (the ids of the held sessions that
+ *               are not all gone already, in the store's state: those replay under the refusal and
+ *               need no confirmation). `memhouse doctor --confirm-empty-store <harness>:<store>`
+ *               (confirmEmptyStore) writes a confirmation of exactly those, in a file of its own beside
+ *               the store's state, which a pass never rewrites: the pass claims it by renaming it, and
+ *               puts it back only where no newer one was written meanwhile. The next sweep that finds
+ *               the list still empty, the store's folder (or file) there and readable, and no session
+ *               held (all gone already aside) that was not confirmed lifts the refusal: the held
+ *               sessions go through the session capture's typed-read confirmation as any candidate
+ *               does, and vanish only on the adapter's answer. The confirmation is used up by that
+ *               sweep, unless candidates wait past the cap, failed to read or were not reached (a
+ *               stop): then it is put back as it is, and applies to what is left of its sessions. A
+ *               list that names a held session again, or a session held that was not confirmed,
+ *               discards it
+ *   bridge      never swept. The log adapter's stores (memhouse-bridge, harness-sessions-sql §4.1's exemption)
+ *               hold logs the normaliser never deletes, so a log missing from its list is an error,
+ *               and its read answers a missing log as an empty source, so it cannot confirm one
+ *   gate        the house is asked only when something can have left: no local store state yet (or
+ *               another house's or adapter's), a session the last pass listed is not listed now, or
+ *               the last sweep left something pending: a refusal, candidates past the cap, a candidate
+ *               that still read, failed or was not reached (a stop), a sweep read that failed, or an
+ *               empty-store confirmation waiting. A listed session's own error or refold does not
+ *               reopen it, nor does a candidate's refold (its outcome is one of the above). A quiet pass costs
+ *               nothing past `list`. The local store state ($MEMHOUSE_HOME/state/<ns>/stores/) is saved
+ *               after every pass whose list answered. It is this home's: a house replaced under the
+ *               same name while the home is kept is swept only once a listed session goes missing,
+ *               or after `state/<ns>/stores/` alone is removed (each session's state stays)
+ *   cap         at most ctx.vanishCap (VANISH_CAP) candidates a store pass, in session order from
+ *               where the last capped pass stopped (store state `after`), so candidates that keep
+ *               failing do not starve the rest; the others wait for the next pass (`vanishWaiting`).
+ *               The first pass after this lands meets every session the store deleted since profile
+ *               capture began, and each candidate costs a read
+ */
+const VANISH_CAP = 100;
+const storeIdOf = (store) => [store.host, store.harness, store.harness_path].join('\u0000');
+const storeStatePath = (home, store, ns) => path.join(home, 'state', ns, 'stores', `${sha1(storeIdOf(store))}.json`);
+function loadStoreState(home, store, ns) {
+  try {
+    const s = JSON.parse(fs.readFileSync(storeStatePath(home, store, ns), 'utf-8'));
+    return s && s.v === 1 && s.id === storeIdOf(store) && Array.isArray(s.listed) ? s : null;
+  } catch { return null; }
+}
+/** Whether a store's folder (or file) is there and can be read: a confirmed empty store must be. */
+function storeReadable(store) {
+  try {
+    const st = fs.statSync(store.harness_path);
+    if (st.isDirectory()) fs.readdirSync(store.harness_path); else fs.accessSync(store.harness_path, fs.constants.R_OK);
+    return true;
+  } catch { return false; }
+}
+/**
+ * The sessions a refusal refused, as a confirmation names them: the ids of the held sessions that are
+ * not all gone already (those replay under the refusal and need none), sorted. A confirmation applies
+ * while every such session held is one it names, however many of them have gone since.
+ */
+const refusedMark = (held) => { const ids = held.filter((h) => !h.allGone).map(idOfHeld).sort(); return { n: ids.length, ids }; };
+const idOfHeld = (h) => `${h.session_id}\u0000${h.incarnation ?? ''}`;
+const confirms = (confirm, held) => {
+  if (!Array.isArray(confirm.ids)) return false;
+  const named = new Set(confirm.ids);
+  return held.every((h) => h.allGone || named.has(idOfHeld(h)));
+};
+const confirmPath = (home, store, ns) => storeStatePath(home, store, ns).replace(/\.json$/, '.confirm.json');
+const claimedPath = (home, store, ns) => storeStatePath(home, store, ns).replace(/\.json$/, '.confirm.claimed');
+/** The empty-store confirmation waiting for `store`, claimed by a pass or not: what doctor wrote, or null. */
+function readConfirmation(home, store, ns) {
+  for (const f of [confirmPath(home, store, ns), claimedPath(home, store, ns)]) {
+    try { const c = JSON.parse(fs.readFileSync(f, 'utf-8')); if (c && c.v === 1 && c.id === storeIdOf(store)) return c; } catch { /* none */ }
+  }
+  return null;
+}
+/**
+ * `memhouse doctor --confirm-empty-store <harness>:<store>`: a confirmation that the sessions the last
+ * pass refused of that store were deleted (THE VANISH SWEEP: confirmed empty), written for every store
+ * of this home that matches. Returns { confirmed: [{ harness, harness_path, n }], notRefused: [...] }:
+ * a store whose last pass did not refuse it as empty has nothing to confirm.
+ */
+function confirmEmptyStore(home, ns, harness, harnessPath, at = Date.now()) {
+  const dir = path.join(home, 'state', ns, 'stores');
+  const out = { confirmed: [], notRefused: [] };
+  let names = [];
+  try { names = fs.readdirSync(dir).filter((x) => /^[0-9a-f]{40}\.json$/.test(x)); } catch { return out; }
+  for (const x of names) {
+    let s;
+    try { s = JSON.parse(fs.readFileSync(path.join(dir, x), 'utf-8')); } catch { continue; }
+    const [host, h, hp] = String((s && s.id) || '').split('\u0000');
+    if (!s || s.v !== 1 || h !== harness || hp !== harnessPath) continue;
+    const store = { host, harness: h, harness_path: hp };
+    if (!s.refused) { out.notRefused.push({ harness: h, harness_path: hp }); continue; }
+    const f = confirmPath(home, store, ns);
+    const tmp = `${f}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ v: 1, id: storeIdOf(store), at, n: s.refused.n, ids: s.refused.ids || [] }), { mode: 0o600 });
+    fs.renameSync(tmp, f);
+    out.confirmed.push({ harness: h, harness_path: hp, n: s.refused.n });
+  }
+  return out;
+}
+/**
+ * Write `c` to `to` unless a file is there (a newer confirmation doctor wrote): a hard link of a whole
+ * written file where the filesystem has them, else an exclusive create, which refuses in the same
+ * case. EEXIST is the newer one; any other link error (EPERM, ENOTSUP, EXDEV, ...: exFAT, some SMB or
+ * FUSE mounts) is only a filesystem without links. Returns 'written', 'newer' or 'failed'.
+ */
+function putBack(beside, to, c) {
+  const body = JSON.stringify(c);
+  const tmp = `${beside}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, body, { mode: 0o600 });
+    try { fs.linkSync(tmp, to); return 'written'; } catch (e) {
+      if (e && e.code === 'EEXIST') return 'newer';
+      try { fs.writeFileSync(to, body, { mode: 0o600, flag: 'wx' }); return 'written'; } catch (e2) { return e2 && e2.code === 'EEXIST' ? 'newer' : 'failed'; }
+    }
+  } catch { return 'failed'; } finally { try { fs.rmSync(tmp, { force: true }); } catch { /* gone */ } }
+}
+function saveStoreState(home, store, ns, s) {
+  const f = storeStatePath(home, store, ns);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = `${f}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...s, v: 1, id: storeIdOf(store) }), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+}
+async function captureStore(ctx, ad, store, { skip = null } = {}) {
+  const session = ctx.captureSession || captureSession;
+  const d = ad.describe();
+  const st = { harness: store.harness, harness_path: store.harness_path, sessions: 0, captured: 0, skipped: 0, kept: 0, vanished: 0, unlisted: 0, unconfirmed: 0, stillThere: 0, candidateErrors: 0, vanishRefused: null, vanishWaiting: 0,
+    steps: 0, refolds: 0, turns: 0, calls: 0, rows: 0, removed: 0, archived: 0, errors: [], refs: [] };
+  // A store whose list throws (an unreadable folder) reports it and captures nothing; the next stores go on.
+  // An adapter may name entries it had to leave out (list `errors`, as the log adapter does for a log
+  // it cannot stat): reported, and the rest captured.
+  let list;
+  try {
+    const got = ad.list(store);
+    list = [...got];
+    for (const x of (got && Array.isArray(got.errors) ? got.errors : [])) st.errors.push({ code: x.code, error: `list: ${x.error}` });
+  } catch (e) { st.errors.push({ code: e && e.code, error: `list: ${String(e && e.message).split('\n')[0]}` }); return st; }
+  // The vanish sweep (above). A house that cannot say what it holds reports it; the listed sessions
+  // are still captured.
+  const idOf = (x) => `${x.session_id}\u0000${x.incarnation ?? ''}`;
+  const adapter = String(d.adapter || d.harness || store.harness);
+  const P = ctx.house && ctx.house.P;
+  const sweeps = adapter !== BRIDGE && !!P && !!P.session_sources && typeof ctx.house.rows === 'function';
+  const ns = ctx.stateNs || 'derive';
+  const listedNow = list.map(idOf);
+  let prev = null; let confirm = null; let after = null; let refused = null;
+  if (sweeps) {
+    prev = ctx.home ? loadStoreState(ctx.home, store, ns) : null;
+    // A confirmation doctor wrote (header: confirmed empty), claimed by this pass.
+    if (ctx.home) {
+      try { fs.renameSync(confirmPath(ctx.home, store, ns), claimedPath(ctx.home, store, ns)); } catch { /* none written since */ }
+      confirm = readConfirmation(ctx.home, store, ns);
+    }
+    const now = new Set(listedNow);
+    st.swept = !prev || prev.house !== P.session_sources || prev.adapter !== adapter || !!prev.pending || prev.listed.some((id) => !now.has(id)) || !!confirm;
+    if (st.swept) {
+      try {
+        const held = await heldSessions(ctx.house, store, adapter);
+        let unlisted = held.filter((h) => !now.has(idOf(h)));
+        const namesNone = unlisted.length > 0 && unlisted.length === held.length;
+        // A confirmed empty store (header): a list that names a held session again, or other sessions
+        // held than were confirmed, discards it.
+        if (confirm && (!namesNone || (!list.length && !confirms(confirm, held)))) {
+          st.confirmDiscarded = !namesNone ? (held.length ? 'its list names a session again' : 'the house holds nothing of it any more') : `it holds a session the confirmation of ${confirm.n} does not name`;
+          confirm = null;
+        }
+        if (namesNone && !(confirm && !list.length && storeReadable(store))) {
+          st.vanishRefused = `its list names none of the ${held.length} session${held.length === 1 ? '' : 's'} the house holds of it${list.length ? '' : ' (the list is empty)'}`;
+          st.emptyStore = !list.length;
+          if (st.emptyStore) refused = refusedMark(held);
+          // Refused, an archive-only session whose sources are all gone already is still replayed.
+          unlisted = unlisted.filter((h) => h.allGone);
+        } else if (namesNone) st.confirmedEmpty = true;
+        const cap = Number.isFinite(ctx.vanishCap) ? ctx.vanishCap : VANISH_CAP;
+        // In session order, from where the last capped pass stopped (header: cap).
+        unlisted.sort((x, y) => (idOf(x) < idOf(y) ? -1 : idOf(x) > idOf(y) ? 1 : 0));
+        const from = prev && prev.after != null && unlisted.length > cap ? unlisted.findIndex((h) => idOf(h) > prev.after) : -1;
+        if (from > 0) unlisted = [...unlisted.slice(from), ...unlisted.slice(0, from)];
+        const hand = unlisted.slice(0, cap);
+        st.unlisted = hand.length;
+        st.vanishWaiting = unlisted.length - hand.length;
+        after = st.vanishWaiting ? idOf(hand[hand.length - 1]) : null;
+        list.push(...hand.map((h) => ({ session_id: h.session_id, incarnation: h.incarnation, updated_hint: null, sources: [], unlisted: true })));
+      } catch (e) { st.sweepFailed = true; st.errors.push({ code: e && e.code, error: `vanished: ${String(e && e.message).split('\n')[0]}` }); }
+    }
+  }
+  const keyOf = (listed) => ({ ...store, session_id: listed.session_id, incarnation: listed.incarnation ?? '' });
+  const unchanged = (key, listed) => {
+    const local = loadLocal(ctx.home, key, ctx.stateNs);
+    return !!local && local.adapter_ver === d.adapter_ver && local.state_ver === d.state_ver && local.hint === canon(listed.updated_hint ?? null) && listed.updated_hint != null
+      // A store whose rows have a mapping version of their own (profile-capture's ROWS_VER): a state it moved past is read again.
+      && (ctx.rowsVer == null || (local.rows_ver || 1) === ctx.rowsVer)
+      // ...and one whose engine edges have a version of their own (profile-capture's EDGES_VER).
+      && (ctx.edgesVer == null || (local.edges_ver || 0) === ctx.edgesVer);
+  };
+  // The sessions to read are taken in groups: a group's first reads are made together (ctx.prefetch).
+  const GROUP = 50;
+  // A pass whose lock was taken over (capture.js passLock) stops before its next session.
+  const stopped = () => !!(ctx.stopped && ctx.stopped());
+  for (let g = 0; g < list.length && !st.stopped; g += GROUP) {
+    if (ctx.prefetch && !stopped()) {
+      const group = list.slice(g, g + GROUP).filter((listed) => { const key = keyOf(listed); return !(skip && skip(key, listed)) && !unchanged(key, listed); });
+      try { if (group.length) await ctx.prefetch(ctx, d, store, group); } catch { ctx.pre = null; /* each session reads its own */ }
+    }
+    for (const listed of list.slice(g, g + GROUP)) {
+      if (st.stopped || stopped()) { st.stopped = true; break; }
+      st.sessions++;
+      const key = keyOf(listed);
+      // A session another path keeps (capture.js: too big at first sight).
+      if (skip && skip(key, listed)) { st.kept++; continue; }
+      if (unchanged(key, listed)) { st.skipped++; continue; }
+      try {
+        let r; let first = true; let any = false; let gone = 0; let unconfirmed = 0;
+        do {
+          r = await session(ctx, ad, d, store, listed);
+          st.steps++;
+          gone += r.gone || 0; unconfirmed += r.unconfirmed || 0;
+          if (r.skipped) break;
+          any = true;
+          if (first) st.refolds += r.refold ? 1 : 0;
+          first = false;
+          st.turns += r.turns || 0; st.calls += r.calls || 0; st.rows += r.rows || 0; st.removed += r.removed; st.archived += r.archived;
+          // Between steps too: a session's next step is the new holder's (its local state is saved with
+          // no hint, so the next pass goes on from the step this one finished).
+          if (r.more && stopped()) { st.stopped = true; break; }
+        } while (r.more);
+        // A candidate is vanished when the adapter answered for every source it held; one that still
+        // reads was left out by a short list (a refusal the pass reports). A listed session's source the
+        // list left out that still reads is a warning (header: confirmed).
+        if (listed.unlisted) { if (unconfirmed) st.stillThere++; else if (gone) st.vanished++; } else st.unconfirmed += unconfirmed;
+        if (st.stopped) { st.more = 1; break; }
+        if (!any) { st.skipped++; continue; }
+        st.captured++;
+        st.refs.push({ harness: key.harness, host: key.host, harness_path: key.harness_path, session_id: key.session_id, incarnation: key.incarnation });
+      } catch (e) {
+        st.errors.push({ session_id: listed.session_id, code: e && e.code, error: String(e && e.message).split('\n')[0] });
+        if (listed.unlisted) st.candidateErrors++;
+      }
+    }
+    ctx.pre = null;
+  }
+  // What a stopped pass left: the session it stopped in, and the ones it did not reach (some of
+  // which may have had nothing new).
+  if (st.stopped) st.more = (st.more || 0) + list.length - st.sessions;
+  // The sweep's gate for the next pass (THE VANISH SWEEP: gate).
+  if (sweeps && ctx.home) {
+    // Pending: only what the sweep itself left (header: gate), never a listed session's error or refold.
+    const reached = st.sessions - (list.length - st.unlisted);
+    const pending = !!(st.vanishRefused || st.vanishWaiting || st.stillThere || st.candidateErrors || st.sweepFailed
+      || (st.stopped && st.unlisted && reached < st.unlisted));
+    try { saveStoreState(ctx.home, store, ns, { house: P.session_sources, adapter, listed: [...new Set(listedNow)].sort(), pending, ...(after != null ? { after } : {}), ...(refused ? { refused } : {}) }); }
+    catch { try { fs.rmSync(storeStatePath(ctx.home, store, ns), { force: true }); } catch { /* the next pass asks the house */ } }
+    // The claimed confirmation (header: confirmed empty): used up, or put back as it is, for what is left
+    // of its sessions (candidates waiting, failed or not reached) or while it did not apply (the
+    // store's folder away, a list that names nothing held). Put back only where doctor wrote none
+    // meanwhile: a newer one wins, and applies as any does.
+    const claimed = claimedPath(ctx.home, store, ns);
+    const back = confirm && (!st.confirmedEmpty || st.vanishWaiting || st.candidateErrors || st.stopped) ? confirm : null;
+    if (back) putBack(claimed, confirmPath(ctx.home, store, ns), back);
+    try { fs.rmSync(claimed, { force: true }); } catch { /* none */ }
+  }
+  return st;
+}
+
+module.exports = { PACKAGE_RENAMED, PACKAGE_UNLOADABLE, OLD_ADAPTER_PREFIX, packageMessage, packageVersion, PACKAGE_VER_FLOOR, isPackageRow, loadPackage, loadLocal, saveLocal, rowDigest, captureStore, captureSession, heldSessions, confirmEmptyStore, readConfirmation, loadStoreState, storeReadable, applyDerive, recordKey, canon, verNumber, unitsFromArchive, unitRows, schema3Rows, statePath, packageStatus, isPackageMissing, PACKAGE_MISSING,
+};