memhouse 0.18.12 → 0.20.1

package/editors/normalise/zed.js

@@ -0,0 +1,473 @@
+'use strict';
+// v4 wave 2: Zed (the native agent) → normalised session log records (docs/design/sessions-log.md,
+// plus the wave-1 format additions: archived, children, lifecycle, hidden, source, exit_code).
+//
+// Store: <data folder>/threads/threads.db (harness-paths dataFolder('zed'): ~/.local/share/zed on
+// Linux, ~/Library/Application Support/Zed on macOS), SQLite with a rollback journal, opened
+// read-only. Table `threads(id, summary, updated_at, data_type, data, parent_id, folder_paths,
+// folder_paths_order, created_at)`: one row per thread; `data` is the whole thread as JSON
+// (data_type 'json') or zstd-compressed JSON ('zstd'), rewritten on every save. Columns vary by
+// build, so the reader asks the table what it has. Archive state lives elsewhere: the workspace
+// DB <data folder>/db/<channel>/db.sqlite, table `sidebar_threads(session_id, archived, …)` (WAL);
+// only those two columns are read.
+// Spec: docs/design/editor-shapes.md "Zed 1.24.3" (repository) with the annex's correction
+// (User messages carry an `id`), sessions-model v0 §1 rule 4 (anchored ids), §2.3, §2.4, §2.5.
+//
+// Rules:
+// - message ids: a User message keeps its `id`. Every other message (Agent, Resume, Compaction,
+//   an unknown entry's notice) has none and is anchored to the nearest preceding User id:
+//   `<user id>+n`, n counting from 1 (a message before any User message anchors to the thread id).
+//   A checkpoint restore truncates messages[] in place from a User message on, and the regrown turn
+//   has a new User id, so the old anchored keys vanish from the log (the engine keeps them as
+//   removed): no lifecycle record, the store keeps no trace of the restore;
+// - order: the array position. ts: none per message (null; the engine falls back to first-seen);
+// - parts: block index as part_id. User Text | Mention (hidden: the expanded context, not what was
+//   typed) | Image (file part, sha of the decoded PNG). Agent Text | Thinking (opaque when only a
+//   signature) | RedactedThinking (opaque) | ToolUse, whose result is `tool_results[<ToolUse.id>]`,
+//   folded into the same part. `reasoning_details` becomes a reasoning part only when the message
+//   has no Thinking content (it is the provider's copy of the same reasoning);
+// - tool results: `is_error` is unreliable (a failing command stores false), so only `true` is
+//   kept and anything else is null. The terminal tool's own header `Command "…" failed with exit
+//   code N.` gives exit_code. Zed's own canned results (`Tool canceled by user`, the permission
+//   denials) set status cancelled | denied;
+// - usage: one per-session series from the thread's own total, `cumulative_token_usage`
+//   (sessions-model §2.4 "No overlap": "Zed has one `per_session` record"; annex zed: "The per-turn
+//   value is not a turn total"). It is handed to writeLog as a running total (`running: true`,
+//   usage_id `session`), which keeps it in the log as increments (`session#1`, `session#2`, …), so the
+//   log still only appends as the thread grows: the total itself, changed in place on every turn,
+//   would rewrite the whole log each time. No message carries usage. `request_token_usage[<user id>]`
+//   is not written: it holds only a turn's last request (each request of the turn overwrites it) and
+//   is part of the total, so writing it too would count those tokens twice. An empty total (no
+//   counter above zero) writes no usage at all, even when request_token_usage has values: those are
+//   last-request snapshots, and a number known to be partial would be billed as the session's (the
+//   harness-session-adapters package writes none either). Basis anthropic: Zed's own source defines total
+//   input = input + cache_creation + cache_read, so input excludes cache, and output has no
+//   reasoning split. Absent counters (Zed omits zeros) are null. A checkpoint restore does not
+//   reduce the total (annex), so the increments already written stay. Time: the thread's own
+//   `updated_at` (its last save, of the same blob as the total), else the row's: each increment is
+//   dated by the save that first showed its tokens, and keeps that time (and its key) through any
+//   later rewrite. Only a thread with neither falls back to first-seen;
+// - model: thread `model.model` (the provider name is not carried), effort: thread
+//   `thinking_effort`. Both are per thread, so a mid-thread change relabels earlier messages;
+// - held back: in the last turn (no later User message), an Agent message with a ToolUse that has no
+//   result or whose input is incomplete, and everything after it (the usage increments do not wait:
+//   they are tokens already spent, and they only append).
+//   Zed (main) skips saves while a reply streams and gives every unanswered ToolUse a cancel result
+//   when it flushes, so this should not fire; an earlier turn keeps such a call as interrupted;
+// - Resume (a "continue" the harness sends as a user turn): role user, source automated, one
+//   notice part. Compaction{Summary}: a lifecycle record, then a system message with a summary part
+//   (`replaces.through_id` = the message before it); ProviderNative: the same, opaque. Both are
+//   source-read (Zed main), not seen in the lab;
+// - nothing in messages[] is dropped (sessions-model §2.3: a notice covers "any native kind the
+//   model lacks … Never dropped"). An entry this reader does not know (a new variant, or a known one
+//   in a shape it does not read) is a system message with one notice part naming the variant,
+//   anchored like the rest, so every message after it keeps its native position and its
+//   `<anchor>+n` (§1 rule 4: never an index of emitted rows). A User message without an `id` is
+//   anchored the same way. A content segment this reader does not know is a notice part at its own
+//   index. Only the variant's name is written, never its payload: what an unknown variant carries
+//   is unknown. A name is an identifier (`^[A-Z][A-Za-z0-9_]{0,63}$`); anything else, such as a
+//   bare string in place of an entry or a segment, is written as `unknown`;
+// - session: title = row `summary`, cwd = the first of `folder_paths` in its stored order (else the
+//   initial project snapshot's first worktree), created = row `created_at`, mode = `profile`,
+//   archived = true when a sidebar row says so (a flag; no time stored). Sub-agent: the child row's
+//   `parent_id` / `subagent_context.parent_thread_id` is one explicit child-side link; a parent's
+//   `spawn_agent` result naming a `session_id` is origin-side (`children`);
+// - not read: legacy agent-1 thread blobs (messages with `role`; version 0.1.0/0.2.0/none). They
+//   yield null (nothing written) until Zed re-saves them as 0.3.0;
+// - volatile fields stay out: row/thread `updated_at`, `ui_scroll_position`, `draft_prompt`;
+// - redaction: the thread holds no credential (the provider key is in env or the keyring). Tool
+//   signatures, the git snapshot (its remote URL) and sandbox grants are never emitted.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const zlib = require('zlib');
+const { openReadOnly, textOf, bytesOf } = require('../sqlite');
+const harnessPaths = require('../harness-paths');
+const { placeChildren } = require('../sessions-log');
+
+const HARNESS = 'zed';
+// Bumped when the records change for an unchanged store, so the runner normalises every session again
+// (normalise-run.js) and the engine re-derives its rewritten log at a higher rev. 2: usage from
+// cumulative_token_usage as a running total; an unknown messages[] entry keeps its place.
+const VERSION = 2;
+const ROW_COLS = ['id', 'summary', 'created_at', 'parent_id', 'folder_paths', 'folder_paths_order', 'data_type'];
+const CANCELLED = new Set(['Tool canceled by user']);
+const DENIED = new Set([
+  'Permission to run tool denied by user',
+  'Permission denied: user sent a follow-up message instead of approving the tool call.',
+]);
+
+function storeRootDefault() { return harnessPaths.dataFolder(HARNESS); }
+function dbPathOf(storeRoot) { return path.join(storeRoot, 'threads', 'threads.db'); }
+
+// ── small helpers ─────────────────────────────────────────────────────────────────────────────
+const ms = (v) => { const t = Date.parse(v); return Number.isFinite(t) ? t : null; };
+const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex');
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** The single key of an externally tagged serde enum ({Text: …}), or a unit variant's string. */
+function variant(v) {
+  if (typeof v === 'string') return [v, null];
+  if (isObj(v)) { const k = Object.keys(v); if (k.length === 1) return [k[0], v[k[0]]]; }
+  return [null, null];
+}
+/** A token counter: absent (Zed omits zeros) or invalid is null. */
+function count(v) { const x = Math.trunc(Number(v)); return v != null && Number.isFinite(x) && x >= 0 ? x : null; }
+
+/** zstd: Node's own (>= 22.15 / 23.8; the engines floor is 24), else the zstd CLI over a pipe. */
+function zstdDecompress(buf) {
+  if (typeof zlib.zstdDecompressSync === 'function') return zlib.zstdDecompressSync(buf);
+  const { execFileSync } = require('child_process');
+  return execFileSync(process.platform === 'win32' ? 'zstd.exe' : 'zstd', ['-d', '-c', '-q'], { input: buf, maxBuffer: 1 << 30, stdio: ['pipe', 'pipe', 'ignore'] });
+}
+/** A `threads.data` value → the parsed thread, or null when it cannot be read. */
+function decodeData(data, dataType) {
+  if (data == null) return null;
+  try {
+    const buf = bytesOf(data);
+    const json = String(dataType || 'zstd') === 'json' ? buf.toString('utf-8') : zstdDecompress(buf).toString('utf-8');
+    const t = JSON.parse(json);
+    return isObj(t) ? t : null;
+  } catch { return null; }
+}
+
+// ── store reads ───────────────────────────────────────────────────────────────────────────────
+// Every read error propagates (the module contract, docs/design/sessions-log.md): a save in progress
+// (threads.db keeps a rollback journal, so a reader waits on the writer's lock, then fails busy), a
+// damaged page, a file that is not a database. The pass fails and the runner retries it; nothing
+// reads as no threads, no columns or no archive flag. Only a missing table or column is empty, and
+// PRAGMA table_info gives that as no rows, without an error.
+function columnsOf(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((r) => String(r.name)));
+}
+function rowOf(r) {
+  const s = (v) => (v == null ? null : String(textOf(v)));
+  return {
+    id: String(textOf(r.id)), summary: s(r.summary), created_at: s(r.created_at), parent_id: s(r.parent_id),
+    folder_paths: s(r.folder_paths), folder_paths_order: s(r.folder_paths_order), data_type: s(r.data_type),
+  };
+}
+function openThreads(file) {
+  const db = openReadOnly(file);
+  try { db.exec('PRAGMA busy_timeout = 2000'); } catch { /* a plain read still works */ }
+  return db;
+}
+
+/** session_id → true for the threads any channel's sidebar marks archived (a flag, no time). */
+function readArchived(storeRoot) {
+  const out = new Map();
+  let channels = [];
+  try { channels = fs.readdirSync(path.join(storeRoot, 'db')).sort(); } catch { return out; }
+  for (const ch of channels) {
+    const file = path.join(storeRoot, 'db', ch, 'db.sqlite');
+    try { if (!fs.statSync(file).isFile()) continue; } catch { continue; }
+    let db = null;
+    try {
+      db = openReadOnly(file);
+      const cols = columnsOf(db, 'sidebar_threads');
+      if (!cols.has('session_id') || !cols.has('archived')) continue;
+      for (const r of db.prepare('SELECT session_id, archived FROM sidebar_threads WHERE session_id IS NOT NULL').all()) {
+        const sid = String(textOf(r.session_id));
+        if (sid && Number(r.archived) === 1) out.set(sid, true);
+      }
+    } finally { if (db) try { db.close(); } catch { /* closed */ } }
+  }
+  return out;
+}
+
+/**
+ * Sessions in one store: one per `threads` row. No blob is read here. Each entry carries
+ * harness_path (the data folder, resolved: = dataFolder('zed') for the default store), the threads
+ * DB relative to it (`db_rel`: every thread shares that DB, so its absolute path would make any
+ * write re-run every thread), the row's `updated_at` as this thread's change key (Zed sets it when
+ * it saves the thread), and the sidebar's archive flag as a field. No row metadata: folder_paths is
+ * a project path the runner would stat. The workspace DB is not listed as a file: Zed writes it on
+ * every UI change, and the one value read from it is the field.
+ */
+function list(storeRoot = storeRootDefault()) {
+  const file = dbPathOf(storeRoot);
+  try { if (!fs.statSync(file).isFile()) return []; } catch { return []; }
+  const harnessPath = harnessPaths.resolveNative(storeRoot);
+  const db = openThreads(file);
+  let rows = [];
+  try {
+    const cols = columnsOf(db, 'threads');
+    if (!cols.has('id')) return [];
+    rows = db.prepare(`SELECT id, ${cols.has('updated_at') ? 'updated_at' : "'' AS updated_at"} FROM threads ORDER BY id`).all()
+      .map((r) => ({ id: String(textOf(r.id)), updated_at: r.updated_at == null ? '' : String(textOf(r.updated_at)) }));
+  } finally { db.close(); }
+  const archived = readArchived(storeRoot);
+  const rel = path.relative(storeRoot, file);
+  return rows.map((r) => ({ harness: HARNESS, harness_path: harnessPath, session_id: r.id, db_rel: rel, updated_at: r.updated_at, archived: archived.get(r.id) === true }));
+}
+
+/** One thread's row and blob, read together so they are of the same save. */
+function loadFromDb(session) {
+  const db = openThreads(session.db || path.join(session.harness_path, session.db_rel));
+  try {
+    const cols = columnsOf(db, 'threads');
+    const sel = ROW_COLS.filter((c) => cols.has(c));
+    const r = db.prepare(`SELECT ${sel.join(', ')}, data FROM threads WHERE id = ?`).get(String(session.session_id));
+    if (!r) return null;
+    const row = rowOf(r);
+    return { row, thread: decodeData(r.data, row.data_type) };
+  } finally { db.close(); }
+}
+
+// ── parts ─────────────────────────────────────────────────────────────────────────────────────
+/** LanguageModelToolUseInput: {type: json|text, value}, or (older) the bare JSON. */
+function argsOf(tu) {
+  const inp = tu.input;
+  if (isObj(inp) && Object.keys(inp).length === 2 && typeof inp.type === 'string' && 'value' in inp) {
+    if (inp.type === 'json') return inp.value ?? {};
+    if (inp.type === 'text') return { raw: String(inp.value ?? '') };
+  }
+  if (inp != null) return inp;
+  if (typeof tu.raw_input === 'string' && tu.raw_input) { try { return JSON.parse(tu.raw_input); } catch { return { raw: tu.raw_input }; } }
+  return {};
+}
+/** LanguageModelToolResultContent, one or a list: Text | Image, in any of serde's accepted shapes. */
+function resultText(content) {
+  const one = (c) => {
+    if (typeof c === 'string') return c;
+    if (!isObj(c)) return '';
+    const key = (n) => Object.keys(c).find((k) => k.toLowerCase() === n);
+    const t = key('text');
+    if (t && typeof c[t] === 'string' && (Object.keys(c).length === 1 || String(c[key('type')] || '').toLowerCase() === 'text')) return c[t];
+    if (key('image')) return '[image]';
+    return '';
+  };
+  return Array.isArray(content) ? content.map(one).join('') : one(content);
+}
+/** The terminal tool's own header, before any command output (after Zed's sandbox notes). */
+function exitCodeOf(tool, text) {
+  if (tool !== 'terminal' || !text) return null;
+  for (const para of text.split('\n\n')) {
+    if (para.startsWith('Note:')) continue;
+    const m = /^Command "[\s\S]*" failed with exit code (-?\d+)\.(?: |$)/.exec(para);
+    return m ? Number(m[1]) : null;
+  }
+  return null;
+}
+
+function toolPart(tu, idx, results) {
+  const callId = String(tu.id ?? idx);
+  const tool = String(tu.name || 'unknown');
+  const r = isObj(results) && Object.prototype.hasOwnProperty.call(results, callId) ? results[callId] : null;
+  const part = { part_id: String(idx), kind: 'tool', call_id: callId, tool, args: argsOf(tu), output: null, is_error: null, status: 'interrupted' };
+  if (!isObj(r)) return { part, open: true };
+  const output = resultText(r.content);
+  const exit = exitCodeOf(tool, output);
+  part.output = output;
+  part.is_error = r.is_error === true ? true : null;
+  part.status = CANCELLED.has(output) ? 'cancelled' : DENIED.has(output) ? 'denied' : (r.is_error === true ? 'error' : 'completed');
+  if (exit !== null) part.exit_code = exit;
+  return { part, open: tu.is_input_complete === false };
+}
+
+/** `reasoning_details` (provider-shaped JSON): readable text where an entry has some, else opaque. */
+function reasoningDetailsPart(rd) {
+  if (rd == null) return null;
+  const texts = [];
+  for (const e of Array.isArray(rd) ? rd : [rd]) {
+    if (typeof e === 'string') { texts.push(e); continue; }
+    if (!isObj(e)) continue;
+    if (typeof e.text === 'string' && e.text) texts.push(e.text);
+    else if (typeof e.summary === 'string' && e.summary) texts.push(e.summary);
+  }
+  return texts.length ? { part_id: 'reasoning_details', kind: 'reasoning', text: texts.join('\n') }
+    : { part_id: 'reasoning_details', kind: 'reasoning', text: '', opaque: true };
+}
+
+/**
+ * What a notice may say about an entry or segment this reader does not know: its variant's name,
+ * when it is one (serde's names: an identifier, capitalised), else `unknown`. variant() returns a
+ * bare string whole as its "name", and an object's key could be anything: neither is written, so
+ * nothing of an unknown payload reaches the log.
+ */
+const VARIANT_NAME = /^[A-Z][A-Za-z0-9_]{0,63}$/;
+const nameOf = (k) => (typeof k === 'string' && VARIANT_NAME.test(k) ? k : 'unknown');
+/** A notice part for a content segment this reader does not know: its variant's name, never its payload. */
+const unknownPart = (i, k) => ({ part_id: String(i), kind: 'notice', text: nameOf(k) });
+
+function userParts(content) {
+  const parts = [];
+  (Array.isArray(content) ? content : []).forEach((c, i) => {
+    const [k, v] = variant(c);
+    if (k === 'Text' && typeof v === 'string') parts.push({ part_id: String(i), kind: 'text', text: v });
+    else if (k === 'Mention' && isObj(v)) {
+      const ref = typeof v.uri === 'string' ? v.uri : JSON.stringify(v.uri ?? '');
+      parts.push({ part_id: String(i), kind: 'text', text: String(v.content ?? ''), ref, hidden: true });
+    } else if (k === 'Image' && isObj(v)) {
+      const bytes = typeof v.source === 'string' ? Buffer.from(v.source, 'base64') : null;
+      parts.push({ part_id: String(i), kind: 'file', media_type: 'image/png', att_sha: bytes ? sha256(bytes) : null, att_len: bytes ? bytes.length : null, ref: '' });
+    } else parts.push(unknownPart(i, k));
+  });
+  return parts;
+}
+
+function agentParts(msg) {
+  const parts = [];
+  let open = false;
+  let thinking = false;
+  (Array.isArray(msg.content) ? msg.content : []).forEach((c, i) => {
+    const [k, v] = variant(c);
+    if (k === 'Text' && typeof v === 'string') parts.push({ part_id: String(i), kind: 'text', text: v });
+    else if (k === 'Thinking' && isObj(v)) {
+      thinking = true;
+      const text = typeof v.text === 'string' ? v.text : '';
+      if (text) parts.push({ part_id: String(i), kind: 'reasoning', text });
+      else if (v.signature) parts.push({ part_id: String(i), kind: 'reasoning', text: '', opaque: true });
+    } else if (k === 'RedactedThinking') {
+      thinking = true;
+      parts.push({ part_id: String(i), kind: 'reasoning', text: '', opaque: true });
+    } else if (k === 'ToolUse' && isObj(v)) {
+      const t = toolPart(v, i, msg.tool_results);
+      parts.push(t.part);
+      if (t.open) open = true;
+    } else parts.push(unknownPart(i, k));
+  });
+  if (!thinking) { const rd = reasoningDetailsPart(msg.reasoning_details); if (rd) parts.unshift(rd); }
+  return { parts, open };
+}
+
+function usageOf(u) {
+  if (!isObj(u)) return null;
+  const x = { input: count(u.input_tokens), output: count(u.output_tokens), cache_read: count(u.cache_read_input_tokens), cache_write: count(u.cache_creation_input_tokens) };
+  if (Object.values(x).every((v) => v === null)) return null;
+  return { basis: 'anthropic', ...x, reasoning: null, cost: null };
+}
+
+/** folder_paths: lexicographic, `\n`-separated; folder_paths_order: each path's original position. */
+function firstFolder(row, thread) {
+  const paths = row && row.folder_paths ? row.folder_paths.split('\n').filter(Boolean) : [];
+  if (paths.length) {
+    const order = String((row && row.folder_paths_order) || '').split(',').map((s) => Number.parseInt(s, 10));
+    const j = order.length === paths.length ? order.indexOf(0) : -1;
+    return paths[j >= 0 ? j : 0];
+  }
+  const ws = thread && thread.initial_project_snapshot && thread.initial_project_snapshot.worktree_snapshots;
+  return Array.isArray(ws) && ws[0] && typeof ws[0].worktree_path === 'string' ? ws[0].worktree_path : '';
+}
+
+// ── normalise ─────────────────────────────────────────────────────────────────────────────────
+/**
+ * Normalise one thread. `session` is a list() entry, or native data already loaded (tests):
+ * `{ session_id, row?, thread }` (the parsed JSON) or `{ session_id, row?, data, data_type }` (the
+ * stored blob), with `archived` optional. Returns the log records, the session record first; null
+ * when the thread cannot be read (missing row, undecodable blob, a legacy agent-1 thread), so the
+ * caller writes nothing rather than an empty log.
+ */
+function normalise(session) {
+  const sid = String(session.session_id);
+  let row = session.row || null;
+  let thread = null;
+  if (isObj(session.thread)) thread = session.thread;
+  else if (session.data != null) thread = decodeData(session.data, session.data_type || (row && row.data_type));
+  else if (session.db || (session.db_rel && session.harness_path)) {
+    const l = loadFromDb(session);
+    if (!l) return null;
+    row = l.row; thread = l.thread;
+  }
+  if (!thread || !Array.isArray(thread.messages)) return null;
+  if (thread.messages.some((m) => isObj(m) && 'role' in m)) return null;   // legacy agent-1 shape
+
+  const model = isObj(thread.model) && thread.model.model ? String(thread.model.model) : '';
+  const effort = thread.thinking_effort ? String(thread.thinking_effort) : '';
+  const sub = isObj(thread.subagent_context) ? thread.subagent_context : null;
+  const origin = (sub && sub.parent_thread_id ? String(sub.parent_thread_id) : '') || (row && row.parent_id) || '';
+  const links = origin && origin !== sid ? [{ kind: 'subagent', origin, evidence: 'explicit', at: '' }] : [];
+
+  const msgs = thread.messages;
+  let lastUser = -1;
+  msgs.forEach((m, i) => { if (variant(m)[0] === 'User') lastUser = i; });
+
+  const out = [];
+  const children = [];
+  let anchor = sid;
+  let n = 0;
+  let prevId = null;
+  for (let i = 0; i < msgs.length; i++) {
+    const [k, v] = variant(msgs[i]);
+    if (k === 'User' && isObj(v) && v.id != null) {
+      anchor = String(v.id); n = 0;
+      out.push({ k: 'message', message_id: anchor, role: 'user', ts: null, order: i, state: 'current', status: 'complete', parts: userParts(v.content) });
+      prevId = anchor;
+      continue;
+    }
+    if (k === 'User' && isObj(v)) {
+      // A User message without its id: anchored like the others, so it keeps its place.
+      const id = `${anchor}+${++n}`;
+      out.push({ k: 'message', message_id: id, role: 'user', ts: null, order: i, state: 'current', status: 'complete', parts: userParts(v.content) });
+      prevId = id;
+      continue;
+    }
+    if (k === 'Agent' && isObj(v)) {
+      const id = `${anchor}+${++n}`;
+      const { parts, open } = agentParts(v);
+      if (open && i > lastUser) break;   // the last turn is still running
+      for (const p of parts) {
+        if (p.kind !== 'tool' || p.tool !== 'spawn_agent' || p.output == null) continue;
+        const o = isObj(v.tool_results) && isObj(v.tool_results[p.call_id]) ? v.tool_results[p.call_id].output : null;
+        let child = isObj(o) && typeof o.session_id === 'string' ? o.session_id : null;
+        if (!child) { try { const j = JSON.parse(p.output); child = isObj(j) && typeof j.session_id === 'string' ? j.session_id : null; } catch { child = null; } }
+        if (child && child !== sid && !children.some((c) => c.session_id === child)) children.push({ kind: 'subagent', session_id: child, evidence: 'explicit', after: id });
+      }
+      const rec = {
+        k: 'message', message_id: id, role: 'assistant', ts: null, order: i, state: 'current',
+        status: parts.some((p) => p.kind === 'tool' && p.status === 'interrupted') ? 'interrupted' : 'complete',
+        model, effort, usage: null, parts,
+      };
+      out.push(rec);
+      prevId = id;
+      continue;
+    }
+    if (k === 'Resume') {
+      const id = `${anchor}+${++n}`;
+      out.push({ k: 'message', message_id: id, role: 'user', source: 'automated', ts: null, order: i, state: 'current', status: 'complete', parts: [{ part_id: '0', kind: 'notice', text: 'Resume' }] });
+      prevId = id;
+      continue;
+    }
+    if (k === 'Compaction') {
+      const id = `${anchor}+${++n}`;
+      const [ck, cv] = variant(v);
+      const summary = ck === 'Summary' && typeof cv === 'string'
+        ? { part_id: '0', kind: 'summary', text: cv, replaces: { through_id: prevId } }
+        : { part_id: '0', kind: 'summary', text: '', opaque: true, replaces: { through_id: prevId } };
+      out.push({ k: 'lifecycle', event: 'compaction', at: null, ...(prevId ? { through: prevId } : {}) });
+      out.push({ k: 'message', message_id: id, role: 'system', ts: null, order: i, state: 'current', status: 'complete', parts: [summary] });
+      prevId = id;
+      continue;
+    }
+    // Any other entry: kept in its place as a notice naming the variant, and counted, so the
+    // messages after it keep their anchored ids (the header's rule).
+    const id = `${anchor}+${++n}`;
+    out.push({ k: 'message', message_id: id, role: 'system', ts: null, order: i, state: 'current', status: 'complete', parts: [{ part_id: '0', kind: 'notice', text: nameOf(k) }] });
+    prevId = id;
+  }
+
+  // Usage: the thread's own total, one per-session series, as a running total that writeLog keeps as
+  // increments (the header's usage rule), dated by the thread's last save. request_token_usage is
+  // not read.
+  const total = usageOf(thread.cumulative_token_usage);
+  const spent = total && [total.input, total.output, total.cache_read, total.cache_write].some((x) => x > 0);
+  const saved = ms(thread.updated_at) ?? ms(session.updated_at) ?? (row ? ms(row.updated_at) : null);
+  const usage = spent ? [{ k: 'usage', usage_id: 'session', running: true, ts: saved, ...(model ? { model } : {}), usage: total }] : [];
+
+  const head = {
+    k: 'session',
+    title: String((row && row.summary) || thread.title || ''),
+    cwd: firstFolder(row, thread),
+    created: row ? ms(row.created_at) : null,
+    updated: null,
+    archived: session.archived === true ? true : null,
+    version: '', incarnation: '',
+    mode: thread.profile ? String(thread.profile) : '',
+    ...(origin ? { kind: 'subagent' } : {}),
+    links,
+    ...(children.length ? { children } : {}),
+  };
+  return [...placeChildren([head, ...out]), ...usage];
+}
+
+module.exports = { HARNESS, VERSION, list, normalise, decodeData, storeRootDefault, dbPathOf };

