memhouse 0.18.12 → 0.20.1

package/editors/base.js

@@ -6,14 +6,6 @@ const HOME = os.homedir();
 
 // --- Permission check ---
 
-function isSubscriptionAccessAllowed() {
-  try {
-    const configPath = path.join(HOME, '.agentlytics', 'config.json');
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    return config.allowSubscriptionAccess === true;
-  } catch { return false; }
-}
-
 // --- Platform utilities ---
 
 /**
@@ -318,10 +310,472 @@ function queryMcpServerToolsStdio(server, timeout) {
   });
 }
 
+// <capture> ===================================================================================
+// The capture capability — docs/design/source-identity.md (draft 5) §2 and §5, and the build
+// contract in docs/design/source-identity-build.md. An adapter that captures exports
+//
+//   capture: {
+//     harness        'claude-code' | 'codex' — the `harness` column
+//     deriveVersion  integer, the `adapter_ver` column. Bumped on ANY change to what derive
+//                    emits; misc/capture-test.js holds a fingerprint of the derive code (this
+//                    region plus the adapter's own <derive> region) and fails until it is.
+//     sessions(root)          -> [session]      discovery under one source root {dir, name}
+//     sourceFiles(session)    -> [{ file_key, path, agent_id, role, agent_type, agent_desc, workflow }]
+//     derive({ file, records, state }) -> { turns, calls, contrib, state, reparse_from }
+//   }
+//
+// derive is a REPLAY: `records` are every complete record from the file's `reparse_from` (the
+// start of the earliest open unit) to its new `upto`, and `state` is the snapshot taken at
+// reparse_from. It returns every row the replay produces — including rows an earlier pass
+// already wrote — each carrying two hidden (non-enumerable) positions: `_src`, the record that
+// created it, and `_touch`, the last record that changed it. The engine writes only the rows
+// touched by bytes it has not derived before, and tombstones keys of the previous replay that
+// this one no longer produces (state.keys). Because the replay always starts from the same
+// snapshot, a file derived in one pass and the same file derived across many passes, cut at any
+// byte, produce the same live rows with the same keys (§2.6, checked in misc/capture-test.js).
+//
+// Identity (§2): a row's key is the whole ORDER BY — (toDate(ts), harness, session_id, ts,
+// message_id, part) for turns, (…, ts, call_id) for calls. `ts` is the source's own and never
+// moves: where a record has none, the first-seen time is stored once in state.fb and reused.
+// `rev` = fgen·2^40 + upto of the pass that wrote the row, so every later write of a key —
+// a revision, a tombstone, a re-derive after a lost cache — carries the same or a higher rev.
+
+const crypto = require('crypto');
+
+const CAPTURE_STATE_V = 2;   // 2: keys carry part_id (layout 3.2)
+const REV_SHIFT = 1n << 40n;
+const TEXT_CAP = Infinity;      // layout 3.2: full text in every row, tool output included (decided 2026-10-22)
+const TOOL_RESULT_CAP = Infinity;
+const ARGS_CAP = 20000;         // calls.args (as legacy tool_calls.args)
+const OPEN_CALLS_CAP = 64;      // calls awaiting a result kept in state; the oldest is closed as is
+const SEEN_CAP = 2048;          // recent keys: a verbatim re-append is counted once in contrib
+const FALLBACK_CAP = 10000;     // first-seen timestamps for records that carry none
+
+const TURN_COLUMNS = ['harness', 'harness_version', 'harness_path', 'session_id', 'incarnation', 'agent_id', 'message_id', 'part_id', 'part_ord',
+  'parent_id', 'response_id', 'ts', 'ord', 'rev', 'is_deleted', 'removed', 'state', 'role', 'kind', 'model', 'effort',
+  'input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens', 'reasoning_tokens',
+  'text', 'text_len', 'folder', 'project', 'host', 'origin', 'extra', 'adapter_ver'];
+const CALL_COLUMNS = ['harness', 'harness_path', 'session_id', 'incarnation', 'agent_id', 'call_id', 'message_id', 'ts', 'rev', 'is_deleted', 'removed',
+  'tool_name', 'args', 'result_ts', 'is_error', 'result_len', 'model', 'folder', 'project', 'host', 'adapter_ver'];
+
+function revOf(fgen, upto) { return BigInt(fgen || 0) * REV_SHIFT + BigInt(upto || 0); }
+
+// DateTime64(3) wire format, UTC: 'YYYY-MM-DD HH:MM:SS.mmm' (the shipper's convention).
+function chTs(ms) {
+  const d = new Date(ms);
+  const p = (n, w = 2) => String(n).padStart(w, '0');
+  return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())} `
+    + `${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}.${p(d.getUTCMilliseconds(), 3)}`;
+}
+function parseTs(v) {
+  if (typeof v === 'number' && Number.isFinite(v)) return v < 1e11 ? v * 1000 : v;
+  if (typeof v !== 'string' || !v) return NaN;
+  return Date.parse(v);
+}
+
+// Lone surrogates make ClickHouse refuse a whole JSONEachRow insert (see ship.js scrub()).
+// Removed, not replaced, so text stays comparable with the legacy rows during reconciliation.
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+function cleanText(s) { return (s == null ? '' : String(s)).replace(LONE_SURROGATE, ''); }
+function capText(s, n) {
+  if (s.length <= n) return s;
+  const c = s.slice(0, n);
+  const last = c.charCodeAt(c.length - 1);
+  return (last >= 0xD800 && last <= 0xDBFF) ? c.slice(0, -1) : c;
+}
+function num(v) { const n = Math.trunc(Number(v)); return Number.isFinite(n) && n > 0 ? n : 0; }
+
+function turnKey(r) { return `${r.ts}\u0000${r.message_id}\u0000${r.part_id}`; }
+function callKey(r) { return `${r.ts}\u0000${r.call_id}`; }
+function shortHash(s) { return crypto.createHash('sha1').update(s).digest('base64').slice(0, 12); }
+function hidden(o, name, value) { Object.defineProperty(o, name, { value, enumerable: false, writable: true, configurable: true }); }
+
+// ── contributions: a file's exact share of its session's totals ─────────────────────────────
+// Kept additive (with counts per day) so a revision subtracts its old row before adding the new.
+function newContrib() {
+  return { n: {}, usage: {}, tools: {}, days: {}, models: {}, agents: {}, first_ts: null, last_ts: null, meta: {} };
+}
+const N_FIELDS = ['messages', 'user_messages', 'assistant_messages', 'agent_messages', 'tool_calls',
+  'input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens', 'reasoning_tokens',
+  'user_chars', 'assistant_chars'];
+function bump(obj, k, by) { const v = (obj[k] || 0) + by; if (v) obj[k] = v; else delete obj[k]; }
+function seeTs(c, ms) {
+  if (!Number.isFinite(ms)) return;
+  if (c.first_ts === null || ms < c.first_ts) c.first_ts = ms;
+  if (c.last_ts === null || ms > c.last_ts) c.last_ts = ms;
+}
+// A row dated by first sighting (§2.1) lives on that day — it is in `days` — but it does not
+// move the session's first/last activity: a backfill would otherwise make every old session end today.
+function applyTurn(c, r, sign) {
+  const text = r.kind === 'text';
+  if (text) {
+    bump(c.n, 'messages', sign);
+    if (r.role === 'user') { bump(c.n, 'user_messages', sign); bump(c.n, 'user_chars', sign * r.text_len); }
+    if (r.role === 'assistant') {
+      bump(c.n, 'assistant_messages', sign); bump(c.n, 'assistant_chars', sign * r.text_len);
+      if (r.model) bump(c.models, r.model, sign);
+    }
+    if (r.agent_id) bump(c.n, 'agent_messages', sign);
+  }
+  const tok = [r.input_tokens, r.output_tokens, r.cache_read_tokens, r.cache_write_tokens, r.reasoning_tokens];
+  bump(c.n, 'input_tokens', sign * tok[0]); bump(c.n, 'output_tokens', sign * tok[1]);
+  bump(c.n, 'cache_read_tokens', sign * tok[2]); bump(c.n, 'cache_write_tokens', sign * tok[3]);
+  bump(c.n, 'reasoning_tokens', sign * tok[4]);
+  if (text || tok.some((x) => x)) {
+    const k = `${r.ts.slice(0, 13)}:00:00\u0000${r.model || ''}`;
+    const u = c.usage[k] || (c.usage[k] = [0, 0, 0, 0, 0, 0]);
+    u[0] += text ? sign : 0;
+    for (let i = 0; i < 5; i++) u[i + 1] += sign * tok[i];
+    if (u.every((x) => x === 0)) delete c.usage[k];
+  }
+  bump(c.days, r.ts.slice(0, 10), sign);
+  if (r.agent_id) {
+    const a = c.agents[r.agent_id] || (c.agents[r.agent_id] = [0, null]);
+    if (text) a[0] += sign;
+    const ms = Date.parse(r.ts.replace(' ', 'T') + 'Z');
+    if (sign > 0 && !r._fb && (a[1] === null || ms < a[1])) a[1] = ms;
+  }
+  if (sign > 0 && !r._fb) seeTs(c, Date.parse(r.ts.replace(' ', 'T') + 'Z'));
+}
+function applyCall(c, r, sign) {
+  bump(c.n, 'tool_calls', sign);
+  const t = c.tools[r.tool_name] || (c.tools[r.tool_name] = [0, 0]);
+  t[0] += sign; t[1] += sign * (r.is_error ? 1 : 0);
+  if (!t[0] && !t[1]) delete c.tools[r.tool_name];
+  bump(c.days, r.ts.slice(0, 10), sign);
+  if (sign > 0) seeTs(c, Date.parse(r.ts.replace(' ', 'T') + 'Z'));
+}
+
+// The contract form (source-identity-build.md "Session totals"): the totals columns of
+// `sessions` for one file. `meta` (folder, branch, version, names, first prompt) and `models`
+// (assistant text rows per model, for dominant_model) ride along for the session builder.
+function serializeContrib(c, file = {}) {
+  const out = {};
+  for (const f of N_FIELDS) out[f] = c.n[f] || 0;
+  out.usage = Object.keys(c.usage).sort().map((k) => {
+    const [hour, model] = k.split('\u0000'); const u = c.usage[k];
+    return { hour, model, messages: u[0], input: u[1], output: u[2], cache_read: u[3], cache_write: u[4], reasoning: u[5] };
+  });
+  out.tools = Object.keys(c.tools).sort().map((name) => ({ name, calls: c.tools[name][0], errors: c.tools[name][1] }));
+  out.agents = Object.keys(c.agents).sort().map((id) => ({
+    agent_id: id,
+    type: id === file.agent_id ? String(file.agent_type || '') : '',
+    description: id === file.agent_id ? String(file.agent_desc || '') : '',
+    workflow: id === file.agent_id ? String(file.workflow || '') : '',
+    messages: c.agents[id][0], first_ts: c.agents[id][1] === null ? null : chTs(c.agents[id][1]),
+  }));
+  out.days = Object.keys(c.days).filter((d) => c.days[d] > 0).sort();
+  out.first_ts = c.first_ts === null ? null : chTs(c.first_ts);
+  out.last_ts = c.last_ts === null ? null : chTs(c.last_ts);
+  out.models = { ...c.models };
+  out.meta = { ...c.meta };
+  return out;
+}
+
+function initialState(adapter) {
+  return { v: CAPTURE_STATE_V, a: adapter.initState(), c: newContrib(), open: {}, seen: [], fb: {}, keys: { t: [], c: [] } };
+}
+
+/**
+ * The replay engine every capture adapter's derive() runs on. The adapter supplies the record
+ * mapping (process), the unit boundaries (unitStart/track, a pure function of the record and a
+ * small tracking state so the boundary scan and the replay agree), and what closes a unit.
+ */
+class Deriver {
+  constructor(adapter, file, state) {
+    this.adapter = adapter;
+    this.file = file;
+    const st = state && state.v === CAPTURE_STATE_V ? state : initialState(adapter);
+    this.inState = st;
+    this.s = structuredClone({ a: st.a, c: st.c, open: st.open, seen: st.seen });
+    this.seenSet = new Set(this.s.seen);
+    this.fb = { ...(st.fb || {}) };
+    this.fbAt = new Map();        // record pos -> the fb key its rows were dated by
+    this.rows = new Map();
+    this.calls = new Map();
+    this.callIndex = new Map();   // call_id -> key in this.calls
+    this.from = Number(file.reparse_from) || 0;
+    this.snap = null;
+    this.snapPos = null;
+    this.rev = String(revOf(file.fgen, file.upto));
+    this.project = '';
+  }
+
+  get a() { return this.s.a; }
+  get c() { return this.s.c; }
+
+  /**
+   * The source's own timestamp, else the first-seen time stored once (§2.1). Returns the wire string.
+   * `id`: a stable identity for the record (a normalised log's message_id). The first-seen time is
+   * then kept under it, and survives a rewrite that moves the record; a byte position cannot (ts is
+   * in the row key, so a re-dated record would be a new row and its old one a removed version).
+   */
+  tsOf(rec, ms, id) {
+    if (Number.isFinite(ms) && ms > 0) return chTs(ms);
+    const k = id != null && id !== '' ? `id:${id}` : String(rec.pos);
+    if (this.fb[k] === undefined) this.fb[k] = Number(rec.capturedAt) || Date.now();
+    this.fbAt.set(rec.pos, k);
+    return chTs(this.fb[k]);
+  }
+
+  seenAdd(k) {
+    const h = shortHash(k);
+    if (this.seenSet.has(h)) return;
+    this.seenSet.add(h); this.s.seen.push(h);
+    if (this.s.seen.length > SEEN_CAP) this.seenSet.delete(this.s.seen.shift());
+  }
+
+  /** A new turn row from one record (or one block of it). */
+  turn(rec, f) {
+    const folder = String(f.folder ?? this.a.folder ?? '');
+    const full = cleanText(f.text);
+    const cap = (f.kind === 'tool_result' || f.kind === 'tool_call') ? TOOL_RESULT_CAP : TEXT_CAP;
+    const row = {
+      harness: this.adapter.harness,
+      harness_version: String(f.harness_version ?? this.a.version ?? ''),
+      harness_path: String(this.file.harness_path || ''),
+      session_id: String(this.file.session_id),
+      incarnation: String(this.file.incarnation || ''),
+      agent_id: String(f.agent_id ?? this.file.agent_id ?? ''),
+      message_id: String(f.message_id),
+      part_id: String(f.part_id ?? num(f.part)),
+      part_ord: num(f.part_ord ?? f.part),
+      parent_id: String(f.parent_id || ''),
+      response_id: String(f.response_id || ''),
+      ts: f.ts,
+      ord: rec.pos,
+      rev: this.rev,
+      is_deleted: 0,
+      removed: 0,
+      state: String(f.state || ''),
+      role: String(f.role),
+      kind: String(f.kind),
+      model: String(f.model || ''),
+      effort: String(f.effort || ''),
+      input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0, reasoning_tokens: 0,
+      text: capText(full, cap),
+      text_len: full.length,
+      folder,
+      project: folder ? folder.replace(/\/+$/, '').split('/').pop() : '',
+      host: String(this.file.host || ''),
+      origin: 'ship',
+      extra: JSON.stringify(f.extra || {}),
+      adapter_ver: this.adapter.deriveVersion,
+    };
+    hidden(row, '_src', rec.pos); hidden(row, '_touch', rec.pos);
+    const fk = this.fbAt.get(rec.pos);
+    hidden(row, '_fb', fk !== undefined && chTs(this.fb[fk]) === row.ts);
+    const k = turnKey(row);
+    const prev = this.rows.get(k);
+    if (prev) {
+      // The same key twice in one replay (a verbatim re-append): it replaces, it does not add.
+      applyTurn(this.c, prev, -1); applyTurn(this.c, row, +1);
+      row._src = Math.min(prev._src, row._src);
+    } else if (!this.seenSet.has(shortHash(k))) {
+      applyTurn(this.c, row, +1);
+    }
+    this.rows.set(k, row);
+    this.seenAdd(k);
+    return row;
+  }
+
+  /** Re-emit a row with changed fields (tokens) — the exact old key, a higher rev. */
+  revise(old, changes, rec) {
+    const k = turnKey(old);
+    const prev = this.rows.get(k) || old;
+    const next = { ...prev, ...changes, rev: this.rev };
+    hidden(next, '_src', prev._src === undefined ? -1 : prev._src);
+    hidden(next, '_touch', Math.max(prev._touch === undefined ? -1 : prev._touch, rec.pos));
+    hidden(next, '_fb', !!prev._fb);
+    applyTurn(this.c, prev, -1); applyTurn(this.c, next, +1);
+    this.rows.set(k, next);
+    return next;
+  }
+
+  /** A tool call. Kept open in state until its result arrives (capped). */
+  call(rec, f) {
+    const folder = String(f.folder ?? this.a.folder ?? '');
+    const row = {
+      harness: this.adapter.harness,
+      harness_path: String(this.file.harness_path || ''),
+      session_id: String(this.file.session_id),
+      incarnation: String(this.file.incarnation || ''),
+      agent_id: String(f.agent_id ?? this.file.agent_id ?? ''),
+      call_id: String(f.call_id),
+      message_id: String(f.message_id),
+      ts: f.ts,
+      rev: this.rev,
+      is_deleted: 0,
+      removed: 0,
+      tool_name: String(f.tool_name || 'unknown'),
+      args: capText(cleanText(f.args == null ? '{}' : f.args), ARGS_CAP),
+      result_ts: null,
+      is_error: false,
+      result_len: 0,
+      model: String(f.model || ''),
+      folder,
+      project: folder ? folder.replace(/\/+$/, '').split('/').pop() : '',
+      host: String(this.file.host || ''),
+      adapter_ver: this.adapter.deriveVersion,
+    };
+    hidden(row, '_src', rec.pos); hidden(row, '_touch', rec.pos);
+    const k = callKey(row);
+    const prev = this.calls.get(k);
+    if (prev && prev.result_ts !== null) {
+      // A re-appended tool_use after its result: keep the result.
+      Object.assign(row, { result_ts: prev.result_ts, is_error: prev.is_error, result_len: prev.result_len });
+    }
+    if (prev) { applyCall(this.c, prev, -1); applyCall(this.c, row, +1); row._src = Math.min(prev._src, row._src); }
+    else if (!this.seenSet.has(shortHash(`call\u0000${k}`))) applyCall(this.c, row, +1);
+    this.calls.set(k, row);
+    this.callIndex.set(row.call_id, k);
+    this.seenAdd(`call\u0000${k}`);
+    if (!prev || prev.result_ts === null) {
+      this.s.open[row.call_id] = { ...row };
+      const ids = Object.keys(this.s.open);
+      if (ids.length > OPEN_CALLS_CAP) delete this.s.open[ids[0]];
+    }
+    return row;
+  }
+
+  /** A tool result: the call row is re-emitted with its ORIGINAL ts, tool_name and args (§3). */
+  result(rec, callId, f) {
+    const id = String(callId || '');
+    let prev = this.callIndex.has(id) ? this.calls.get(this.callIndex.get(id)) : null;
+    if (!prev && this.s.open[id]) prev = this.s.open[id];
+    if (!prev) return false;
+    const next = { ...prev, rev: this.rev, result_ts: f.ts, is_error: !!f.is_error, result_len: num(f.result_len) };
+    hidden(next, '_src', prev._src === undefined ? -1 : prev._src);
+    hidden(next, '_touch', Math.max(prev._touch === undefined ? -1 : prev._touch, rec.pos));
+    applyCall(this.c, prev, -1); applyCall(this.c, next, +1);
+    this.calls.set(callKey(next), next);
+    this.callIndex.set(id, callKey(next));
+    delete this.s.open[id];
+    return true;
+  }
+
+  snapshot(pos) {
+    this.snap = structuredClone(this.s);
+    this.snapPos = pos;
+  }
+
+  run(records) {
+    const ad = this.adapter;
+    // The boundary scan: where the LAST unit of this replay starts — the next reparse_from.
+    const u = structuredClone(this.a.u || {});
+    let last = -1;
+    for (let i = 0; i < records.length; i++) {
+      if (ad.unitStart(records[i], u)) last = i;
+      ad.track(records[i], u);
+    }
+    for (let i = 0; i < records.length; i++) {
+      const rec = records[i];
+      if (ad.unitStart(rec, this.a.u)) {
+        ad.closeUnit(this, rec);
+        if (i === last) this.snapshot(rec.pos);
+        ad.openUnit(this, rec);
+      }
+      ad.track(rec, this.a.u);
+      if (rec.obj) ad.process(this, rec);
+      else if (!rec.empty) this.c.meta.malformed = (this.c.meta.malformed || 0) + 1;
+    }
+    ad.endReplay(this);
+    return this.finish();
+  }
+
+  finish() {
+    const reparseFrom = this.snap ? this.snapPos : this.from;
+    const kept = this.snap || structuredClone({ a: this.inState.a, c: this.inState.c, open: this.inState.open, seen: this.inState.seen });
+    const turns = [...this.rows.values()];
+    const calls = [...this.calls.values()];
+    const fbKeys = Object.keys(this.fb);
+    if (fbKeys.length > FALLBACK_CAP) for (const k of fbKeys.slice(0, fbKeys.length - FALLBACK_CAP)) delete this.fb[k];
+    const state = {
+      v: CAPTURE_STATE_V, a: kept.a, c: kept.c, open: kept.open, seen: kept.seen, fb: this.fb,
+      keys: {
+        t: turns.filter((r) => r._src >= reparseFrom).map((r) => [r.message_id, r.part_id, r.ts, r.role, r.kind]),
+        c: calls.filter((r) => r._src >= reparseFrom).map((r) => [r.call_id, r.ts, r.message_id]),
+      },
+    };
+    return { turns, calls, contrib: serializeContrib(this.c, this.file), state, reparse_from: reparseFrom };
+  }
+}
+
+/** derive() for any adapter built on Deriver. */
+function runDerive(adapter, { file, records, state }) {
+  return new Deriver(adapter, file, state).run(records || []);
+}
+
+/** Keys the previous replay produced that this one does not — to be tombstoned (§2.2). */
+function vanishedKeys(oldState, result) {
+  const out = { turns: [], calls: [] };
+  const old = oldState && oldState.keys ? oldState.keys : { t: [], c: [] };
+  const haveT = new Set(result.turns.map(turnKey));
+  const haveC = new Set(result.calls.map(callKey));
+  for (const [message_id, part_id, ts, role, kind] of old.t || []) {
+    if (!haveT.has(turnKey({ ts, message_id, part_id }))) out.turns.push({ message_id, part_id: String(part_id), ts, role, kind });
+  }
+  for (const [call_id, ts, message_id] of old.c || []) {
+    if (!haveC.has(callKey({ ts, call_id }))) out.calls.push({ call_id, ts, message_id });
+  }
+  return out;
+}
+
+/**
+ * A tombstone is a FULL copy of the row it replaces — every column, the old row's own values —
+ * with only `rev` raised and is_deleted = 1 (§2.2). A key-only tombstone is not enough: under
+ * FINAL, ClickHouse 26.7 applies skip indexes (text, tool_name set, ts minmax), so a tombstone
+ * whose indexed columns differ from the old row's can be skipped while the old row is read,
+ * and FINAL resurrects it (measured: calls FINAL WHERE tool_name = 'Bash' returned 9,357 rows
+ * instead of 7,404). `old` must be the row as the house holds it.
+ */
+function tombstoneOf(kind, old, rev) {
+  const cols = kind === 'turns' ? TURN_COLUMNS : CALL_COLUMNS;
+  const out = {};
+  for (const c of cols) {
+    if (old[c] === undefined) throw new Error(`tombstone of ${kind} needs the full old row; ${c} is missing`);
+    out[c] = old[c];
+  }
+  const floor = BigInt(old.rev || 0) + 1n;
+  const r = BigInt(rev);
+  out.rev = String(r > floor ? r : floor);
+  out.is_deleted = 1;
+  return out;
+}
+
+/**
+ * Layout 3.2: content that left the source is kept, not deleted. The same full row copy as a
+ * tombstone, at a higher rev, but live and marked `removed = 1`. Physical tombstones (tombstoneOf)
+ * are only for duplicates: dedupe of converted 0.18 rows, and keys an upgraded adapter no longer
+ * produces.
+ */
+function removedOf(kind, old, rev) {
+  const out = tombstoneOf(kind, old, rev);
+  out.is_deleted = 0;
+  out.removed = 1;
+  return out;
+}
+
+/** Does this adapter carry the capture capability? */
+function canCapture(adapter) {
+  const c = adapter && adapter.capture;
+  return !!(c && c.harness && Number.isInteger(c.deriveVersion) && typeof c.sessions === 'function'
+    && typeof c.sourceFiles === 'function' && typeof c.derive === 'function');
+}
+
+const capture = {
+  CAPTURE_STATE_V, REV_SHIFT, TEXT_CAP, TOOL_RESULT_CAP, ARGS_CAP, OPEN_CALLS_CAP, SEEN_CAP,
+  TURN_COLUMNS, CALL_COLUMNS,
+  revOf, chTs, parseTs, cleanText, capText, num, turnKey, callKey, removedOf,
+  newContrib, applyTurn, applyCall, serializeContrib, initialState,
+  Deriver, runDerive, vanishedKeys, tombstoneOf, canCapture,
+};
+// </capture> ==================================================================================
+
 module.exports = {
   getAppDataPath,
-  isSubscriptionAccessAllowed,
   scanArtifacts,
   parseMcpConfigFile,
   queryMcpServerTools,
+  capture,
 };

