memhouse 0.18.12 → 0.20.1

package/memhouse/import/import.js

@@ -0,0 +1,372 @@
+'use strict';
+// `memhouse import claude-ai`: plan, apply, undo and list import batches. Transport-free: every
+// entry point takes `house` — { rows(sql) -> object[], exec(sql), insert(fq, rows) } — and the
+// member's names ({ db, member, … }), so the CLI, a lab test and a unit test drive the same code.
+// The member's layout picks the writer: writer-v3.js for <m>_turns (layout 3.2), writer-profile.js
+// for harness-sessions-sql's profile. Both take the parser's keys as they are.
+//
+// What is written, and when:
+//   new        a conversation the house has never held: its rows at rev 1.
+//   same       the house holds it and the export's updated_at is not newer: nothing.
+//   changed    the export's updated_at is newer than the house's: nothing, unless --update.
+//   rewritten  a session written before whose rows the house still has (changed with --update,
+//              or rows left by an undone batch or a stopped run): every live row of it is
+//              tombstoned at R = 1 + the highest rev any of its rows carries, and the new rows
+//              are written at R + 1. So a re-import is never hidden behind an older tombstone,
+//              and a message the export no longer holds does not stay current.
+// The session row is written last: a run that stops before it leaves the session not present,
+// and the next run writes it again.
+
+const C = require('./claude-ai');
+const V = require('./writer-v3');
+const PR = require('./writer-profile');
+
+const WRITERS = { [V.LAYOUT]: V, [PR.LAYOUT]: PR };
+// The layout 3.2 writer's store, kept for callers that build its rows directly.
+const SRC = V.SRC;
+// The member layouts this build writes imports into (layoutOf's names).
+const WRITES_LAYOUTS = Object.keys(WRITERS);
+const BATCH_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+const META_PREFIX = 'import:';
+const ID_CHUNK = 500;
+
+class ImportRefusal extends Error {}
+
+function newBatchId(now = new Date()) {
+  const iso = now.toISOString();
+  return `claude-ai-${iso.slice(0, 10)}-${iso.slice(11, 19).replace(/:/g, '')}`;
+}
+
+function checkBatchId(id) {
+  if (!BATCH_ID.test(String(id))) throw new ImportRefusal(`'${id}' is not a batch id (letters, digits, '.', '_' and '-')`);
+  return String(id);
+}
+
+/** The member's layout as its tables show it: '3.2' (<m>_turns), 'profile' (<m>_session_parts), '0.18', or null. */
+async function layoutOf(house, db, member) {
+  const rows = await house.rows(`SELECT name FROM system.tables WHERE database = ${V.sqlStr(db)}
+    AND name IN (${[`${member}_turns`, `${member}_session_parts`, `${member}_messages`].map(V.sqlStr).join(', ')})`);
+  const has = (n) => rows.some((r) => r.name === `${member}_${n}`);
+  return has('turns') ? '3.2' : has('session_parts') ? 'profile' : has('messages') ? '0.18' : null;
+}
+
+/**
+ * The writer for the member's layout and its table names: { layout, W, N }. A member on both
+ * layouts (the profile laid beside <m>_turns) is written on the profile, which its readers read.
+ */
+async function requireLayout(house, names) {
+  const layout = await layoutOf(house, names.db, names.member);
+  const turnsToo = layout === '3.2' && (await house.rows(`SELECT name FROM system.tables WHERE database = ${V.sqlStr(names.db)}
+    AND name = ${V.sqlStr(`${names.member}_session_parts`)}`)).length > 0;
+  if (turnsToo) {
+    // Both layouts name <m>_sessions and <m>_calls: the profile is written only when those are its own.
+    const cols = await house.rows(`SELECT name FROM system.columns WHERE database = ${V.sqlStr(names.db)}
+      AND table = ${V.sqlStr(`${names.member}_sessions`)} AND name IN ('title', 'harness_path')`);
+    if (cols.length < 2) {
+      throw new ImportRefusal(`'${names.member}' has ${names.member}_session_parts beside the 3.2 tables, but ${names.member}_sessions is not the profile's: `
+        + 'finish the move to the profile first (docs/guides/upgrade-to-0.20.md)');
+    }
+  }
+  const use = turnsToo ? PR.LAYOUT : layout;
+  if (WRITERS[use]) return { layout: use, W: WRITERS[use], N: WRITERS[use].names(names.db, names.member) };
+  if (layout === '0.18') throw new ImportRefusal(`'${names.member}' is on the 0.18 rooms; import needs schema 3 (docs/guides/upgrade-to-0.20.md)`);
+  throw new ImportRefusal(`'${names.member}' has no schema-3 tables in ${names.db}`);
+}
+
+/** Insertable columns of a table, as the server has them (no MATERIALIZED / ALIAS / EPHEMERAL). */
+async function columnsOf(house, fq) {
+  const [db, table] = fq.split('.');
+  const rows = await house.rows(`SELECT name, default_kind FROM system.columns
+    WHERE database = ${V.sqlStr(db)} AND table = ${V.sqlStr(table)} ORDER BY position`);
+  return rows.filter((r) => !['MATERIALIZED', 'ALIAS', 'EPHEMERAL'].includes(r.default_kind)).map((r) => r.name);
+}
+
+function chunks(list, n) {
+  const out = [];
+  for (let k = 0; k < list.length; k += n) out.push(list.slice(k, k + n));
+  return out;
+}
+
+/** The content digest of each of these stored sessions (each writer says what it covers). */
+async function storedDigests(house, L, present, ids) {
+  const by = new Map(ids.map((id) => [id, {}]));
+  for (const part of chunks(ids, ID_CHUNK)) {
+    for (const [name, sql] of Object.entries(L.W.contentSQL(L.N, L.W.SRC, part))) {
+      for (const r of await house.rows(sql)) { const o = by.get(r.session_id); if (o) (o[name] || (o[name] = [])).push(r); }
+    }
+  }
+  const digestOf = L.W.contentDigestOf || L.W.contentDigest;
+  return new Map(ids.map((id) => [id, digestOf(present.get(id), by.get(id))]));
+}
+
+async function maxRevs(house, L, ids) {
+  const out = new Map();
+  for (const part of chunks(ids, ID_CHUNK)) {
+    for (const sql of L.W.maxRevSQL(L.N, L.W.SRC, part)) {
+      for (const r of await house.rows(sql)) out.set(r.session_id, Math.max(out.get(r.session_id) || 0, Number(r.rev)));
+    }
+  }
+  return out;
+}
+
+/**
+ * What an import would do. `input` is readInput()'s result. Returns counts (never content) and,
+ * under `work`, the sessions to write with their revs.
+ */
+async function plan(house, names, input, { update = false } = {}) {
+  const L = await requireLayout(house, names);
+  const { W } = L;
+  const present = new Map((await house.rows(W.presentSQL(L.N, W.SRC))).map((r) => [r.session_id, r]));
+  const counts = { new: 0, same: 0, changed: 0, changed_newer: 0, changed_content: 0, older: 0 };
+  const chosen = [];
+  const sameTime = [];
+  const changed = (s, h, how) => {
+    counts.changed++;
+    counts[how]++;
+    if (!update) return;
+    // An export says nothing of projects: a changed session keeps the project the house gave it.
+    const keep = input.kind === 'archive' ? {} : { project: h.project, folder: h.folder };
+    chosen.push({ s: { ...s, ...keep }, why: 'changed' });
+  };
+  for (const s of input.sessions) {
+    const h = present.get(s.sessionId);
+    if (!h) { counts.new++; chosen.push({ s, why: 'new' }); continue; }
+    const known = h.updated_at !== null && h.updated_at !== undefined;
+    // The export's updated_at moves when a conversation gets a message or a new name; an export
+    // older than what the house holds never replaces it.
+    if (!known || s.updated > h.updated_at) changed(s, h, 'changed_newer');
+    else if (s.updated < h.updated_at) { counts.older++; counts.same++; }
+    else sameTime.push([s, h]);
+  }
+  // At the same updated_at the content can still differ: claude.ai adds a summary, or a newer
+  // export carries what an older copy lacked. The stored rows are compared with the parse.
+  if (sameTime.length) {
+    const stored = await storedDigests(house, L, present, sameTime.map(([s]) => s.sessionId));
+    for (const [s, h] of sameTime) {
+      if (stored.get(s.sessionId) === W.parsedDigest(s, W.SRC)) counts.same++;
+      else changed(s, h, 'changed_content');
+    }
+  }
+  const revs = await maxRevs(house, L, chosen.map((c) => c.s.sessionId));
+  const work = chosen.map((c) => {
+    const had = revs.get(c.s.sessionId);
+    return had === undefined ? { ...c, rev: 1, tombstoneRev: null } : { ...c, rev: had + 2, tombstoneRev: had + 1 };
+  });
+  const write = { sessions: work.length, turns: 0, calls: 0, rewritten: work.filter((w) => w.tombstoneRev !== null).length };
+  for (const w of work) { write.turns += w.s.parts.length; write.calls += w.s.calls.length; }
+  // Sessions a stopped run left with an unfilled row (profile only), apart from the ones this run
+  // writes again: apply refreshes them.
+  const writing = new Set(work.map((w) => w.s.sessionId));
+  const unfilled = W.unrefreshedSQL ? await house.rows(W.unrefreshedSQL(L.N, W.SRC)) : [];
+  const repair = unfilled.map((r) => r.session_id).filter((id) => !writing.has(id));
+  // Batches whose run stopped after all their rows went in: applied once this run has filled every
+  // row a stopped run left.
+  const stopped = [...(await readMeta(house, names))].filter(([, m]) => m.status === 'applying' && m.inserted).map(([b]) => b).sort();
+  const span = work.length
+    ? [work.reduce((a, w) => (w.s.created < a ? w.s.created : a), work[0].s.created).slice(0, 10),
+       work.reduce((a, w) => (w.s.updated > a ? w.s.updated : a), work[0].s.updated).slice(0, 10)]
+    : null;
+  return {
+    layout: L.layout,
+    input: { kind: input.kind, conversations: input.sessions.length + input.empty + input.duplicates, categories: input.categories,
+      read: input.read || [], ignored: input.ignored || [] },
+    house: { claude_ai_sessions: present.size },
+    sessions: { ...counts, empty: input.empty, duplicates: input.duplicates, update },
+    write,
+    repair,
+    stopped_batches: stopped,
+    skipped_blocks: input.skipped,
+    span,
+    work,
+  };
+}
+
+async function readMeta(house, names) {
+  const meta = names.meta || `${names.db}.${names.member}_meta`;
+  const rows = await house.rows(`SELECT key, value, toString(updated_at) AS at FROM ${meta} FINAL
+    WHERE startsWith(key, ${V.sqlStr(META_PREFIX)})`);
+  const out = new Map();
+  for (const r of rows) {
+    let v = {};
+    try { v = JSON.parse(r.value); } catch { v = { status: 'unreadable' }; }
+    out.set(r.key.slice(META_PREFIX.length), { ...v, at: r.at });
+  }
+  return out;
+}
+
+async function writeMeta(house, names, batch, value) {
+  const meta = names.meta || `${names.db}.${names.member}_meta`;
+  await house.exec(`INSERT INTO ${meta} (key, value) VALUES (${V.sqlStr(META_PREFIX + batch)}, ${V.sqlStr(JSON.stringify(value))})`);
+}
+
+async function batchExists(house, L, names, batch) {
+  if ((await readMeta(house, names)).has(batch)) return true;
+  const r = await house.rows(`SELECT count() AS n FROM ${L.N.sessions} WHERE ${L.W.storeWhere(L.W.SRC)}
+    AND harness_version = ${V.sqlStr(V.batchTag(batch))}`);
+  return Number(r[0] && r[0].n) > 0;
+}
+
+async function checkColumns(house, L, sample) {
+  const cols = {};
+  for (const t of L.W.TABLES) {
+    cols[t] = await columnsOf(house, L.N[t]);
+    const have = new Set(cols[t]);
+    const extra = sample[t] ? Object.keys(sample[t]).filter((k) => !have.has(k)) : [];
+    if (extra.length) throw new ImportRefusal(`${L.N[t]} does not take: ${extra.join(', ')}`);
+  }
+  return cols;
+}
+
+/** Counts of the live rows a batch holds. `turns` counts the message parts, whatever the layout calls them. */
+async function batchCounts(house, names, batch, L = null) {
+  const X = L || await requireLayout(house, names);
+  const q = X.W.countsSQL(X.N, X.W.SRC, batch);
+  const s = (await house.rows(q.sessions))[0] || {};
+  const t = await house.rows(q.parts);
+  const c = (await house.rows(q.calls))[0] || {};
+  const turnsByKind = Object.fromEntries(t.map((r) => [r.kind, Number(r.n)]));
+  return {
+    sessions: Number(s.sessions || 0), messages: Number(s.messages || 0), tool_calls: Number(s.tool_calls || 0),
+    turns: Object.values(turnsByKind).reduce((a, n) => a + n, 0), turns_by_kind: turnsByKind, calls: Number(c.n || 0),
+  };
+}
+
+/** Write what plan() chose, as one batch. Returns the batch's read-back counts. */
+async function apply(house, names, p, { batch, version = '', onProgress = () => {} } = {}) {
+  checkBatchId(batch);
+  const L = await requireLayout(house, names);
+  const { W } = L;
+  if (L.layout !== p.layout) throw new ImportRefusal(`the plan was made for layout ${p.layout}; the house is now on ${L.layout} — plan again`);
+  const repair = p.repair || [];
+  if (!p.work.length) {
+    // Nothing to write: still fill the rows a stopped run left and finish its batch. No batch is used
+    // or recorded, so a retry under the stopped run's own --batch is no refusal.
+    if (repair.length) { await W.refresh(house, L.N, repair, W.SRC); onProgress(`refreshed ${repair.length} session row(s) a stopped run left`); }
+    const completed = await completeStopped(house, names, p.stopped_batches);
+    return { batch: null, written: { sessions: 0, turns: 0, calls: 0 }, counts: null, repaired: repair.length, completed };
+  }
+  if (await batchExists(house, L, names, batch)) throw new ImportRefusal(`batch '${batch}' already exists in this house; name another with --batch`);
+  const built = p.work.map((w) => W.rows(w.s, { src: W.SRC, batch, rev: w.rev }));
+  const sample = {};
+  for (const t of W.TABLES) sample[t] = (built.find((b) => b[t].length) || { [t]: [] })[t][0];
+  const cols = await checkColumns(house, L, sample);
+  const record = { kind: C.HARNESS, layout: L.layout, input: p.input.kind, sessions: p.write.sessions, turns: p.write.turns,
+    calls: p.write.calls, rewritten: p.write.rewritten, update: p.sessions.update, version };
+  await writeMeta(house, names, batch, { ...record, status: 'applying' });
+  const again = new Map(p.work.filter((w) => w.tombstoneRev !== null).map((w) => [w.s.sessionId, w.tombstoneRev]));
+  if (again.size) {
+    // Calls first, as in an undo; then the parts; the session row last.
+    for (const ids of chunks([...again.keys()], ID_CHUNK)) {
+      const revs = new Map(ids.map((i) => [i, again.get(i)]));
+      const where = W.sessionsWhere(W.SRC, ids);
+      for (const t of W.TOMBSTONE_ORDER) await house.exec(W.tombstoneSQL(L.N[t], cols[t], where[t], W.revBySession(revs)));
+    }
+    onProgress(`tombstoned the earlier rows of ${again.size} session(s)`);
+  }
+  // Every row in: a run that stops from here on is finished by the next one (completeStopped).
+  const w = await W.writeRows(house, L.N, built, W.SRC, onProgress, () => writeMeta(house, names, batch, { ...record, status: 'applying', inserted: true }));
+  if (repair.length) { await W.refresh(house, L.N, repair, W.SRC); onProgress(`refreshed ${repair.length} session row(s) a stopped run left`); }
+  const completed = await completeStopped(house, names, p.stopped_batches);
+  const written = { sessions: w.sessions || 0, turns: w[W.PARTS] || 0, calls: w.calls || 0 };
+  const counts = await batchCounts(house, names, batch, L);
+  await writeMeta(house, names, batch, { ...record, status: 'applied' });
+  return { batch, written, counts, repaired: repair.length, completed };
+}
+
+/**
+ * The batches a run stopped in after all their rows went in ('applying', inserted): the caller has
+ * filled every row a stopped run left, so each is applied, whatever --batch this run has and whatever
+ * it wrote again. A batch whose insert stopped part way was never marked inserted and stays applying;
+ * an undo in progress is 'undoing', never applying. Returns the batches it applied.
+ */
+async function completeStopped(house, names, batches = []) {
+  if (!batches.length) return [];
+  const metas = await readMeta(house, names);
+  const done = [];
+  for (const b of batches) {
+    const meta = metas.get(b);
+    if (!meta || meta.status !== 'applying' || !meta.inserted) continue;
+    await writeMeta(house, names, b, { ...meta, at: undefined, status: 'applied' });
+    done.push(b);
+  }
+  return done;
+}
+
+/** Tombstone every live row of a batch. Dry unless `write`. Returns counts before and after. */
+async function undo(house, names, batch, { write = false, version = '' } = {}) {
+  checkBatchId(batch);
+  const L = await requireLayout(house, names);
+  const { W } = L;
+  const before = await batchCounts(house, names, batch, L);
+  const meta = (await readMeta(house, names)).get(batch) || {};
+  // An undo that stopped part way left 'undoing' and the counts it found. A retry keeps those counts;
+  // one that finds every row already tombstoned only records the undo as done.
+  const resuming = meta.status === 'undoing';
+  const live = Boolean(before.sessions || before.turns || before.calls);
+  const finishing = resuming && !live;
+  if (!write || (!live && !finishing)) return { batch, before, after: null, written: false, finishing };
+  const rec = { ...meta, at: undefined, kind: C.HARNESS, undone: resuming && meta.undone ? meta.undone : before, version };
+  if (live) {
+    // Recorded first: an undo that stops part way leaves 'undoing', which no import completes.
+    await writeMeta(house, names, batch, { ...rec, status: 'undoing' });
+    const where = W.batchWhere(L.N, W.SRC, batch);
+    // Calls first: they are found through the batch's live parts, so the parts must still be there.
+    for (const t of W.TOMBSTONE_ORDER) {
+      await house.exec(W.tombstoneSQL(L.N[t], await columnsOf(house, L.N[t]), where[t], 'rev + 1'));
+    }
+  }
+  const after = await batchCounts(house, names, batch, L);
+  await writeMeta(house, names, batch, { ...rec, status: 'undone' });
+  return { batch, before, after, written: true, finishing };
+}
+
+const INSERT_SETTINGS = { async_insert: 0, date_time_input_format: 'best_effort', input_format_skip_unknown_fields: 0 };
+
+/**
+ * A `house` over two calls: rows(sql) -> object[] for reads, write(sql, settings) for writes.
+ * Inserts go as JSONEachRow in chunks of at most 2,000 rows or 8 MB, async_insert off.
+ */
+function houseOver({ rows, write }) {
+  return {
+    rows,
+    exec: (sql) => write(sql, { async_insert: 0 }),
+    async insert(fq, list) {
+      let buf = []; let size = 0;
+      const flush = async () => {
+        if (!buf.length) return;
+        await write(`INSERT INTO ${fq} FORMAT JSONEachRow\n${buf.join('\n')}`, INSERT_SETTINGS);
+        buf = []; size = 0;
+      };
+      for (const r of list) {
+        const line = JSON.stringify(r);
+        if (buf.length && (buf.length >= 2000 || size + line.length > 8 * 1024 * 1024)) await flush();
+        buf.push(line); size += line.length;
+      }
+      await flush();
+    },
+  };
+}
+
+/** Every import batch the house holds live rows of, with what meta recorded about it. */
+async function list(house, names) {
+  const L = await requireLayout(house, names);
+  const rows = await house.rows(`SELECT replaceOne(harness_version, ${V.sqlStr(META_PREFIX)}, '') AS batch, count() AS sessions,
+      sum(messages) AS messages, sum(tool_calls) AS tool_calls, toString(min(started)) AS first, toString(max(ended)) AS last
+    FROM ${L.N.sessions} FINAL WHERE is_deleted = 0 AND ${L.W.storeWhere(L.W.SRC)} AND origin = 'import'
+    GROUP BY batch ORDER BY batch`);
+  const meta = await readMeta(house, names);
+  const out = new Map();
+  for (const r of rows) {
+    out.set(r.batch, { batch: r.batch, sessions: Number(r.sessions), messages: Number(r.messages), tool_calls: Number(r.tool_calls),
+      first: r.first ? r.first.slice(0, 10) : null, last: r.last ? r.last.slice(0, 10) : null, status: null, recorded_at: null });
+  }
+  for (const [b, m] of meta) {
+    const e = out.get(b) || { batch: b, sessions: 0, messages: 0, tool_calls: 0, first: null, last: null };
+    out.set(b, { ...e, status: m.status || null, recorded_at: m.at || null });
+  }
+  return [...out.values()].sort((a, b) => (a.batch < b.batch ? -1 : 1));
+}
+
+module.exports = {
+  SRC, WRITERS, WRITES_LAYOUTS, ImportRefusal, houseOver, newBatchId, checkBatchId, layoutOf, requireLayout, plan, apply, undo, list, batchCounts, readMeta,
+};