package/editors/opencode-v4.js

@@ -0,0 +1,119 @@
+'use strict';
+// v4 prototype: OpenCode (v1 engine) → normalised session log records (editors/sessions-log.js).
+// Input is the database read as rows ({ sessions, messages, parts }, the shapes in
+// docs/design/adapter-specs/opencode.md §3); output is one record list per session.
+//
+// Rules from the spec:
+// - order: messages by (time_created, id), parts by id;
+// - a tool part holds both the call and its result;
+// - tokens: step-finish parts, basis net (input = prompt − cache.read, output = completion − reasoning);
+// - an assistant message still streaming (no time.completed, no error) is held back;
+// - sub-agent: session.parent_id (explicit); fork: no column, a copied message's id-embedded time is
+//   later than its time_created (inferred), the origin found by content.
+
+const crypto = require('crypto');
+
+const MS_MOD = 2 ** 36;          // ids carry the low 48 bits of ms·4096 + counter: ms modulo 2^36
+const COPY_SLACK_MS = 1000;
+
+/** The id-embedded time of an OpenCode id, modulo 2^36 ms. */
+function idTime(id) {
+  const m = /^[a-z]+_([0-9a-f]{12})/.exec(String(id));
+  return m ? Math.floor(parseInt(m[1], 16) / 4096) % MS_MOD : null;
+}
+function wasCopied(row) {
+  const t = idTime(row.id);
+  if (t === null) return false;
+  return ((t - (Number(row.time_created) % MS_MOD) + MS_MOD) % MS_MOD) > COPY_SLACK_MS
+    && ((t - (Number(row.time_created) % MS_MOD) + MS_MOD) % MS_MOD) < MS_MOD / 2;
+}
+
+function partRecord(p) {
+  const d = p.data || {};
+  if (d.type === 'text') return { part_id: p.id, kind: 'text', text: d.text || '', ts: p.time_created };
+  if (d.type === 'reasoning') return { part_id: p.id, kind: 'reasoning', text: d.text || '', ts: p.time_created };
+  if (d.type === 'tool') {
+    const st = d.state || {};
+    return {
+      part_id: p.id, kind: 'tool', call_id: d.callID, tool: d.tool, args: st.input || {},
+      output: st.status === 'completed' || st.status === 'error' ? (st.output ?? st.error ?? '') : null,
+      is_error: st.status === 'error', ts: p.time_created,
+    };
+  }
+  return null;   // step-start / step-finish / patch / snapshot: not message content
+}
+function usageOf(parts) {
+  const fins = parts.filter((p) => (p.data || {}).type === 'step-finish');
+  if (!fins.length) return null;
+  const u = { basis: 'net', input: 0, output: 0, reasoning: 0, cache_read: 0, cache_write: 0 };
+  for (const p of fins) {
+    const t = p.data.tokens || {};
+    u.input += t.input || 0; u.output += t.output || 0; u.reasoning += t.reasoning || 0;
+    u.cache_read += (t.cache && t.cache.read) || 0; u.cache_write += (t.cache && t.cache.write) || 0;
+  }
+  return u;
+}
+const contentKey = (m) => crypto.createHash('sha256').update(JSON.stringify([m.role, (m.parts || []).map((p) => [p.kind, p.text ?? p.output ?? p.tool ?? ''])])).digest('hex');
+
+/** { sessions, messages, parts } → Map(session_id → records) */
+function normalise(db) {
+  const bySession = new Map();
+  const partsByMsg = new Map();
+  for (const p of db.parts || []) {
+    if (!partsByMsg.has(p.message_id)) partsByMsg.set(p.message_id, []);
+    partsByMsg.get(p.message_id).push(p);
+  }
+  for (const list of partsByMsg.values()) list.sort((a, b) => (a.id < b.id ? -1 : 1));
+  const msgsOf = new Map();
+  for (const m of db.messages || []) {
+    if (!msgsOf.has(m.session_id)) msgsOf.set(m.session_id, []);
+    msgsOf.get(m.session_id).push(m);
+  }
+  const messageRecords = new Map();
+  for (const s of db.sessions || []) {
+    const rows = (msgsOf.get(s.id) || []).sort((a, b) => (a.time_created - b.time_created) || (a.id < b.id ? -1 : 1));
+    const out = [];
+    for (const m of rows) {
+      const d = m.data || {};
+      if (d.role === 'assistant' && !(d.time && d.time.completed) && !d.error) continue;   // still streaming
+      const parts = partsByMsg.get(m.id) || [];
+      out.push({
+        k: 'message', message_id: m.id, role: d.role, ts: m.time_created,
+        parent_id: d.parentID || '', model: d.modelID || (d.model && d.model.modelID) || '',
+        effort: d.variant || (d.model && d.model.variant) || '',
+        status: d.error ? 'error' : 'complete',
+        parts: parts.map(partRecord).filter(Boolean),
+        usage: d.role === 'assistant' ? usageOf(parts) : null,
+        _copied: wasCopied(m),
+      });
+    }
+    messageRecords.set(s.id, out);
+  }
+  // Links. Sub-agent: explicit. Fork: the copied prefix's content found in another session.
+  const index = new Map();
+  for (const [sid, recs] of messageRecords) for (const r of recs) if (!r._copied) {
+    const k = contentKey(r);
+    if (!index.has(k)) index.set(k, []);
+    index.get(k).push({ sid, message_id: r.message_id });
+  }
+  for (const s of db.sessions || []) {
+    const recs = messageRecords.get(s.id) || [];
+    const links = [];
+    if (s.parent_id) links.push({ kind: 'subagent', origin: s.parent_id, evidence: 'explicit', at: '' });
+    const copied = recs.filter((r) => r._copied);
+    if (copied.length) {
+      const hits = copied.map((r) => (index.get(contentKey(r)) || []).filter((h) => h.sid !== s.id));
+      const origins = new Set(hits.flat().map((h) => h.sid));
+      if (origins.size === 1 && hits.every((h) => h.length)) {
+        const origin = [...origins][0];
+        const last = hits[hits.length - 1].find((h) => h.sid === origin);
+        links.push({ kind: 'fork', origin, evidence: 'inferred', at: last.message_id, through: copied[copied.length - 1].message_id });
+      }
+    }
+    const session = { k: 'session', title: s.title || '', cwd: s.directory || '', created: s.time_created, archived: s.time_archived || null, version: s.version || '', links };
+    bySession.set(s.id, [session, ...recs.map(({ _copied, ...r }) => r)]);
+  }
+  return bySession;
+}
+
+module.exports = { normalise, idTime, wasCopied };