package/editors/bridge.js

@@ -0,0 +1,119 @@
+'use strict';
+// The bridge: schema-3 capture for every editor whose sessions are not append-only transcript
+// files (SQLite stores, JSON documents, …). Claude Code and Codex capture their own files
+// (editors/claude.js, editors/codex.js); the other adapters keep their 0.18 readers
+// (getChats/getMessages), and memhouse/shipper/snapshots.js turns each session they read into a
+// per-session snapshot log under $MEMHOUSE_HOME/snapshots/<harness>/<session>.jsonl. The capture
+// engine treats that log as a source file like any other: appended when the session grows,
+// rewritten (fgen bump, vanished keys tombstoned) when the editor's history changed.
+//
+// A snapshot line is one of
+//   {"k":"meta","name":…,"mode":…,"folder":…,"created":ms,"updated":ms,"branch":…}
+//   {"k":"msg","i":<position in the parse>,"role":…,"text":…,"ts":ms,"tsk":"own"|"interp",
+//    "model":…,"tok":{"in","out","cr","cw"},"tools":[{"name","args"}]}
+// `text` is exactly the text 0.18 stored for the message (content, or JSON of it), so dedupe can
+// match the converted 0.18 rows of the same session line for line. `ts` is written once and never
+// moves: the editor's own time where it has one, else 0.18's interpolation over the session's
+// span at the moment the line was first written.
+
+const fs = require('fs');
+const path = require('path');
+
+// Version 2: layout 3.2 (part_id/part_ord, harness_path, full text). Version 3: no derive change: comment wording in the shared capture region.
+const BRIDGE_DERIVE_VERSION = 3;
+
+// <derive> ====================================================================================
+function bTok(t) {
+  const n = (v) => { const x = Math.trunc(Number(v)); return Number.isFinite(x) && x > 0 ? x : 0; };
+  return { input_tokens: n(t && t.in), output_tokens: n(t && t.out), cache_read_tokens: n(t && t.cr), cache_write_tokens: n(t && t.cw), reasoning_tokens: 0 };
+}
+function bKind(role, text) {
+  if (role === 'tool') return 'tool_result';
+  if (role === 'system') return 'context';
+  return 'text';
+}
+function bRole(role) {
+  if (role === 'user' || role === 'assistant' || role === 'system') return role;
+  if (role === 'tool') return 'user';
+  return 'assistant';
+}
+
+function bridgeDeriveAdapter(harness) {
+  const ad = {
+    harness,
+    deriveVersion: BRIDGE_DERIVE_VERSION,
+    initState() { return { u: {}, folder: '', model: '' }; },
+    // Every message line is its own unit: a later pass re-reads only the last one.
+    unitStart(rec) { return !!(rec.obj && rec.obj.k === 'msg'); },
+    track() {},
+    closeUnit() {},
+    openUnit() {},
+    endReplay() {},
+    process(d, rec) {
+      const o = rec.obj;
+      if (o.k === 'meta') {
+        if (typeof o.folder === 'string' && o.folder) { d.a.folder = o.folder; if (!d.c.meta.folder) d.c.meta.folder = o.folder; }
+        if (typeof o.name === 'string' && o.name) d.c.meta.title = o.name;
+        if (typeof o.branch === 'string' && o.branch) d.c.meta.git_branch = o.branch;
+        if (typeof o.mode === 'string' && o.mode) d.c.meta.mode = o.mode;
+        if (typeof o.version === 'string' && o.version) { d.a.version = o.version; d.c.meta.version = o.version; }
+        return;
+      }
+      if (o.k !== 'msg') return;
+      const role = String(o.role || '');
+      const text = typeof o.text === 'string' ? o.text : '';
+      const ts = d.tsOf(rec, Number(o.ts));
+      const mid = typeof o.id === 'string' && o.id ? o.id : `m${Number(o.i) || 0}`;
+      if (typeof o.model === 'string' && o.model) d.a.model = o.model;
+      const row = d.turn(rec, {
+        message_id: mid, part: 0, role: bRole(role), kind: bKind(role, text), text, ts,
+        model: role === 'assistant' ? (o.model || '') : '', extra: role === 'tool' || (role !== bRole(role)) ? { source_role: role } : {},
+      });
+      const tok = bTok(o.tok);
+      if (tok.input_tokens || tok.output_tokens || tok.cache_read_tokens || tok.cache_write_tokens) d.revise(row, tok, rec);
+      if (role === 'user' && !d.c.meta.first_prompt && text.trim()) d.c.meta.first_prompt = text.slice(0, 2000);
+      (Array.isArray(o.tools) ? o.tools : []).forEach((t, n) => {
+        if (!t || n > 255) return;
+        d.call(rec, { call_id: `${mid}:${n}`, message_id: mid, ts, tool_name: String(t.name || 'unknown'), args: JSON.stringify(t.args ?? {}), model: o.model || '' });
+      });
+    },
+  };
+  return ad;
+}
+// </derive> ===================================================================================
+
+const SNAP_EXT = '.jsonl';
+/** Session id <-> snapshot file name: reversible, filesystem-safe. */
+function fileNameFor(sessionId) { return encodeURIComponent(String(sessionId)).replace(/\./g, '%2E') + SNAP_EXT; }
+function sessionIdOf(fileName) { try { return decodeURIComponent(path.basename(fileName, SNAP_EXT)); } catch { return null; } }
+
+const cache = new Map();
+/** The capture capability for one bridged harness; `root.dir` is its snapshot directory. */
+function bridgeCapture(harness) {
+  if (cache.has(harness)) return cache.get(harness);
+  const adapter = bridgeDeriveAdapter(harness);
+  const cap = {
+    harness,
+    deriveVersion: BRIDGE_DERIVE_VERSION,
+    bridged: true,
+    sessions(root) {
+      let names = [];
+      try { names = fs.readdirSync(root.dir).filter((n) => n.endsWith(SNAP_EXT)); } catch { return []; }
+      const out = [];
+      for (const n of names) {
+        const id = sessionIdOf(n);
+        if (id) out.push({ harness, session_id: id, root: root.name, paths: [path.join(root.dir, n)] });
+      }
+      return out;
+    },
+    sourceFiles(session) { return session.paths.map((p) => ({ file_key: path.basename(p), path: p, agent_id: '', role: 'main' })); },
+    attribution: () => ({ agent_type: '', agent_desc: '' }),
+    tsless: (o) => !o || !(Number(o.ts) > 0),
+    derive: (input) => require('./base').capture.runDerive(adapter, input),
+    adapter,
+  };
+  cache.set(harness, cap);
+  return cap;
+}
+
+module.exports = { bridgeCapture, bridgeDeriveAdapter, fileNameFor, sessionIdOf, BRIDGE_DERIVE_VERSION, SNAP_EXT };