package/memhouse/import/pyjson.js

@@ -0,0 +1,206 @@
+'use strict';
+// JSON read and written the way Python's json module does it, for the claude.ai import.
+//
+// The import's row texts (a tool call's `Name(args)`, its args, a turn's `extra`) were first
+// produced by Python's json.dumps(…, ensure_ascii=False): ', ' and ': ' separators, a float
+// that was written 1.0 stays 1.0, integers of any size, keys in source order. JSON.parse and
+// JSON.stringify differ on all four, so a re-import would write different text for the same
+// message. parse() keeps what dumps() needs to reproduce Python exactly: the source order of
+// an object whose keys JavaScript would reorder (integer-like keys), and the source text of a
+// number JavaScript cannot round-trip (a float literal, an integer past 2^53). Everything else
+// is a plain value, so callers read the result like JSON.parse's.
+
+const ORDER = Symbol('pyjson.order');   // object -> its keys in source order (only when JS would reorder them)
+const NUMSRC = Symbol('pyjson.numsrc'); // container -> { key or index: number source text }
+
+const INDEX_KEY = /^(?:0|[1-9]\d*)$/;
+const NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+
+class JsonError extends Error {}
+
+function parse(text) {
+  let i = 0;
+  const n = text.length;
+  let numSrc = null; // set by value() when the number it returned needs its source text
+  const fail = (what) => { throw new JsonError(`invalid JSON at offset ${i}: ${what}`); };
+  const ws = () => {
+    while (i < n) {
+      const c = text.charCodeAt(i);
+      if (c === 32 || c === 10 || c === 13 || c === 9) i++; else break;
+    }
+  };
+  function str() {
+    const start = i++;
+    for (;;) {
+      const j = text.indexOf('"', i);
+      if (j < 0) { i = start; fail('unterminated string'); }
+      let k = j - 1; let bs = 0;
+      while (k > start && text.charCodeAt(k) === 92) { bs++; k--; }
+      i = j + 1;
+      if (bs % 2 === 0) {
+        const raw = text.slice(start + 1, j);
+        return raw.indexOf('\\') < 0 ? raw : JSON.parse(text.slice(start, j + 1));
+      }
+    }
+  }
+  function keep(container, key) {
+    if (numSrc === null) return;
+    if (!container[NUMSRC]) Object.defineProperty(container, NUMSRC, { value: {}, enumerable: false });
+    container[NUMSRC][key] = numSrc;
+    numSrc = null;
+  }
+  function value() {
+    numSrc = null;
+    ws();
+    const c = text.charCodeAt(i);
+    if (c === 123) { // {
+      i++;
+      const o = {};
+      const keys = [];
+      let reordered = false;
+      ws();
+      if (text.charCodeAt(i) === 125) { i++; return o; }
+      for (;;) {
+        ws();
+        if (text.charCodeAt(i) !== 34) fail('expected a key');
+        const k = str();
+        ws();
+        if (text.charCodeAt(i) !== 58) fail("expected ':'");
+        i++;
+        const v = value();
+        if (!Object.prototype.hasOwnProperty.call(o, k)) {
+          keys.push(k);
+          if (INDEX_KEY.test(k) && Number(k) < 4294967295) reordered = true;
+        }
+        if (k === '__proto__') Object.defineProperty(o, k, { value: v, enumerable: true, writable: true, configurable: true });
+        else o[k] = v;
+        keep(o, k);
+        ws();
+        const d = text.charCodeAt(i++);
+        if (d === 44) continue;
+        if (d === 125) break;
+        i--; fail("expected ',' or '}'");
+      }
+      if (reordered) Object.defineProperty(o, ORDER, { value: keys, enumerable: false });
+      return o;
+    }
+    if (c === 91) { // [
+      i++;
+      const a = [];
+      ws();
+      if (text.charCodeAt(i) === 93) { i++; return a; }
+      for (;;) {
+        a.push(value());
+        keep(a, a.length - 1);
+        ws();
+        const d = text.charCodeAt(i++);
+        if (d === 44) continue;
+        if (d === 93) break;
+        i--; fail("expected ',' or ']'");
+      }
+      return a;
+    }
+    if (c === 34) return str();
+    if (text.startsWith('true', i)) { i += 4; return true; }
+    if (text.startsWith('false', i)) { i += 5; return false; }
+    if (text.startsWith('null', i)) { i += 4; return null; }
+    NUMBER.lastIndex = i;
+    const m = NUMBER.exec(text);
+    if (!m) fail('unexpected character');
+    i += m[0].length;
+    const src = m[0];
+    const v = Number(src);
+    if (/[.eE]/.test(src) || !Number.isSafeInteger(v)) numSrc = src;
+    return v;
+  }
+  const out = value();
+  numSrc = null;
+  ws();
+  if (i < n) fail('trailing data');
+  return out;
+}
+
+/** Python's repr() of a float: the shortest round-trip digits, exponent form outside 1e-4 ≤ |x| < 1e16. */
+function pyFloat(x) {
+  if (Number.isNaN(x)) return 'NaN';
+  if (x === Infinity) return 'Infinity';
+  if (x === -Infinity) return '-Infinity';
+  if (x === 0) return Object.is(x, -0) ? '-0.0' : '0.0';
+  const [m, e] = x.toExponential().split('e');
+  const exp = Number(e);
+  const neg = m[0] === '-';
+  const digits = m.replace('-', '').replace('.', '');
+  let s;
+  if (exp >= -4 && exp < 16) {
+    if (exp >= 0) {
+      const whole = digits.slice(0, exp + 1).padEnd(exp + 1, '0');
+      s = `${whole}.${digits.slice(exp + 1) || '0'}`;
+    } else {
+      s = `0.${'0'.repeat(-exp - 1)}${digits}`;
+    }
+  } else {
+    const mant = digits.length > 1 ? `${digits[0]}.${digits.slice(1)}` : digits;
+    s = `${mant}e${exp < 0 ? '-' : '+'}${String(Math.abs(exp)).padStart(2, '0')}`;
+  }
+  return neg ? `-${s}` : s;
+}
+
+function numberText(v, src) {
+  if (src !== undefined) return /[.eE]/.test(src) ? pyFloat(Number(src)) : BigInt(src).toString();
+  return Number.isInteger(v) ? String(v === 0 ? 0 : v) : pyFloat(v);
+}
+
+/** json.dumps(v, ensure_ascii=False) — Python's default separators, source key order and number forms. */
+function dumps(v, src, sep = PY_SEP) {
+  if (v === null || v === undefined) return 'null';
+  if (v === true) return 'true';
+  if (v === false) return 'false';
+  if (typeof v === 'number') return numberText(v, src);
+  if (typeof v === 'bigint') return v.toString();
+  if (typeof v === 'string') return JSON.stringify(v);
+  const srcs = v[NUMSRC] || {};
+  if (Array.isArray(v)) return `[${v.map((x, k) => dumps(x, srcs[k], sep)).join(sep.item)}]`;
+  const keys = v[ORDER] || Object.keys(v);
+  return `{${keys.map((k) => `${JSON.stringify(k)}${sep.key}${dumps(v[k], srcs[k], sep)}`).join(sep.item)}}`;
+}
+const PY_SEP = { item: ', ', key: ': ' };
+
+/** The same value as compact JSON (no spaces), numbers and key order still as the source wrote them. */
+function compact(v, src) { return dumps(v, src, { item: ',', key: ':' }); }
+
+/**
+ * str(v) for a value Python read from JSON. Strings, numbers, booleans and null are exact;
+ * a list or dict falls back to its JSON text (Python would print its repr, with single quotes —
+ * the export never puts one where this is used).
+ */
+function pyStr(v, src) {
+  if (typeof v === 'string') return v;
+  if (v === true) return 'True';
+  if (v === false) return 'False';
+  if (v === null || v === undefined) return 'None';
+  if (typeof v === 'number') return numberText(v, src);
+  return dumps(v, src);
+}
+
+/** len() of a Python str: code points, not UTF-16 units. */
+function pyLen(s) {
+  let pairs = 0;
+  for (let k = 0; k < s.length - 1; k++) {
+    const c = s.charCodeAt(k);
+    if (c >= 0xd800 && c <= 0xdbff) {
+      const d = s.charCodeAt(k + 1);
+      if (d >= 0xdc00 && d <= 0xdfff) { pairs++; k++; }
+    }
+  }
+  return s.length - pairs;
+}
+
+/** str.strip() with no argument: whitespace as Python's str.isspace() counts it. */
+const PY_SPACE = '\\t\\n\\v\\f\\r\\x1c-\\x20\\x85\\xa0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000';
+const STRIP = new RegExp(`^[${PY_SPACE}]+|[${PY_SPACE}]+$`, 'g');
+function pyStrip(s) { return s.replace(STRIP, ''); }
+
+/** The source text of the number at `key` in a parsed container, when parse() kept it. */
+function numSource(container, key) { return container && container[NUMSRC] ? container[NUMSRC][key] : undefined; }
+
+module.exports = { parse, dumps, compact, pyStr, pyFloat, pyLen, pyStrip, numSource, JsonError, ORDER, NUMSRC };