package/editors/scope.js

@@ -29,16 +29,27 @@ function parseList(value) {
 }
 
 /** The adapters that should run, in the order given. */
+// Names the v4 normalisers answer to (editors/normalise/): known to MEMHOUSE_EDITORS, though no 0.18
+// adapter carries them. agy (the Antigravity CLI) also answers to 'antigravity'.
+const NORMALISER_NAMES = ['agy', 'copilot-cli', 'cursor', 'cursor-agent', 'devin', 'gemini-cli', 'goose', 'opencode', 'vscode', 'zed'];
+const NORMALISER_ALIASES = { agy: ['antigravity'] };
+/** Whether MEMHOUSE_EDITORS lets a normaliser run (nothing set: every one). */
+function normaliserInScope(harness, value) {
+  const wanted = parseList(value);
+  return !wanted.length || wanted.includes(harness) || (NORMALISER_ALIASES[harness] || []).some((a) => wanted.includes(a));
+}
+
 function selectEditors(editors, value) {
   const wanted = parseList(value);
   if (!wanted.length) return editors;
   const byName = new Map(editors.map((e) => [e.name, e]));
-  const unknown = wanted.filter((n) => !byName.has(n));
+  const aliases = Object.values(NORMALISER_ALIASES).flat();
+  const unknown = wanted.filter((n) => !byName.has(n) && !NORMALISER_NAMES.includes(n) && !aliases.includes(n));
   if (unknown.length) {
     throw new Error(`MEMHOUSE_EDITORS names an adapter that does not exist: ${unknown.join(', ')}. `
       + `Known: ${editors.map((e) => e.name).join(', ')}`);
   }
-  return wanted.map((n) => byName.get(n));
+  return wanted.filter((n) => byName.has(n)).map((n) => byName.get(n));
 }
 
 function expandHome(p) {
@@ -123,4 +134,4 @@ function watching() {
   return [...watched.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, w]) => ({ name, ...w }));
 }
 
-module.exports = { parseList, selectEditors, selectClaudeRoots, selectRoot, expandHome, describe, keyFor, root, roots, fixed, watching };
+module.exports = { parseList, selectEditors, selectClaudeRoots, selectRoot, expandHome, describe, keyFor, root, roots, fixed, watching, normaliserInScope, NORMALISER_NAMES, NORMALISER_ALIASES };