memhouse 0.18.12 → 0.20.1

package/editors/normalise/goose.js

@@ -0,0 +1,673 @@
+'use strict';
+// v4 wave 2: Goose → normalised session log records (docs/design/sessions-log.md, with the format
+// additions v2/v3: archived, children, exit_code, model_requested, hidden, lifecycle, server,
+// source, content_id).
+//
+// Store: <data>/sessions/sessions.db (SQLite, WAL), opened read-only in place (rows live in the WAL
+// for hours: never copy the main file alone). <data> is $GOOSE_PATH_ROOT/data, else
+// $XDG_DATA_HOME/goose, else harness-paths' data folder (~/.local/share/goose).
+//   - sessions: one row per session; `id` is `YYYYMMDD_N` (UTC date, MAX(N)+1), reused after a
+//     delete of the max;
+//   - messages: one row per message; content_json[] (parts), metadata_json (visibility flags,
+//     inference, usage, operations); `id` is a rowid, re-minted by `--edit`;
+//   - usage_ledger: one row per LLM call (authoritative), including compaction calls.
+// Spec: docs/design/adapter-specs/goose.md (gs3, repository); sessions-model v0 and its annex.
+//
+// Rules:
+// - message id = messages.message_id, never messages.id (positions are not identities). A NULL id is
+//   anchored on the previous native id (`<id>+n`); a repeat inside one session is `<id>+n` too;
+// - order = ORDER BY created_timestamp, id (the harness's own load query), as the position in that
+//   order. Same-second rows can sort against causality (an elicitation response precedes its
+//   request): both are kept as stored, nothing is reordered;
+// - reuse is undetectable (sessions-model §1 rule 2): incarnation = sessions.created_at as stored,
+//   so the log file is fileNameFor(id, created_at). A same-second delete and recreate is not told
+//   apart, which is accepted;
+// - tool results are role-user rows carrying toolResponse parts. Each is folded into its call's tool
+//   part by id (toolRequest.id == toolResponse.id), whatever order parallel results completed in;
+//   the result row's own message_id is kept as the part's `content_id`. A result row whose every
+//   part was folded is not a message of its own; an unclaimed result is a role `tool` message.
+//   Images in a result are file parts after the tool part; exit_code from structuredContent;
+// - tool status: a declined call (confirmation deny, or goose's "declined" result) is `denied`; goose's
+//   "interrupted before completing" result, and a Ctrl-C `(no output)` error with no exit code, are
+//   `cancelled`;
+// - held back: an assistant row whose tool call has no result yet, until the result row lands or a
+//   later user prompt shows the turn ended (then it is written with the call `interrupted`). Every
+//   row after a held-back one waits too, so the log only grows while the session only grows. Goose
+//   persists nothing while a reply streams;
+// - visibility: metadata.userVisible=false is `hidden: true`; agentVisible=false (kept from the model
+//   only) is `model_visible: false`. Compaction flips agentVisible in place on every earlier row, so
+//   a compaction rewrites the earlier lines once; their keys stay;
+// - compaction: the summary row (role user, userVisible false, agentVisible true, a provider id or
+//   `# Conversation Summary`) is a `system` message with one summary part (replaces: {flags}),
+//   hidden, preceded by a compaction lifecycle record (through = the last message before it);
+// - source: turn-context rows and goose's own hidden notices (compaction continuation, sub-agent
+//   completion) are `injected`; goose-written hidden user turns (goal nudges, the auto-compaction
+//   replay of the prompt) and the prompts of `sub_agent` and `scheduled` sessions are `automated`.
+//   Steer rows are the user's own steering: kept, no source;
+// - usage (basis unknown): the ledger (one row per LLM call) is authoritative. A ledger row links to
+//   the assistant row of the same call: equal input/output/cache-read counts, written at the call's
+//   end (within elapsedMs of the row's time). A linked row is that message's usage and nothing else.
+//   Every other ledger row is a `k: 'usage'` record (usage_id = the ledger row's id), placed by its
+//   time among the messages: a compaction call (reason 'compaction'; the summary message carries no
+//   usage) and calls whose messages are gone (/clear and truncate delete rows, goose keeps the
+//   ledger);
+// - copied usage: a fork or an import copies rows with their metadata.usage but not the ledger. So in
+//   a store that keeps a ledger, an assistant row with metadata.usage and no linked ledger row, whose
+//   call ended at or after the store's first ledger row, is a copy: it gets no `usage`, and its metadata.usage goes to
+//   the message's `raw`, so the call is billed once, in the session that made it. A store with no
+//   ledger rows at all (older goose), and calls that ended before its first ledger row (an upgraded store),
+//   keep metadata.usage as the message's usage. Billing across a fork is M4's;
+// - model: served = the linked ledger row's `model`, else inference.resolvedModel, else the requested
+//   one; model_requested = inference.requestedModel. Effort is per session
+//   (model_config_json.request_params.thinking_effort), written on each LLM reply;
+// - status: an error part is `error`; a reply with inference but no usage (Ctrl-C mid-stream) and an
+//   outputTokenLimitReached row are `interrupted`;
+// - session: title = name, cwd = working_dir, kind = session_type, mode = goose_mode, archived =
+//   archived_at (RFC 3339) plus an archive lifecycle record placed by time. `updated` is null
+//   (updated_at, the token counters and accumulated_* are volatile and stay out). Child side:
+//   parent_session_id is an explicit subagent link. Origin side: `children` from a row's
+//   operations.foreground_subagent.delivered. A fork stores no link (inferred forks are the engine's);
+// - raw: the session record keeps the sessions row's stable columns (JSON parsed), redacted;
+// - redaction by field path (sessions-model §4), in the session raw. Tokens sit in extension env
+//   values and headers, in stdio args (`--token …`) and in SSE/HTTP URL queries, so for every
+//   extension (in extension_data and in recipe_json): each `envs` / `headers` value and each `args`
+//   element becomes `<redacted len=N>` (keys kept); `uri` / `url` is cut to scheme://host; a `cmd`
+//   with spaces in it (args folded in) is redacted whole; any extension field not known to be
+//   harmless is redacted. In recipes, sub-recipe `values` and parameter `default`s are redacted, and
+//   so is every value of user_recipe_values_json (keys kept). In tool results, an MCP resource URI
+//   other than a file: URI or a plain/Windows path is cut to scheme://host (or redacted with no host). Map keys are sorted and the extension
+//   list is sorted by name, so a re-save in another order does not rewrite the log. Free text
+//   (prompts, tool output) is out of reach (§4.6). Nothing outside sessions.db is opened
+//   (config.yaml, keyring and logs are never read), and only through openReadOnly, which creates
+//   nothing next to the DB;
+// - list(): sessions.db is shared by every session, so an entry names no absolute file (the runner
+//   would re-read every session on any write). It names the DB relative to harness_path and carries
+//   a change key read in the list query, per session through the session_id indexes: updated_at,
+//   the session's message count, max rowid (an insert, a delete, --edit's re-insert) and
+//   total(octet_length(metadata_json)) (the spec's fingerprint: an agentVisible flip in place changes
+//   it by one; octet_length reads the stored size, not each overflow chain), its ledger count and max id (a ledger row landing after its message re-links
+//   usage), a hash of the session's raw columns (rename, archive, mode, extensions, effort: whatever
+//   line 1 is made of) and the store's first ledger second (the copy rule; the lowest ledger rowid's,
+//   read by rowid, not a scan).
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { openReadOnly, textOf } = require('../sqlite');
+const harnessPaths = require('../harness-paths');
+const { placeChildren } = require('../sessions-log');
+
+const HARNESS = 'goose';
+
+// ── store ─────────────────────────────────────────────────────────────────────────────────────
+/**
+ * Goose's data folder: harness-paths' (GOOSE_PATH_ROOT/data, then XDG_DATA_HOME/goose, then
+ * ~/.local/share/goose; adapter spec §1), the one source the bridge uses too.
+ */
+function storeRootDefault(env = process.env) { return harnessPaths.defaultFolder(HARNESS, { env }); }
+function dbPathOf(storeRoot) { return path.join(storeRoot, 'sessions', 'sessions.db'); }
+/** harness_path: dataFolder('goose') for the default store (so the bridge switch dedupes), else the resolved folder. */
+function harnessPathOf(storeRoot) {
+  const def = harnessPaths.defaultFolder(HARNESS);
+  return def && path.resolve(storeRoot) === path.resolve(def) ? harnessPaths.dataFolder(HARNESS) : harnessPaths.resolveNative(storeRoot);
+}
+
+// The module contract (docs/design/sessions-log.md): null or a throw when the store cannot be read
+// consistently, never fewer records than the session holds. So no SQLite error is caught here: busy,
+// locked, malformed, IOERR, NOTADB, a locking-protocol failure all propagate (list() throwing keeps
+// the runner's index; normalise() throwing is retried). Only a missing table or column reads as
+// empty, and PRAGMA table_info returns no rows for those by itself.
+function columnsOf(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((r) => String(r.name)));
+}
+/** One read transaction (one snapshot) over the store: wait a moment on a lock, then fail. */
+function withRead(file, fn) {
+  const db = openReadOnly(file);
+  try {
+    db.exec('PRAGMA busy_timeout = 1000');
+    db.exec('BEGIN');
+    const out = fn(db);
+    db.exec('COMMIT');
+    return out;
+  } finally { db.close(); }
+}
+
+const DB_REL = path.join('sessions', 'sessions.db');
+
+/** The list query: every sessions row with its change key, each count a per-session index lookup. */
+function listSql(db) {
+  const mc = columnsOf(db, 'messages');
+  const lc = columnsOf(db, 'usage_ledger');
+  const per = (t, cols, a) => (cols.has('session_id')
+    ? `(SELECT count(*) FROM ${t} x WHERE x.session_id = s.id) AS mh_${a}_n, (SELECT max(x.id) FROM ${t} x WHERE x.session_id = s.id) AS mh_${a}_max`
+    : `0 AS mh_${a}_n, NULL AS mh_${a}_max`);
+  const meta = mc.has('session_id') && mc.has('metadata_json')
+    ? '(SELECT total(octet_length(x.metadata_json)) FROM messages x WHERE x.session_id = s.id) AS mh_msg_meta' : '0 AS mh_msg_meta';
+  return `SELECT s.*, ${per('messages', mc, 'msg')}, ${meta}, ${per('usage_ledger', lc, 'led')} FROM sessions s ORDER BY s.created_at, s.id`;
+}
+/**
+ * The store's first ledger second (the copy rule), or null when it keeps no ledger: the lowest
+ * rowid's (rows are inserted as calls end), read by rowid rather than by scanning the table.
+ */
+function ledgerSince(db) {
+  if (!columnsOf(db, 'usage_ledger').has('created_timestamp')) return null;
+  const first = db.prepare('SELECT created_timestamp AS since FROM usage_ledger ORDER BY id LIMIT 1').get();
+  return first && first.since != null ? Number(first.since) : null;
+}
+
+/**
+ * Sessions in one store: one per sessions row, with its incarnation (created_at as stored). The DB
+ * is shared, so the entry names it relative to harness_path (`db_rel`: not stat'ed by the runner) and
+ * carries `key`, this session's change key, read in the same query. Nothing volatile.
+ */
+function list(storeRoot = storeRootDefault()) {
+  const file = path.resolve(dbPathOf(storeRoot));
+  let st;
+  try { st = fs.statSync(file); } catch (e) {
+    if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return [];   // no store here
+    throw e;
+  }
+  if (!st.isFile()) return [];
+  const harnessPath = harnessPathOf(storeRoot);
+  return withRead(file, (db) => {
+    if (!columnsOf(db, 'sessions').has('id')) return [];
+    const since = ledgerSince(db);
+    return db.prepare(listSql(db)).all().map((r) => ({
+      harness: HARNESS, harness_path: harnessPath, session_id: str(r.id), incarnation: str(r.created_at), db_rel: DB_REL,
+      key: {
+        updated_at: str(r.updated_at), messages: Number(r.mh_msg_n) || 0, max_message: num(r.mh_msg_max), meta_len: Number(r.mh_msg_meta) || 0,
+        ledger: Number(r.mh_led_n) || 0, max_ledger: num(r.mh_led_max), ledger_since: since,
+        row: sha256(JSON.stringify(rawSession(r))).slice(0, 16),
+      },
+    }));
+  });
+}
+/** The DB a list() entry (or a test's `{ db }`) names. */
+const dbFileOf = (session) => session.db || path.join(session.harness_path, session.db_rel || DB_REL);
+
+/** One session's rows, read in one read transaction: its sessions row, messages and ledger. */
+function loadFromDb(session) {
+  return withRead(dbFileOf(session), (db) => {
+    const row = db.prepare('SELECT * FROM sessions WHERE id = ?').get(String(session.session_id)) || null;
+    let messages = [];
+    let ledger = [];
+    let since = null;
+    if (row) {
+      const mc = columnsOf(db, 'messages');
+      const pick = (cols, c) => (cols.has(c) ? c : `NULL AS ${c}`);
+      if (mc.has('content_json')) {
+        messages = db.prepare(`SELECT id, ${pick(mc, 'message_id')}, role, content_json, created_timestamp, ${pick(mc, 'metadata_json')}
+          FROM messages WHERE session_id = ? ORDER BY created_timestamp, id`).all(row.id);
+      }
+      const lc = columnsOf(db, 'usage_ledger');
+      if (lc.has('session_id')) {
+        const cols = ['model', 'input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens', 'cost', 'cost_source', 'is_compaction'].map((c) => pick(lc, c)).join(', ');
+        ledger = db.prepare(`SELECT id, created_timestamp, ${cols} FROM usage_ledger WHERE session_id = ? ORDER BY created_timestamp, id`).all(row.id);
+        // The store's first ledger row: from then on, every call this store makes has one.
+        since = ledgerSince(db);
+      }
+    }
+    return { row, messages, ledger, ledger_since: since };
+  });
+}
+
+// ── small helpers ─────────────────────────────────────────────────────────────────────────────
+function parseJson(v) {
+  if (v == null) return null;
+  if (typeof v === 'object' && !(v instanceof Uint8Array)) return v;
+  try { return JSON.parse(textOf(v)); } catch { return null; }
+}
+const str = (v) => (v == null ? '' : String(textOf(v)));
+const sha256 = (b) => crypto.createHash('sha256').update(b).digest('hex');
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const num = (v) => (v == null || v === '' || !Number.isFinite(Number(v)) ? null : Number(v));
+
+// Text timestamps without a zone are UTC (SQLite CURRENT_TIMESTAMP); archived_at is RFC 3339 with ns.
+const TS_RE = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?\s*(Z|[+-]\d{2}:?\d{2})?$/i;
+function utcMs(v) {
+  if (v == null || v === '') return null;
+  if (typeof v === 'number') return Number.isFinite(v) && v > 0 ? (v < 1e11 ? v * 1000 : v) : null;
+  const s = String(textOf(v)).trim();
+  const m = TS_RE.exec(s);
+  if (!m) { const t = Date.parse(s); return Number.isFinite(t) ? t : null; }
+  let t = Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6], m[7] ? Math.floor(Number(`0.${m[7]}`) * 1000) : 0);
+  if (m[8] && m[8].toUpperCase() !== 'Z') {
+    const sign = m[8][0] === '-' ? -1 : 1;
+    const digits = m[8].replace(/[^0-9]/g, '');
+    t -= sign * (Number(digits.slice(0, 2)) * 60 + Number(digits.slice(2, 4))) * 60000;
+  }
+  return t;
+}
+const secMs = (v) => { const x = Number(v); return Number.isFinite(x) && x > 0 ? x * 1000 : null; };
+
+// ── redaction (sessions-model §4: Goose extensions and recipe values) ─────────────────────────────
+function marker(v) {
+  const n = typeof v === 'string' ? Buffer.byteLength(v, 'utf8') : Buffer.byteLength(JSON.stringify(v) ?? '', 'utf8');
+  return `<redacted len=${n}>`;
+}
+const isMarker = (v) => typeof v === 'string' && /^<redacted len=\d+>$/.test(v);
+const hide = (v) => (v == null || isMarker(v) ? v : marker(v));
+const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);   // code-unit order: the same on every machine
+const sortedKeys = (o) => Object.keys(o).sort(cmp);
+/** Every value redacted, the keys kept (sorted). */
+function hideValues(x) {
+  if (Array.isArray(x)) return x.map(hide);
+  if (isObj(x)) return Object.fromEntries(sortedKeys(x).map((k) => [k, hide(x[k])]));
+  return hide(x);
+}
+/** A URL cut to scheme://host (the path and query can carry a token); anything else redacted. */
+function hideUrl(v) {
+  if (v == null || isMarker(v)) return v;
+  try {
+    const u = new URL(String(v));
+    if (u.host) return `${u.protocol}//${u.host}`;
+  } catch { /* not a URL */ }
+  return marker(v);
+}
+// Extension fields kept as stored: names, descriptions, numbers, flags and env var NAMES (env_keys).
+const EXT_SAFE = new Set(['type', 'name', 'display_name', 'description', 'timeout', 'bundled', 'cwd', 'env_keys', 'available_tools', 'enabled']);
+function redactExtension(e) {
+  if (!isObj(e)) return hide(e);
+  const o = {};
+  for (const k of Object.keys(e)) {
+    const x = e[k];
+    if (x == null) o[k] = x;
+    else if (k === 'envs' || k === 'headers') o[k] = hideValues(x);
+    else if (k === 'args') o[k] = Array.isArray(x) ? x.map(hide) : hide(x);
+    else if (k === 'uri' || k === 'url') o[k] = hideUrl(x);
+    else if (k === 'cmd') o[k] = typeof x === 'string' && !/\s/.test(x) ? x : hide(x);
+    else o[k] = EXT_SAFE.has(k) ? x : hide(x);
+  }
+  return o;
+}
+/**
+ * extension_data or recipe_json, redacted: extension lists (sorted by name), env/header maps anywhere,
+ * and in a recipe (`recipe`) sub-recipe `values` and parameter `default`s.
+ */
+function redactExtensions(v, recipe = false, depth = 0) {
+  if (depth > 32) return hide(v);
+  if (Array.isArray(v)) return v.map((x) => redactExtensions(x, recipe, depth + 1));
+  if (!isObj(v)) return v;
+  const o = {};
+  for (const k of Object.keys(v)) {
+    const x = v[k];
+    if (x == null) o[k] = x;
+    else if (k === 'extensions' && Array.isArray(x)) {
+      o[k] = x.map(redactExtension).sort((a, b) => cmp(`${str(a && a.name)}\u0000${str(a && a.type)}`, `${str(b && b.name)}\u0000${str(b && b.type)}`));
+    } else if (k === 'envs' || k === 'headers' || (recipe && k === 'values')) o[k] = hideValues(x);
+    else if (recipe && k === 'default') o[k] = hide(x);
+    else o[k] = redactExtensions(x, recipe, depth + 1);
+  }
+  return o;
+}
+
+// The sessions row's stable columns. Left out as volatile: updated_at, the last-call token columns and
+// accumulated_* (they move without the transcript changing: kept after deletes, copied on forks).
+const RAW_COLS = ['id', 'name', 'description', 'user_set_name', 'session_type', 'working_dir', 'created_at', 'archived_at',
+  'provider_name', 'model_config_json', 'goose_mode', 'project_id', 'parent_session_id', 'schedule_id', 'recipe_json',
+  'user_recipe_values_json', 'system_prompt_override', 'system_prompt_extras_json', 'container_id', 'extension_data'];
+const JSON_COLS = new Set(['model_config_json', 'recipe_json', 'user_recipe_values_json', 'system_prompt_extras_json', 'extension_data']);
+const REDACTED_COLS = new Set(['extension_data', 'recipe_json', 'user_recipe_values_json']);
+function rawSession(row) {
+  const o = {};
+  for (const c of RAW_COLS) {
+    if (!(c in row)) continue;
+    let v = row[c];
+    if (v instanceof Uint8Array) v = textOf(v);
+    if (JSON_COLS.has(c) && v != null) {
+      const p = parseJson(v);
+      // An unparseable column on a secret path cannot be walked: the whole value is withheld.
+      if (p == null) v = REDACTED_COLS.has(c) ? marker(str(v)) : str(v);
+      else if (c === 'user_recipe_values_json') v = isObj(p) ? hideValues(p) : hide(p);
+      else v = REDACTED_COLS.has(c) ? redactExtensions(p, c === 'recipe_json') : p;
+    }
+    o[c] = v;
+  }
+  return o;
+}
+
+/**
+ * A reference in a tool result (an MCP resource URI): a file: URI, a plain path and a Windows drive
+ * path stay as they are; any other URI is cut to scheme://host (its query can carry a token), or
+ * redacted when it has no host.
+ */
+function safeRef(v) {
+  const s0 = str(v);
+  if (!s0 || /^file:/i.test(s0) || /^[A-Za-z]:[\\/]/.test(s0) || !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(s0)) return s0;
+  return hideUrl(s0);
+}
+
+// ── parts ─────────────────────────────────────────────────────────────────────────────────────
+function filePart(partId, mime, data) {
+  const bytes = typeof data === 'string' && data ? Buffer.from(data, 'base64') : null;
+  return { part_id: partId, kind: 'file', media_type: str(mime), att_sha: bytes ? sha256(bytes) : null, att_len: bytes ? bytes.length : null, ref: '' };
+}
+
+/** A toolResponse's result: output text, error flag, exit code and the binary items as file parts. */
+function resultOf(resp, partId) {
+  const tr = resp && resp.toolResult;
+  const files = [];
+  if (!isObj(tr)) return { output: '', isError: false, exit: null, files };
+  if (tr.status === 'error') {
+    const e = tr.error ?? tr.value;
+    return { output: typeof e === 'string' ? e : (isObj(e) && typeof e.message === 'string' ? e.message : JSON.stringify(e ?? null)), isError: true, exit: null, files };
+  }
+  const v = tr.value;
+  const content = Array.isArray(v) ? v : (isObj(v) && Array.isArray(v.content) ? v.content : []);
+  const text = [];
+  content.forEach((c, k) => {
+    if (!isObj(c)) return;
+    if (c.type === 'text') text.push(str(c.text));
+    else if (c.type === 'image' || c.type === 'audio') files.push(filePart(`${partId}:${c.type}:${k}`, c.mimeType, c.data));
+    else if (c.type === 'resource_link') text.push(`[resource_link ${safeRef(c.uri)}]`);
+    else if (c.type === 'resource') {
+      const r = isObj(c.resource) ? c.resource : {};
+      if (typeof r.text === 'string') text.push(r.text);
+      else if (typeof r.blob === 'string') files.push({ ...filePart(`${partId}:resource:${k}`, r.mimeType, r.blob), ref: safeRef(r.uri) });
+      else text.push(`[resource ${safeRef(r.uri)}]`);
+    } else text.push(`[${str(c.type)}]`);
+  });
+  const sc = isObj(v) && isObj(v.structuredContent) ? v.structuredContent : null;
+  const exit = sc && Number.isFinite(sc.exit_code) ? sc.exit_code : null;
+  return { output: text.join('\n'), isError: !!(isObj(v) && v.isError === true), exit, files };
+}
+
+const DECLINED = /^The user has declined to run this tool/;
+const INTERRUPTED = /^Tool call was interrupted before completing/;
+function toolStatus(res, permission) {
+  if (!res) return 'interrupted';
+  if (INTERRUPTED.test(res.output)) return 'cancelled';
+  if (permission === 'cancel') return 'cancelled';
+  if (permission === 'deny_once' || permission === 'always_deny' || DECLINED.test(res.output)) return 'denied';
+  if (res.isError && res.output === '(no output)' && res.exit === null) return 'cancelled';   // Ctrl-C during a shell call
+  return 'completed';
+}
+
+function actionText(d) {
+  if (!isObj(d)) return '[actionRequired]';
+  const t = str(d.actionType);
+  switch (t) {
+    case 'toolConfirmation': return `[toolConfirmation] ${str(d.toolName)} ${JSON.stringify(d.arguments ?? {})}${d.prompt ? `\n${str(d.prompt)}` : ''}`;
+    case 'toolConfirmationResponse': return `[toolConfirmationResponse] ${str(d.permission)}`;
+    case 'elicitation': return `[elicitation] ${str(d.message)}${d.requested_schema ? `\n${JSON.stringify(d.requested_schema)}` : ''}`;
+    case 'elicitationResponse': return `[elicitationResponse] ${str(d.action)} ${JSON.stringify(d.user_data ?? null)}`;
+    default: return `[${t || 'actionRequired'}]`;
+  }
+}
+
+function ledgerUsage(l) {
+  return { basis: 'unknown', input: num(l.input_tokens), output: num(l.output_tokens), cache_read: num(l.cache_read_tokens), cache_write: num(l.cache_write_tokens), reasoning: null, cost: num(l.cost) };
+}
+function metaUsage(u) {
+  if (!isObj(u)) return null;
+  return { basis: 'unknown', input: num(u.inputTokens), output: num(u.outputTokens), cache_read: num(u.cacheReadTokens), cache_write: num(u.cacheWriteTokens), reasoning: null, cost: num(u.cost) };
+}
+
+// ── normalise ─────────────────────────────────────────────────────────────────────────────────
+/** A message row's JSON column. A value that does not parse is a damaged read and throws: read as
+ * null it would become an empty message (content_json) or a visible one (metadata_json), and the
+ * module contract allows never fewer records than the session holds. */
+function rowJson(v, col) {
+  if (v == null) return null;
+  if (typeof v === 'object' && !(v instanceof Uint8Array)) return v;
+  try { return JSON.parse(textOf(v)); } catch { throw new Error(`goose: damaged read: messages.${col} does not parse`); }
+}
+function prep(r) {
+  const content = rowJson(r.content_json, 'content_json');
+  const meta = rowJson(r.metadata_json, 'metadata_json');
+  const m = isObj(meta) ? meta : {};
+  return {
+    rowid: Number(r.id) || 0, mid: r.message_id == null || r.message_id === '' ? null : str(r.message_id),
+    role: str(r.role), cts: Number(r.created_timestamp) || 0, ts: secMs(r.created_timestamp),
+    parts: Array.isArray(content) ? content : [], meta: m, U: m.userVisible !== false, A: m.agentVisible !== false,
+  };
+}
+const only = (r, types) => r.parts.length > 0 && r.parts.every((p) => isObj(p) && types.includes(p.type));
+const firstText = (r) => { const p = r.parts.find((x) => isObj(x) && x.type === 'text'); return p ? str(p.text) : ''; };
+
+/**
+ * The compaction summary: role user, hidden from the user, a provider id (or the summary heading).
+ * Not keyed on agentVisible: a later compaction flips an earlier summary to false in place.
+ */
+function isSummary(r) {
+  if (r.role !== 'user' || r.U || r.meta.turnContext || r.meta.steer || !only(r, ['text'])) return false;
+  return (!!r.mid && !/^(msg_|steer_)/.test(r.mid)) || /^# Conversation Summary\b/.test(firstText(r));
+}
+/** A prompt the user typed (or goose sent as the user's turn): it ends whatever turn came before. */
+function isPrompt(r) {
+  return r.role === 'user' && r.U && !r.meta.steer && !r.meta.turnContext && only(r, ['text', 'image']);
+}
+function deliveredOf(meta) {
+  const ops = isObj(meta.operations) ? meta.operations : {};
+  const fs0 = isObj(ops.foreground_subagent) ? ops.foreground_subagent.delivered : null;
+  return (Array.isArray(fs0) ? fs0 : (fs0 == null ? [] : [fs0])).map(str).filter(Boolean);
+}
+
+/**
+ * Normalise one session. `session` is a list() entry, or `{ session_id, row, messages, ledger,
+ * ledger_since? }` already loaded (tests): `row` is the sessions row, `messages` the messages rows,
+ * `ledger` the session's usage_ledger rows and `ledger_since` the store's first ledger second (null:
+ * the store keeps no ledger; default: the session's own first ledger row). JSON columns may be text
+ * or parsed. Returns the log records, the session record first; null when the store holds no
+ * sessions row for the id.
+ */
+function normalise(session) {
+  const loaded = (session.row !== undefined || Array.isArray(session.messages))
+    ? {
+      row: session.row || null, messages: session.messages || [], ledger: session.ledger || [],
+      ledger_since: session.ledger_since !== undefined ? session.ledger_since
+        : ((session.ledger || []).reduce((a, l) => (a == null || Number(l.created_timestamp) < a ? Number(l.created_timestamp) : a), null)),
+    }
+    : loadFromDb(session);
+  const row = loaded.row;
+  if (!row) return null;
+  const kind = str(row.session_type);
+  const mc = parseJson(row.model_config_json);
+  const rp = isObj(mc) && isObj(mc.request_params) ? mc.request_params : {};
+  const effort = rp.thinking_effort == null ? '' : str(rp.thinking_effort);
+
+  const rows = loaded.messages.map(prep).sort((a, b) => (a.cts - b.cts) || (a.rowid - b.rowid));
+  const key = (i, j) => `${i}:${j}`;
+
+  // Results and confirmations by call id; each call claims the first unclaimed result after it.
+  const responses = new Map();
+  const permission = new Map();
+  rows.forEach((r, i) => r.parts.forEach((p, j) => {
+    if (!isObj(p)) return;
+    if (p.type === 'toolResponse' && p.id != null) {
+      const id = str(p.id);
+      if (!responses.has(id)) responses.set(id, []);
+      responses.get(id).push({ i, j, part: p });
+    } else if (p.type === 'actionRequired' && isObj(p.data) && p.data.actionType === 'toolConfirmationResponse' && p.data.id != null) {
+      permission.set(str(p.data.id), str(p.data.permission));
+    }
+  }));
+  const claim = new Map();
+  const claimed = new Set();
+  rows.forEach((r, i) => r.parts.forEach((p, j) => {
+    if (!isObj(p) || p.type !== 'toolRequest' || p.id == null) return;
+    const cands = responses.get(str(p.id)) || [];
+    const hit = cands.find((c) => c.i > i && !claimed.has(key(c.i, c.j))) || cands.find((c) => !claimed.has(key(c.i, c.j)));
+    if (hit) { claimed.add(key(hit.i, hit.j)); claim.set(key(i, j), hit); }
+  }));
+
+  // Whether a user prompt follows each row: the turn it belongs to has ended.
+  const promptAfter = new Array(rows.length).fill(false);
+  for (let i = rows.length - 1, seen = false; i >= 0; i--) { promptAfter[i] = seen; if (isPrompt(rows[i])) seen = true; }
+
+  // Ledger rows → the message of the same call.
+  const ledger = loaded.ledger.map((l) => ({ ...l, lid: Number(l.id) || 0, lts: Number(l.created_timestamp) || 0 }))
+    .sort((a, b) => (a.lts - b.lts) || (a.lid - b.lid));
+  const used = new Set();
+  const linked = new Map();
+  const same = (a, b) => (a == null && b == null) || (a != null && b != null && Number(a) === Number(b));
+  const fits = (a, b) => a == null || b == null || Number(a) === Number(b);
+  // How long after a row's time its call's ledger row can be written (the row is the first token).
+  const spanOf = (u) => { const el = Number(u.elapsedMs); return Number.isFinite(el) && el >= 0 ? Math.ceil(el / 1000) + 2 : 900; };
+  rows.forEach((r, i) => {
+    const u = r.meta.usage;
+    if (r.role !== 'assistant' || !isObj(u)) return;
+    const span = spanOf(u);
+    const hit = ledger.find((l) => !used.has(l.lid) && !Number(l.is_compaction) && same(l.input_tokens, u.inputTokens) && same(l.output_tokens, u.outputTokens)
+      && fits(l.cache_read_tokens, u.cacheReadTokens) && l.lts >= r.cts - 1 && l.lts <= r.cts + span);
+    if (hit) { used.add(hit.lid); linked.set(i, hit); }
+  });
+  const since = loaded.ledger_since == null || !Number.isFinite(Number(loaded.ledger_since)) ? null : Number(loaded.ledger_since);
+  // A call whose ledger row would fall before the store's first one predates the ledger (older goose).
+  const copied = (r, i) => since !== null && r.role === 'assistant' && isObj(r.meta.usage) && !linked.has(i) && r.cts + spanOf(r.meta.usage) >= since;
+
+  const out = [];
+  const children = [];
+  const seenIds = new Map();
+  let anchor = '';
+  let anchorN = 0;
+  let lastId = '';
+  let heldTs = null;   // the time of the first held-back row: nothing at or after it is written yet
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const reqs = r.parts.map((p, j) => (isObj(p) && p.type === 'toolRequest' ? j : -1)).filter((j) => j >= 0);
+    const pending = reqs.some((j) => !claim.has(key(i, j)));
+    if (pending && !promptAfter[i]) { heldTs = r.ts ?? 0; break; }   // a tool still running: wait
+
+    // The id: native; anchored on the previous native id where NULL or repeated.
+    let id;
+    if (r.mid) {
+      const n = seenIds.get(r.mid) || 0;
+      seenIds.set(r.mid, n + 1);
+      id = n ? `${r.mid}+${n}` : r.mid;
+      anchor = r.mid; anchorN = 0;
+    } else id = `${anchor || '@start'}+${++anchorN}`;
+
+    // A result row whose every part was folded into its call is not a message of its own.
+    if (r.parts.length && r.parts.every((p, j) => isObj(p) && p.type === 'toolResponse' && claimed.has(key(i, j)))) continue;
+
+    const summary = isSummary(r);
+    const parts = [];
+    let hasError = false;
+    r.parts.forEach((p, j) => {
+      if (!isObj(p)) return;
+      const pid = String(j);
+      switch (p.type) {
+        case 'text':
+          if (summary) parts.push({ part_id: pid, kind: 'summary', text: str(p.text), replaces: { flags: { agentVisible: false } } });
+          else parts.push({ part_id: pid, kind: 'text', text: str(p.text) });
+          break;
+        case 'image': parts.push(filePart(pid, p.mimeType, p.data)); break;
+        case 'thinking': {
+          const t = str(p.thinking);
+          if (t) parts.push({ part_id: pid, kind: 'reasoning', text: t });
+          else if (p.signature) parts.push({ part_id: pid, kind: 'reasoning', text: '', opaque: true });
+          break;
+        }
+        case 'redactedThinking': parts.push({ part_id: pid, kind: 'reasoning', text: '', opaque: true }); break;
+        case 'toolRequest': {
+          const tc = isObj(p.toolCall) ? p.toolCall : {};
+          const v = isObj(tc.value) ? tc.value : {};
+          const meta = isObj(p._meta) ? p._meta : {};
+          const hit = claim.get(key(i, j));
+          const res = hit ? resultOf(hit.part, pid) : null;
+          const callId = str(p.id);
+          const bad = tc.status === 'error';
+          parts.push({
+            part_id: pid, kind: 'tool', call_id: callId, tool: str(v.name) || 'unknown',
+            args: isObj(v.arguments) || Array.isArray(v.arguments) ? v.arguments : (v.arguments == null ? {} : { raw: v.arguments }),
+            output: res ? res.output : (bad ? str(isObj(tc.error) ? tc.error.message : tc.error) : null),
+            is_error: res ? res.isError : bad,
+            ...(res && res.exit !== null ? { exit_code: res.exit } : {}),
+            status: toolStatus(res, permission.get(callId)),
+            ...(meta.goose_extension ? { server: str(meta.goose_extension) } : {}),
+            ...(hit && rows[hit.i].mid ? { content_id: rows[hit.i].mid } : {}),
+            ts: hit ? rows[hit.i].ts : r.ts,
+          });
+          if (res) for (const f of res.files) parts.push({ ...f, ts: rows[hit.i].ts });
+          break;
+        }
+        case 'toolResponse': {
+          if (claimed.has(key(i, j))) break;
+          const res = resultOf(p, pid);   // a result no call in this session claims
+          parts.push({ part_id: pid, kind: 'text', text: res.output });
+          parts.push(...res.files);
+          break;
+        }
+        case 'actionRequired': parts.push({ part_id: pid, kind: 'notice', text: actionText(p.data) }); break;
+        case 'error': hasError = true; parts.push({ part_id: pid, kind: 'error', text: str(p.message) }); break;
+        case 'systemNotification': parts.push({ part_id: pid, kind: 'notice', text: str(p.msg) }); break;
+        default: parts.push({ part_id: pid, kind: 'notice', text: `[${str(p.type)}]${typeof p.text === 'string' ? ` ${p.text}` : ''}` });
+      }
+    });
+
+    let role = r.role === 'assistant' ? 'assistant' : 'user';
+    if (summary) role = 'system';
+    else if (r.role === 'user' && only(r, ['toolResponse'])) role = 'tool';
+
+    let source;
+    if (r.meta.turnContext) source = 'injected';
+    else if (!summary && !r.U && r.role === 'assistant' && !r.meta.inference && only(r, ['text'])) source = 'injected';   // compaction continuation
+    else if (!summary && !r.U && r.role === 'user' && deliveredOf(r.meta).length) source = 'injected';   // sub-agent completion
+    else if (!summary && !r.U && r.role === 'user' && only(r, ['text'])) source = 'automated';   // goal nudge, compaction replay
+    else if (r.U && isPrompt(r) && (kind === 'sub_agent' || kind === 'scheduled')) source = 'automated';
+
+    const inf = isObj(r.meta.inference) ? r.meta.inference : null;
+    const l = linked.get(i) || null;
+    let status = 'complete';
+    if (hasError) status = 'error';
+    else if (pending) status = 'interrupted';
+    else if (r.role === 'assistant' && (r.meta.outputTokenLimitReached || (inf && !isObj(r.meta.usage) && !l))) status = 'interrupted';
+
+    const m = { k: 'message', message_id: id, role, ts: r.ts, order: i, state: 'current', status };
+    if (!r.U) m.hidden = true;
+    if (!r.A) m.model_visible = false;
+    if (source) m.source = source;
+    const copy = copied(r, i);
+    if (role === 'assistant') {
+      m.model = (l && str(l.model)) || (inf && (str(inf.resolvedModel) || str(inf.requestedModel))) || '';
+      if (inf && inf.requestedModel) m.model_requested = str(inf.requestedModel);
+      m.effort = inf ? effort : '';
+      m.usage = l ? ledgerUsage(l) : (copy ? null : metaUsage(r.meta.usage));
+    }
+    m.parts = parts;
+    if (copy) m.raw = { metadata: { usage: r.meta.usage } };   // a copied call: billed where it was made
+
+    if (summary) out.push({ k: 'lifecycle', event: 'compaction', at: r.ts, ...(lastId ? { through: lastId } : {}) });
+    out.push(m);
+    lastId = id;
+    for (const c of deliveredOf(r.meta)) if (!children.some((x) => x.session_id === c)) children.push({ kind: 'subagent', session_id: c, evidence: 'explicit', after: id });
+  }
+
+  // Records with a time of their own go in by that time, after every record at or before it; one that
+  // would land at or after a held-back row waits with it.
+  const timeOf = (x) => Number(x.k === 'message' || x.k === 'usage' ? x.ts : x.at) || 0;
+  const place = (rec, t) => {
+    const idx = out.findIndex((x) => timeOf(x) > t);
+    if (idx >= 0) out.splice(idx, 0, rec);
+    else if (heldTs === null || t < heldTs) out.push(rec);
+  };
+  // Ledger rows no message carries: compaction calls, and calls whose messages are gone.
+  for (const l of ledger) {
+    if (used.has(l.lid)) continue;
+    const t = l.lts * 1000;
+    place({
+      k: 'usage', usage_id: str(l.id), ts: t, ...(l.model ? { model: str(l.model) } : {}),
+      ...(Number(l.is_compaction) ? { reason: 'compaction' } : {}), usage: ledgerUsage(l),
+    }, t);
+  }
+  // Archive: the session record says when; a lifecycle record sits at that time among the messages.
+  const archivedRaw = row.archived_at == null || row.archived_at === '' ? null : row.archived_at;
+  const archived = archivedRaw == null ? null : (utcMs(archivedRaw) ?? true);
+  if (typeof archived === 'number') place({ k: 'lifecycle', event: 'archive', at: archived }, archived);
+
+  const parent = str(row.parent_session_id);
+  const head = {
+    k: 'session',
+    title: str(row.name), cwd: str(row.working_dir),
+    created: utcMs(row.created_at), updated: null, archived,
+    version: '', incarnation: str(row.created_at),
+    kind, mode: str(row.goose_mode),
+    links: parent ? [{ kind: 'subagent', origin: parent, evidence: 'explicit', at: '' }] : [],
+    ...(children.length ? { children } : {}),
+    raw: rawSession(row),
+  };
+  return placeChildren([head, ...out]);
+}
+
+module.exports = { HARNESS, list, listSql, normalise, storeRootDefault, dbPathOf, harnessPathOf, redactExtensions, utcMs };