package/memhouse/import/records.js

@@ -0,0 +1,64 @@
+'use strict';
+// A parsed claude.ai conversation (claude-ai.js) as sessions-model records: one session record and
+// one message record per claude.ai message, its parts in order. Layout-free, like the parser: the
+// profile writer turns these into rows with records-to-profile.js. The keys are the parser's own —
+// session id, message ids, part ids, call ids — copied, never derived again.
+//
+//   parser part      record part
+//   text             text
+//   thinking         reasoning
+//   tool_call        tool_call (call_id, name, args as the export's input)
+//   tool_result      tool_result (call_id, is_error, status completed, output, output_len)
+//   summary          summary (replaces: unknown), in a 'system' message of its own
+// An attachment's extracted text is a text part, as the parser stores it.
+
+const py = require('./pyjson');
+
+/** The parser's 'YYYY-MM-DD HH:MM:SS.mmm' (UTC) as ISO 8601. */
+const iso = (t) => (t ? `${String(t).replace(' ', 'T')}Z` : null);
+
+function partOf(p) {
+  switch (p.kind) {
+    case 'text': return { part_id: p.partId, kind: 'text', text: p.text };
+    case 'thinking': return { part_id: p.partId, kind: 'reasoning', text: p.text };
+    case 'tool_call': return { part_id: p.partId, kind: 'tool_call', call_id: p.callId, name: p.toolName, args: p.input === undefined ? {} : p.input };
+    case 'tool_result': return {
+      part_id: p.partId, kind: 'tool_result', call_id: p.callId, is_error: Boolean(p.isError), status: 'completed',
+      output: p.text, output_len: py.pyLen(p.text),
+    };
+    case 'summary': return { part_id: p.partId, kind: 'summary', text: p.text, replaces: 'unknown' };
+    default: throw new Error(`no record part for a '${p.kind}' part`);
+  }
+}
+
+/**
+ * The records of one parsed session. `harnessVersion` names the import batch (import:<batch>) on
+ * the session record; nothing else in the records depends on the batch.
+ */
+function recordsOf(s, { harnessVersion = '' } = {}) {
+  const messages = [];
+  const byId = new Map();
+  for (const p of s.parts) {
+    let m = byId.get(p.messageId);
+    if (!m) {
+      const role = p.messageRole || p.role;
+      m = {
+        type: 'message', message_id: p.messageId, order: String(messages.length).padStart(6, '0'), parent_id: p.parentId || null,
+        agent_id: '', role, source: null, to_user: null, to_model: null, status: 'complete', state: 'current', on_active_branch: null,
+        ts: iso(p.ts), requested_model: '', served_model: '', effort: '', response_id: role === 'assistant' ? p.messageId : null,
+        aliases: [], parts: [],
+      };
+      byId.set(p.messageId, m);
+      messages.push(m);
+    }
+    m.parts.push(partOf(p));
+  }
+  const session = {
+    type: 'session', harness: 'claude-ai', engine: '', client: 'claude.ai', harness_version: harnessVersion,
+    title: s.name, title_set_by: 'unknown', cwd: '', last_cwd: '', created_at: iso(s.created), updated_at: iso(s.updated),
+    state: 'active', pinned: null, mode: s.mode, kind: '', reuse: '', ts_source: 'event', aliases: [], fingerprint: null, setup: null,
+  };
+  return [session, ...messages];
+}
+
+module.exports = { recordsOf, partOf, iso };