memhouse 0.18.12 → 0.20.1

package/memhouse/house/convert-profile.js

@@ -0,0 +1,638 @@
+// memhouse 0.18 → harness-sessions-sql's profile (step B3, the conversion; harness-sessions-sql §4.8). Server-side INSERT … SELECT, like convert-v3.js, whose readers of the
+// legacy rooms it reuses (current parse, one row per key, the session and harness split, the
+// data-folder path). Every converted row has adapter 'legacy', adapter_ver 0, rev 0.
+//
+// THE MAPPING (each line is a decision)
+//   copies             a converted session is (harness, session id, host group): one host group for a
+//                      globally unique id (GLOBAL_ID_HARNESSES with a UUID or ses_ id) or for one 0.18
+//                      stream that reads as one machine renamed (oneMachineSQL), else one per host, hosts a reported
+//                      pair names as one machine together. Its 0.18 copies (a prefixed and a bare id,
+//                      two users) become one session: the current copy (the member's, then the latest
+//                      message, the most rows, the newest shipping) converts live; another copy's rows
+//                      the current one holds again (role, text, usage and model, each matched once) are
+//                      duplicates and not converted; the rest left the source and convert as removed
+//                      versions under ids qualified by their copy (~<hash>), so no key collides and
+//                      nothing is counted twice. A call takes its message's decision; one with no
+//                      message row converts with its copy (live in the current one)
+//   store              one per converted session: its newest row's host, its newest non-empty path
+//   host               host/v0 where the machine reported its pair (meta `host_pair:<host/v0>` =
+//                      old id) and no other machine reported the same old id; the old id otherwise
+//   session_parts      one row per 0.18 message: part_id '0' (a usage-only '[assistant activity]'
+//                      row: part_id '', kind 'none'); kind from the 0.18 markers in the spec's
+//                      values (reasoning, tool_call, tool_result, text); role 'tool' for a result
+//     text             text and reasoning rows: the stored text, as is
+//     tool_call        tool_name from the first marker; the stored text kept in extra.legacy_text
+//     tool_result      output: the stored text; output_len its length
+//     order_key        the 0.18 seq, zero-padded so the strings sort
+//     served_model     the 0.18 model; status 'complete', state 'current'
+//     response_id      a run id for Claude Code per_record usage (below), else ''
+//     content_sha      the TSV-line sha (harness-sessions-sql §4.8) over the spec columns in DDL order, without
+//                      content_sha, message_content_sha, cmp_sha, rev, is_deleted, removed,
+//                      ingested_at, writer and memhouse's own columns
+//     message_content_sha = content_sha; cmp_sha = the TSV-line sha over role, kind, text, tool_name,
+//                      args, is_error, output (DDL order)
+//     first_seen       the 0.18 row's ingested_at (memhouse's column)
+//     extra            memhouse's column: legacy_text (tool_call), agent (a sub-agent's 0.18 id,
+//                      type and description, for the agents rollup)
+//   session_usage      one row per 0.18 message with a non-zero counter, as 0.18 stored it:
+//                      input/output/cache_read/cache_write; reasoning, tool_prompt and cost null;
+//                      flags claude-code false/true, codex false/true, gemini-cli true/false, other
+//                      harnesses null; granularity per_record (claude-code), per_turn (codex),
+//                      per_message (others)
+//     anchor           Claude Code: anchor 'response' with a minted run id
+//                      'legacy-run:<origin>:<epoch>:<first seq>': consecutive rows (by seq) of one
+//                      session, parse and agent with an identical (input, cache_read, cache_write,
+//                      model) tuple (sessions-model v1's per_record). Other harnesses: anchor 'message'
+//     usage_id         sessions-model's form, <anchor> '#' n: 'response:<run id>#<n>', n counting
+//                      from 1 in seq order within the run, so the run's last record has the
+//                      greatest n (the record a reader counts output from, #43); 'message:<id>#1'
+//   calls              one row per 0.18 tool call (memhouse's convenience table): agent and model
+//                      from its message; is_error, result_ts and output_len null (0.18 kept none);
+//                      content_sha the session_parts row of its message (the part that holds it),
+//                      or for a call whose message has no row, a sha of its own key and content
+//   sessions           one row per session key of the converted parts (run last: after the parts,
+//                      usage and calls of its bucket, which its rollup reads), and one per 0.18 session
+//                      with no message row at all (only its sessions room row: a title, a path), grouped
+//                      by host as a session's messages are (no stream to read a renamed machine from):
+//                      fingerprint [], no totals, started and ended from its 0.18 times:
+//     fingerprint      the ordered cmp_shas of the session's legacy rows (by order_key, message_id)
+//     from 0.18        title (name), cwd (folder), created_at, updated_at, mode; memhouse's folder,
+//                      project, git_branch, origin: the session's own row (its host group's; for a
+//                      global id or one machine renamed, a row of a host whose messages it holds),
+//                      the member's newest where several users shipped one. With no row of its own:
+//                      no title or times, folder and project from its first message
+//     fixed            title_set_by 'unknown', state 'active', reuse 'undetectable' (0.18 kept no
+//                      birth marker; incarnation ''), ts_source 'legacy' (the time 0.18 stored: a
+//                      record's own for Claude Code, an interpolation for Codex), aliases [],
+//                      setup null, pinned null
+//     content_sha      the TSV-line sha over the spec columns in DDL order, as session_parts'
+//     totals           memhouse's derived columns (counts, usage, rollups, started/ended): the
+//                      shared rollup (profile-rollup.js) over the converted parts, usage and calls
+
+const conv = require('./convert-v3');
+const { profileNames } = require('./schema-profile');
+const rollup = require('./profile-rollup');
+const { v3Names } = require('./schema-v3');
+
+const { lit, harnessSQL, sessionSQL, kindSQL, currentParseSQL, bucketSQL } = conv;
+
+/** Settings that pin the TSV bytes behind content_sha (harness-sessions-sql §4.8). */
+const SHA_SETTINGS = { format_tsv_null_representation: '\\N', bool_true_representation: 'true', bool_false_representation: 'false', session_timezone: 'UTC' };
+
+const FLAGS = { 'claude-code': ['false', 'true'], codex: ['false', 'true'], 'gemini-cli': ['true', 'false'] };
+const GRANULARITY = { 'claude-code': 'per_record', codex: 'per_turn' };
+const flagSQL = (h, i) => `multiIf(${Object.entries(FLAGS).map(([k, v]) => `${h} = ${lit(k)}, CAST(${v[i]} AS Nullable(Bool))`).join(', ')}, CAST(NULL AS Nullable(Bool)))`;
+const granularitySQL = (h) => `multiIf(${Object.entries(GRANULARITY).map(([k, v]) => `${h} = ${lit(k)}, ${lit(v)}`).join(', ')}, 'per_message')`;
+const shaOf = (cols) => `lower(hex(SHA256(trimRight(formatRow('TabSeparated', ${cols.join(', ')}), '\\n'))))`;
+
+/** The session_parts spec columns in DDL order; the line behind content_sha leaves the marked ones out. */
+const PART_COLUMNS = ['host', 'harness', 'harness_path', 'session_id', 'incarnation', 'message_id', 'part_id', 'part_index', 'parent_id', 'order_key',
+  'agent_id', 'role', 'source', 'to_user', 'to_model', 'status', 'state', 'on_active_branch', 'ts', 'requested_model', 'served_model', 'effort',
+  'response_id', 'message_aliases', 'cmp_sha', 'message_content_sha', 'kind', 'text', 'call_id', 'tool_name', 'args', 'server', 'is_error',
+  'result_status', 'output', 'output_ref', 'output_ref_sha256', 'output_ref_bytes', 'output_len', 'truncated', 'exit_code', 'media_type',
+  'inline_b64', 'ref', 'bytes_len', 'opaque', 'signature_len', 'replaces_form', 'replaces_value', 'error_kind', 'error_message', 'http_status',
+  'level', 'native_type', 'part_source', 'part_state', 'content_sha', 'adapter', 'adapter_ver', 'model_version'];
+const NOT_IN_LINE = new Set(['content_sha', 'message_content_sha', 'cmp_sha', 'rev', 'is_deleted', 'removed', 'ingested_at', 'writer']);
+const PART_LINE = PART_COLUMNS.filter((c) => !NOT_IN_LINE.has(c));
+const CMP_LINE = ['role', 'kind', 'text', 'tool_name', 'args', 'is_error', 'output'];
+const USAGE_COLUMNS = ['host', 'harness', 'harness_path', 'session_id', 'incarnation', 'usage_id', 'anchor_kind', 'anchor_id', 'input', 'output', 'cache_read',
+  'cache_write', 'reasoning', 'tool_prompt', 'cost', 'input_includes_cache', 'output_includes_reasoning', 'granularity', 'model', 'content_sha', 'adapter',
+  'adapter_ver', 'model_version'];
+const USAGE_LINE = USAGE_COLUMNS.filter((c) => !NOT_IN_LINE.has(c));
+const SESSION_COLUMNS = ['host', 'host_label', 'harness', 'harness_path', 'session_id', 'incarnation', 'engine', 'client', 'harness_version', 'title',
+  'title_set_by', 'cwd', 'last_cwd', 'created_at', 'updated_at', 'state', 'pinned', 'mode', 'kind', 'reuse', 'ts_source', 'aliases', 'fingerprint',
+  'setup', 'content_sha', 'adapter', 'adapter_ver', 'model_version'];
+const SESSION_LINE = SESSION_COLUMNS.filter((c) => !NOT_IN_LINE.has(c));
+const CALL_COLUMNS = ['host', 'harness', 'harness_path', 'session_id', 'incarnation', 'call_id', 'message_id', 'agent_id', 'ts', 'first_seen',
+  'tool_name', 'args', 'result_ts', 'is_error', 'output_len', 'model', 'folder', 'project', 'content_sha', 'adapter', 'adapter_ver'];
+
+/** The old-id → host/v0 pairs machines reported, unambiguous ones only (a clone's conflict maps nothing).
+ * Joined LEFT without join_use_nulls, a row with no pair reads v0 = '', so the callers test for ''. */
+function hostPairsSQL(P) {
+  return `SELECT value AS old_host, any(substring(key, ${'host_pair:'.length + 1})) AS v0
+    FROM ${P.meta} FINAL WHERE startsWith(key, 'host_pair:') GROUP BY value HAVING uniqExact(substring(key, ${'host_pair:'.length + 1})) = 1`;
+}
+
+/**
+ * A 0.18 row's host group, the one rule every reader of the 0.18 rooms shares (the copies, the
+ * message-less sessions, the 0.18 metadata): '' for a globally unique id or one machine renamed,
+ * else the row's host (its host/v0 where a pair says so). `pairV0` is the joined hostPairsSQL v0.
+ */
+function groupSQL(N, P, n, b, h, s, host, pairV0) {
+  return `if(${globalIdSQL(h, s)} OR (${h}, ${s}) IN (${oneMachineSQL(N, P, n, b)}), '', ${hostGroupSQL(h, s, host, pairV0)})`;
+}
+
+/**
+ * The same group without the one-machine reading, which comes from message streams alone: what a
+ * 0.18 sessions row with no message rows of its own is grouped by — '' for a globally unique id,
+ * else its host (host/v0 where paired). A sessions row on a machine that shipped no message of the
+ * session is that machine's session, not merged into another's.
+ */
+function hostGroupSQL(h, s, host, pairV0) {
+  return `if(${globalIdSQL(h, s)}, '', if(ifNull(${pairV0}, '') != '', ${pairV0}, ${host}))`;
+}
+
+// Harnesses whose 0.18 session ids are globally unique (a UUID, OpenCode's ses_ ids), when the id
+// itself has that form: the same id under two host ids is one session, read by one machine under the
+// ids memhouse gave it over time. Every other harness (goose, zed, kiro, devin, antigravity,
+// copilot-jetbrains, codebuff, commandcode, gsd and any not named here) may use short, sequential or
+// per-machine ids, so its rows under two hosts are one session only when they read as one machine
+// renamed (oneMachineSQL) or the hosts are known aliases (a reported host pair); otherwise one per host.
+const GLOBAL_ID_HARNESSES = ['claude-code', 'claude', 'codex', 'gemini-cli', 'cursor', 'cursor-agent', 'vscode', 'copilot-cli', 'opencode'];
+const globalIdSQL = (h, s) => `(${h} IN (${GLOBAL_ID_HARNESSES.map(lit).join(', ')})
+  AND (match(${s}, '[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}') OR match(${s}, '^ses_[0-9A-Za-z]{16,}$')))`;
+
+/**
+ * The sessions of a bucket whose rows under several hosts read as one machine renamed: one 0.18
+ * stream (one 0.18 id, one user, one origin, one epoch) in which the hosts hold separate runs of seqs,
+ * each run shipped after the one before it, as a machine that kept shipping under a new id does, and
+ * whose hosts no reported pairs name as two machines. Two machines that shared a short id both started
+ * at the first seq, and 0.18 keyed a row without its host, so the later one wrote over the earlier
+ * one's first rows: their runs interleave, or the run with the lower seqs was shipped later. Rows in
+ * two streams (an import beside a shipped copy, two users) carry no such order between them, and two
+ * 0.18 ids are copies: kept apart per host for such a harness.
+ */
+function oneMachineSQL(N, P, n, b) {
+  const L = N.legacy;
+  const ranges = `SELECT ${harnessSQL('x')} AS kh, ${sessionSQL('x')} AS ks, x.session_id AS kl, x.user_id AS ku, toString(x.origin) AS ko, x.epoch AS ke,
+      toString(x.host) AS kx, min(x.seq) AS ka, max(x.seq) AS kz, min(x.ingested_at) AS ki, max(x.ingested_at) AS kj
+    FROM ${L.messages} AS x FINAL
+    WHERE ${currentParseSQL('x', L.messages)} AND ${bucketSQL(harnessSQL('x'), sessionSQL('x'), n, b)}
+    GROUP BY kh, ks, kl, ku, ko, ke, kx`;
+  const paired = `SELECT r.*, ifNull(kp.v0, '') AS kv FROM (${ranges}) AS r LEFT JOIN (${hostPairsSQL(P)}) AS kp ON kp.old_host = r.kx`;
+  const streams = `SELECT kh, ks, arraySort((r) -> r.1, groupArray((ka, kz, ki, kj))) AS rs,
+      arrayExists((r, i) -> i > 1 AND (r.1 <= rs[i - 1].2 OR r.3 < rs[i - 1].4), rs, arrayEnumerate(rs)) AS crossed,
+      uniqExactIf(kv, kv != '') AS machines
+    FROM (${paired}) GROUP BY kh, ks, kl, ku, ko, ke`;
+  return `SELECT kh, ks FROM (${streams}) GROUP BY kh, ks HAVING count() = 1 AND max(crossed) = 0 AND max(machines) <= 1`;
+}
+
+/**
+ * Every 0.18 row of a bucket with its converted session and the copy decision (header: copies):
+ *   g          the session's host group: '' for a globally unique id or one machine renamed
+ *              (oneMachineSQL), else the host (its host/v0 where a pair says so); a converted
+ *              session is (h, s, g)
+ *   m_copy     the 0.18 stream the row came from: its 0.18 id and user
+ *   cur_copy   the converted session's current copy: the member's own first, then the latest
+ *              message, the most rows, the newest shipping
+ *   m_keep     a row of the current copy, or a row of another copy the current one does not hold
+ *              (the same role and text, each row of the current copy matched once)
+ *   m_removed  a kept row of another copy: content that left the source, a removed version
+ *   m_mid      its message id, qualified (~<copy>) for another copy's rows, so no key collides
+ *   z_old_host, z_path  the session's store: its newest row's host, its newest non-empty path
+ */
+function copiesSQL(N, P, n, b) {
+  const L = N.legacy;
+  const t = `if(startsWith(m.text, '[subagent] '), substring(m.text, 12), m.text)`;
+  const rows = `SELECT ${harnessSQL('m')} AS h, ${sessionSQL('m')} AS s, m.session_id AS l_session, toString(m.host) AS old_host,
+      ${groupSQL(N, P, n, b, 'h', 's', 'old_host', 'hp0.v0')} AS g,
+      concat(m.session_id, char(0), m.user_id) AS m_copy,
+      toString(m.origin) AS m_origin, m.epoch AS m_epoch, m.seq AS m_seq, m.ts AS m_ts, toString(m.role) AS m_role, toString(m.model) AS m_model,
+      m.input_tokens AS m_in, m.output_tokens AS m_out, m.cache_read_tokens AS m_cr, m.cache_write_tokens AS m_cw,
+      m.text AS m_text, ${t} AS m_text_bare, m.folder AS m_folder, m.project AS m_project, m.user_id AS m_user, m.ingested_at AS m_ingested,
+      JSONExtractString(toJSONString(m.extra), 'agent', 'id') AS m_agent, JSONExtractRaw(toJSONString(m.extra), 'agent') AS m_agent_json,
+      ifNull(r.l_path, '') AS m_path,
+      cityHash64(toString(m.role), m.text, m.input_tokens, m.output_tokens, m.cache_read_tokens, m.cache_write_tokens, toString(m.model)) AS m_th
+    FROM ${L.messages} AS m FINAL
+    LEFT JOIN (${legacyPathsSQL(N)}) AS r ON r.l_session = m.session_id
+    LEFT JOIN (${hostPairsSQL(P)}) AS hp0 ON hp0.old_host = toString(m.host)
+    -- Every user's copy enters: the member's is chosen current below (cur_copy), and another user's
+    -- rows of the same session become removed versions or duplicates, never silently dropped.
+    WHERE ${currentParseSQL('m', L.messages)} AND ${bucketSQL(harnessSQL('m'), sessionSQL('m'), n, b)}`;
+  const stats = `SELECT *,
+      max(ifNull(m_ts, toDateTime64(0, 3, 'UTC'))) OVER (PARTITION BY h, s, g, m_copy) AS c_ts, count() OVER (PARTITION BY h, s, g, m_copy) AS c_n,
+      max(m_ingested) OVER (PARTITION BY h, s, g, m_copy) AS c_ing,
+      argMax(old_host, (m_ingested, m_seq)) OVER (PARTITION BY h, s, g) AS z_old_host,
+      argMax(m_path, (m_path != '', m_ingested, m_seq)) OVER (PARTITION BY h, s, g) AS z_path
+    FROM (${rows})`;
+  const current = `SELECT *, argMax(m_copy, (m_user = ${lit(N.member)}, c_ts, c_n, c_ing, m_copy)) OVER (PARTITION BY h, s, g) AS cur_copy FROM (${stats})`;
+  const dup = `SELECT *, m_copy = cur_copy AS m_cur,
+      row_number() OVER (PARTITION BY h, s, g, m_copy, m_role, m_th ORDER BY m_origin, m_epoch, m_seq) AS m_k,
+      countIf(m_copy = cur_copy) OVER (PARTITION BY h, s, g, m_role, m_th) AS m_c
+    FROM (${current})`;
+  return `SELECT *, m_cur OR m_k > m_c AS m_keep, toUInt8(NOT m_cur) AS m_removed,
+      if(m_cur, '', concat('~', lower(hex(cityHash64(m_copy))))) AS m_tag,
+      concat('legacy:', m_origin, ':', toString(m_epoch), ':', toString(m_seq), m_tag) AS m_mid
+    FROM (${dup})`;
+}
+
+/**
+ * The converted rows of one bucket, every column cast to its DDL type: the inner query of the
+ * session_parts and session_usage inserts. Only the rows the copy decision keeps.
+ */
+function convertedMessagesSQL(N, P, n, b) {
+  return `SELECT *,
+      ${kindSQL('m_role', 'm_text', 'h')} AS k0,
+      multiIf(k0 = 'thinking', 'reasoning', k0 = 'usage', 'none', k0) AS kind,
+      if(k0 = 'tool_result', 'tool', m_role) AS role,
+      lagInFrame(tuple(m_in, m_cr, m_cw, m_model)) OVER w AS prev_tuple,
+      row_number() OVER w AS rn
+    -- m_turn: the user rows so far in the copy's stream. A user turn ends a run: two responses with the
+    -- same input and cache numbers on either side of a prompt are two responses, not one re-reported.
+    -- Counted over the copy's whole stream, before the rows the current copy also holds are left out.
+    FROM (SELECT * FROM (SELECT *, countIf(m_role = 'user') OVER (PARTITION BY h, s, g, m_copy, m_origin, m_epoch, m_agent ORDER BY m_seq
+                                                   ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS m_turn
+          FROM (${copiesSQL(N, P, n, b)}))
+          WHERE m_keep)
+    WINDOW w AS (PARTITION BY h, s, g, m_copy, m_origin, m_epoch, m_agent, m_turn, (m_role = 'assistant' AND (m_in + m_out + m_cr + m_cw) > 0) ORDER BY m_seq ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)`;
+}
+
+/** The run id of a Claude Code per_record usage row: the seq that started its run (qualified like its copy's message ids). */
+function runsSQL(N, P, n, b) {
+  return `SELECT *, row_number() OVER (PARTITION BY h, s, g, m_copy, m_origin, m_epoch, m_agent, has_usage, run_id ORDER BY m_seq) AS run_n
+    FROM (SELECT *, if(h = 'claude-code' AND has_usage,
+      concat('legacy-run:', m_origin, ':', toString(m_epoch), ':', toString(max(start_seq) OVER (PARTITION BY h, s, g, m_copy, m_origin, m_epoch, m_agent, m_turn, has_usage ORDER BY m_seq ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)), m_tag),
+      '') AS run_id
+    FROM (SELECT *, (m_role = 'assistant' AND (m_in + m_out + m_cr + m_cw) > 0) AS has_usage,
+                 if(rn = 1 OR prev_tuple != tuple(m_in, m_cr, m_cw, m_model), m_seq, 0) AS start_seq
+          FROM (${convertedMessagesSQL(N, P, n, b)})))`;
+}
+
+/** session_parts rows of one bucket. */
+function partsSelectSQL(N, P, n, b) {
+  const typed = `SELECT
+      CAST(if(ifNull(hp.v0, '') != '', hp.v0, c.z_old_host) AS String) AS host, CAST(c.h AS String) AS harness, CAST(c.z_path AS String) AS harness_path,
+      CAST(c.s AS String) AS session_id, '' AS incarnation,
+      c.m_mid AS message_id,
+      if(c.kind = 'none', '', '0') AS part_id, toUInt32(0) AS part_index, '' AS parent_id, leftPad(toString(c.m_seq), 12, '0') AS order_key,
+      c.m_agent AS agent_id, c.role AS role, '' AS source, CAST(NULL AS Nullable(Bool)) AS to_user, CAST(NULL AS Nullable(Bool)) AS to_model,
+      'complete' AS status, 'current' AS state, CAST(NULL AS Nullable(Bool)) AS on_active_branch, CAST(c.m_ts AS Nullable(DateTime64(3, 'UTC'))) AS ts,
+      '' AS requested_model, c.m_model AS served_model, '' AS effort, c.run_id AS response_id,
+      CAST([] AS Array(Tuple(id String, kind String))) AS message_aliases,
+      c.kind AS kind,
+      if(c.kind IN ('text', 'reasoning'), c.m_text, '') AS text, '' AS call_id,
+      if(c.kind = 'tool_call', extract(c.m_text_bare, '^\\\\[tool-call: ([^(\\\\]]+)'), '') AS tool_name, '' AS args, '' AS server,
+      CAST(NULL AS Nullable(Bool)) AS is_error, '' AS result_status,
+      if(c.kind = 'tool_result', c.m_text, '') AS output, '' AS output_ref, '' AS output_ref_sha256, CAST(NULL AS Nullable(UInt64)) AS output_ref_bytes,
+      CAST(if(c.kind = 'tool_result', toUInt64(lengthUTF8(c.m_text)), NULL) AS Nullable(UInt64)) AS output_len,
+      CAST(NULL AS Nullable(Bool)) AS truncated, CAST(NULL AS Nullable(Int32)) AS exit_code, '' AS media_type, '' AS inline_b64, '' AS ref,
+      CAST(NULL AS Nullable(UInt64)) AS bytes_len, CAST(NULL AS Nullable(Bool)) AS opaque, CAST(NULL AS Nullable(UInt32)) AS signature_len,
+      '' AS replaces_form, '' AS replaces_value, '' AS error_kind, '' AS error_message, CAST(NULL AS Nullable(UInt16)) AS http_status, '' AS level,
+      '' AS native_type, '' AS part_source, '' AS part_state, 'legacy' AS adapter, '0' AS adapter_ver, 'sessions-model/1' AS model_version,
+      c.m_ingested AS first_seen, c.m_folder AS folder, c.m_project AS project, toUInt32(lengthUTF8(c.m_text)) AS text_len, c.m_origin AS origin,
+      concat('{', arrayStringConcat(arrayFilter(x -> x != '', [
+        if(c.kind = 'tool_call', concat('"legacy_text":', toJSONString(c.m_text)), ''),
+        if(c.m_agent != '', concat('"agent":', c.m_agent_json), '')]), ','), '}') AS extra,
+      c.m_removed AS removed
+    FROM (${runsSQL(N, P, n, b)}) AS c
+    LEFT JOIN (${hostPairsSQL(P)}) AS hp ON hp.old_host = c.z_old_host`;
+  return `SELECT *, ${shaOf(PART_LINE.map((x) => `x.${x}`))} AS content_sha, content_sha AS message_content_sha, ${shaOf(CMP_LINE.map((x) => `x.${x}`))} AS cmp_sha,
+      toUInt64(0) AS rev, toUInt8(0) AS is_deleted
+    FROM (${typed}) AS x`;
+}
+
+/** session_usage rows of one bucket: the messages with a non-zero counter. */
+function usageSelectSQL(N, P, n, b) {
+  const typed = `SELECT
+      CAST(if(ifNull(hp.v0, '') != '', hp.v0, c.z_old_host) AS String) AS host, CAST(c.h AS String) AS harness, CAST(c.z_path AS String) AS harness_path,
+      CAST(c.s AS String) AS session_id, '' AS incarnation,
+      if(c.run_id != '', concat('response:', c.run_id, '#', toString(c.run_n)), concat('message:', c.m_mid, '#1')) AS usage_id,
+      if(c.run_id != '', 'response', 'message') AS anchor_kind,
+      if(c.run_id != '', c.run_id, c.m_mid) AS anchor_id,
+      CAST(c.m_in AS Nullable(UInt64)) AS input, CAST(c.m_out AS Nullable(UInt64)) AS output, CAST(c.m_cr AS Nullable(UInt64)) AS cache_read,
+      CAST(c.m_cw AS Nullable(UInt64)) AS cache_write, CAST(NULL AS Nullable(UInt64)) AS reasoning, CAST(NULL AS Nullable(UInt64)) AS tool_prompt,
+      CAST(NULL AS Nullable(Decimal(18, 9))) AS cost, ${flagSQL('c.h', 0)} AS input_includes_cache, ${flagSQL('c.h', 1)} AS output_includes_reasoning,
+      ${granularitySQL('c.h')} AS granularity, c.m_model AS model, 'legacy' AS adapter, '0' AS adapter_ver, 'sessions-model/1' AS model_version,
+      CAST(c.m_ts AS Nullable(DateTime64(3, 'UTC'))) AS ts, c.m_origin AS origin, c.m_removed AS removed
+    FROM (${runsSQL(N, P, n, b)}) AS c
+    LEFT JOIN (${hostPairsSQL(P)}) AS hp ON hp.old_host = c.z_old_host
+    WHERE c.has_usage OR (c.m_in + c.m_out + c.m_cr + c.m_cw) > 0`;
+  return `SELECT *, ${shaOf(USAGE_LINE.map((x) => `x.${x}`))} AS content_sha, toUInt64(0) AS rev, toUInt8(0) AS is_deleted FROM (${typed}) AS x`;
+}
+
+/** The converted parts' session keys in one bucket, with their fingerprints. */
+function sessionKeysSQL(P, n, b) {
+  return `SELECT host, harness, harness_path, session_id, incarnation,
+      arrayMap((x) -> x.3, arraySort(groupArray((order_key, message_id, cmp_sha)))) AS fp
+    FROM ${P.session_parts} FINAL
+    WHERE adapter = 'legacy' AND removed = 0 AND ${bucketSQL('harness', 'session_id', n, b)}
+    GROUP BY host, harness, harness_path, session_id, incarnation`;
+}
+
+/**
+ * The (harness, session, host group) of a bucket that hold message rows: a session has messages in its
+ * own host group, not merely under its id. Another machine's messages of a short id leave this one's
+ * message-less session to convert on its own, and its 0.18 row out of the sessions that have messages.
+ */
+function withMessagesSQL(N, P, n, b) {
+  const L = N.legacy;
+  return `SELECT DISTINCT mh, ms, ${hostGroupSQL('mh', 'ms', 'mx', 'hpm.v0')} AS mg
+    FROM (SELECT ${harnessSQL('m')} AS mh, ${sessionSQL('m')} AS ms, toString(m.host) AS mx FROM ${L.messages} AS m
+      WHERE ${bucketSQL(harnessSQL('m'), sessionSQL('m'), n, b)}) AS mm
+    LEFT JOIN (${hostPairsSQL(P)}) AS hpm ON hpm.old_host = mm.mx`;
+}
+
+/**
+ * The 0.18 sessions of one bucket with no message row at all, only their sessions room row (a title, a
+ * path): one key per (harness, session id, host group), the groups copiesSQL makes (one for a globally
+ * unique id, else one per host, a reported pair's hosts together). The key's host is its newest row's
+ * (host/v0 where paired), its path the newest non-empty one; e_ing the newest row's shipping time.
+ */
+function emptySessionKeysSQL(N, P, n, b) {
+  const withMessages = withMessagesSQL(N, P, n, b);
+  const groups = `SELECT z.v_harness AS e_harness, z.v_session AS e_session,
+      ${hostGroupSQL('z.v_harness', 'z.v_session', 'z.l_host', 'hp0.v0')} AS e_g,
+      argMax(z.l_host, z.l_ing) AS e_host, argMax(z.l_path, (z.l_path != '', z.l_ing)) AS e_path, max(z.l_ing) AS e_ing
+    FROM (${conv.legacySessionsSQL(N, n, b)}) AS z
+    LEFT JOIN (${hostPairsSQL(P)}) AS hp0 ON hp0.old_host = z.l_host
+    WHERE (z.v_harness, z.v_session, ${hostGroupSQL('z.v_harness', 'z.v_session', 'z.l_host', 'hp0.v0')}) NOT IN (${withMessages})
+    GROUP BY e_harness, e_session, e_g`;
+  return `SELECT CAST(if(ifNull(hp.v0, '') != '', hp.v0, e.e_host) AS String) AS host, CAST(e.e_harness AS String) AS harness,
+      CAST(e.e_path AS String) AS harness_path, CAST(e.e_session AS String) AS session_id, '' AS incarnation, e.e_ing AS e_ing
+    FROM (${groups}) AS e
+    LEFT JOIN (${hostPairsSQL(P)}) AS hp ON hp.old_host = e.e_host`;
+}
+
+/**
+ * sessions rows of one bucket: one per session key of the converted parts, and one per 0.18 session with
+ * no message row (emptySessionKeysSQL), its start and end its 0.18 times (run after the parts, usage and
+ * calls inserts).
+ */
+function sessionsSelectSQL(N, P, n, b) {
+  // A session's 0.18 metadata: its row in its own host group, the member's newest where several users
+  // shipped one. Two machines' sessions of one short id keep their own titles, folders and times.
+  // Two groupings of the rows: per machine (a short id's session on one host), and over the hosts
+  // whose messages it holds ('': a global id, every host; a session whose messages read as one
+  // machine renamed, the hosts of that stream). A row of a host with no messages is that host's own
+  // message-less session's, never another's. A session with no row of its own (0.18 kept one row per
+  // id and user, so a short id on two machines kept the last one's) borrows none: no title or times,
+  // and its folder and project from its messages.
+  const pick = `argMax(tuple(ls.l_name, ls.l_mode, ls.l_folder, ls.l_project, ls.l_branch, ls.l_created, ls.l_updated, ls.l_origin), (ls.l_user = ${lit(N.member)}, ls.l_ing)) AS z`;
+  const meta = `SELECT ls.v_harness AS z_harness, ls.v_session AS z_session, ${hostGroupSQL('ls.v_harness', 'ls.v_session', 'ls.l_host', 'hpz.v0')} AS z_g, ${pick}
+      FROM (${conv.legacySessionsSQL(N, n, b)}) AS ls
+      LEFT JOIN (${hostPairsSQL(P)}) AS hpz ON hpz.old_host = ls.l_host
+      WHERE NOT ${globalIdSQL('ls.v_harness', 'ls.v_session')}
+      GROUP BY z_harness, z_session, z_g
+    UNION ALL
+    SELECT ls.v_harness AS z_harness, ls.v_session AS z_session, '' AS z_g, ${pick}
+      FROM (${conv.legacySessionsSQL(N, n, b)}) AS ls
+      LEFT JOIN (${hostPairsSQL(P)}) AS hpw ON hpw.old_host = ls.l_host
+      WHERE ${globalIdSQL('ls.v_harness', 'ls.v_session')}
+        OR (ls.v_harness, ls.v_session, ${hostGroupSQL('ls.v_harness', 'ls.v_session', 'ls.l_host', 'hpw.v0')}) IN (${withMessagesSQL(N, P, n, b)})
+      GROUP BY z_harness, z_session`;
+  const keys = `SELECT toString(host) AS host, toString(harness) AS harness, toString(harness_path) AS harness_path, session_id, incarnation, fp,
+      toUInt8(0) AS e_empty, CAST(NULL AS Nullable(DateTime64(3, 'UTC'))) AS e_ing FROM (${sessionKeysSQL(P, n, b)})
+    UNION ALL
+    SELECT host, harness, harness_path, session_id, incarnation, CAST([] AS Array(FixedString(64))) AS fp,
+      toUInt8(1) AS e_empty, CAST(e_ing AS Nullable(DateTime64(3, 'UTC'))) AS e_ing FROM (${emptySessionKeysSQL(N, P, n, b)})`;
+  // A session with no message row has no rollup: its start and end are its 0.18 times (schema 3's rule).
+  const roll = { started: 'if(k.e_empty, coalesce(tupleElement(m.z, 6), tupleElement(m.z, 7), k.e_ing), r.r_started)',
+    ended: 'if(k.e_empty, coalesce(tupleElement(m.z, 7), tupleElement(m.z, 6), k.e_ing), r.r_ended)' };
+  const typed = `SELECT
+      CAST(k.host AS String) AS host, '' AS host_label, CAST(k.harness AS String) AS harness, CAST(k.harness_path AS String) AS harness_path,
+      k.session_id AS session_id, k.incarnation AS incarnation, '' AS engine, '' AS client, '' AS harness_version,
+      tupleElement(m.z, 1) AS title, 'unknown' AS title_set_by, if(ifNull(m.z_harness, '') = '', r.r_folder, tupleElement(m.z, 3)) AS cwd, '' AS last_cwd,
+      CAST(tupleElement(m.z, 6) AS Nullable(DateTime64(3, 'UTC'))) AS created_at, CAST(tupleElement(m.z, 7) AS Nullable(DateTime64(3, 'UTC'))) AS updated_at,
+      'active' AS state, CAST(NULL AS Nullable(Bool)) AS pinned, tupleElement(m.z, 2) AS mode, '' AS kind, 'undetectable' AS reuse, 'legacy' AS ts_source,
+      CAST([] AS Array(Tuple(id String, kind String))) AS aliases, CAST(k.fp AS Array(FixedString(64))) AS fingerprint, CAST(NULL AS Nullable(String)) AS setup,
+      'legacy' AS adapter, '0' AS adapter_ver, 'sessions-model/1' AS model_version,
+      if(ifNull(m.z_harness, '') = '', r.r_folder, tupleElement(m.z, 3)) AS folder, if(ifNull(m.z_harness, '') = '', r.r_project, tupleElement(m.z, 4)) AS project,
+      tupleElement(m.z, 5) AS git_branch,
+      if(tupleElement(m.z, 8) != '', tupleElement(m.z, 8), 'ship') AS origin,
+      ${rollup.ROLLUP_COLUMNS.map(([c, e]) => `${roll[c] || e} AS ${c}`).join(', ')}
+    FROM (${keys}) AS k
+    -- A key's metadata group: '' where the id is global, or its messages read as one machine renamed;
+    -- else the key's host (host/v0 where paired), as the copies and the message-less keys make it.
+    LEFT JOIN (${meta}) AS m ON m.z_harness = k.harness AND m.z_session = k.session_id
+      AND m.z_g = if(${globalIdSQL('k.harness', 'k.session_id')} OR (NOT k.e_empty AND (k.harness, k.session_id) IN (${oneMachineSQL(N, P, n, b)})), '', k.host)
+    LEFT JOIN (${rollup.sessionRollupSQL(P, bucketSQL('harness', 'session_id', n, b))}) AS r
+      ON r.host = k.host AND r.harness = k.harness AND r.harness_path = k.harness_path AND r.session_id = k.session_id AND r.incarnation = k.incarnation`;
+  return `SELECT *, ${shaOf(SESSION_LINE.map((x) => `x.${x}`))} AS content_sha, toUInt64(0) AS rev, toUInt8(0) AS is_deleted, toUInt8(0) AS removed
+    FROM (${typed}) AS x`;
+}
+
+/**
+ * The 0.18 tool calls of a bucket that convert: each takes its message's copy decision (dropped with
+ * a duplicate message, a removed version with a removed one, its ids qualified like the message's).
+ * A call whose message has no row converts on its own: live in the current copy, removed (and
+ * qualified) in another; its session and host group are found as its message's would be.
+ */
+function callsDecisionSQL(N, P, n, b) {
+  const copies = copiesSQL(N, P, n, b);
+  return `SELECT c.*, if(c.i_hit = 1, c.i_h, gs.h) AS d_h0, if(c.i_hit = 1, c.i_s, gs.s) AS d_s0, if(c.i_hit = 1, c.i_g, gs.g) AS d_g,
+      if(c.i_hit = 1, c.i_tag, if(c.c_copy = gs.cur_copy, '', concat('~', lower(hex(cityHash64(c.c_copy)))))) AS d_tag,
+      toUInt8(if(c.i_hit = 1, c.i_removed, c.c_copy != gs.cur_copy)) AS d_removed,
+      if(c.i_hit = 1, c.i_host, gs.z_old_host) AS d_host, if(c.i_hit = 1, c.i_path, gs.z_path) AS d_path,
+      if(c.i_hit = 1, c.i_agent, '') AS d_agent, if(c.i_hit = 1, c.i_model, '') AS d_model,
+      concat(c.v_call_id, if(c.i_hit = 1, c.i_tag, if(c.c_copy = gs.cur_copy, '', concat('~', lower(hex(cityHash64(c.c_copy))))))) AS cid
+    FROM (
+      SELECT c.*, ifNull(d.i_hit, 0) AS i_hit, ifNull(d.i_keep, 0) AS i_keep, d.h AS i_h, d.s AS i_s, d.g AS i_g, d.m_tag AS i_tag, d.m_removed AS i_removed,
+          d.z_old_host AS i_host, d.z_path AS i_path, d.m_agent AS i_agent, d.m_model AS i_model,
+          concat(c.l_session, char(0), c.v_user) AS c_copy,
+          ${groupSQL(N, P, n, b, 'c.v_harness', 'c.v_session', 'c.v_host', 'hp0.v0')} AS c_g
+        FROM (${conv.legacyCallsSQL(N, n, b, { onePerKey: false })}) AS c
+        LEFT JOIN (SELECT l_session, m_user, m_origin, m_epoch, m_seq, h, s, g, m_tag, m_removed, z_old_host, z_path, m_agent, m_model,
+            toUInt8(1) AS i_hit, toUInt8(m_keep) AS i_keep FROM (${copies})) AS d
+          ON d.l_session = c.l_session AND d.m_user = c.v_user AND d.m_origin = c.v_origin AND d.m_epoch = c.l_epoch AND d.m_seq = c.l_seq
+        LEFT JOIN (${hostPairsSQL(P)}) AS hp0 ON hp0.old_host = c.v_host
+    ) AS c
+    LEFT JOIN (SELECT DISTINCT h, s, g, cur_copy, z_old_host, z_path FROM (${copies})) AS gs
+      ON gs.h = c.v_harness AND gs.s = c.v_session AND gs.g = c.c_g
+    WHERE (c.i_hit = 1 AND c.i_keep = 1) OR (c.i_hit = 0 AND gs.h != '')`;
+}
+
+/** calls rows of one bucket: one per 0.18 tool call that converts, with its message's part sha (run after partsInsertSQL). */
+function callsSelectSQL(N, P, n, b) {
+  const typed = `SELECT
+      CAST(if(ifNull(hp.v0, '') != '', hp.v0, c.d_host) AS String) AS host, CAST(c.d_h0 AS String) AS harness, CAST(c.d_path AS String) AS harness_path,
+      CAST(c.d_s0 AS String) AS session_id, '' AS incarnation, c.cid AS call_id, concat(c.v_message_id, c.d_tag) AS message_id, c.d_agent AS agent_id,
+      CAST(c.v_ts AS Nullable(DateTime64(3, 'UTC'))) AS ts, c.v_ingested AS first_seen, c.v_tool AS tool_name, c.v_args AS args,
+      CAST(NULL AS Nullable(DateTime64(3, 'UTC'))) AS result_ts, CAST(NULL AS Nullable(Bool)) AS is_error, CAST(NULL AS Nullable(UInt64)) AS output_len,
+      c.d_model AS model, c.v_folder AS folder, c.v_project AS project, 'legacy' AS adapter, '0' AS adapter_ver, c.d_removed AS removed
+    FROM (${callsDecisionSQL(N, P, n, b)}) AS c
+    LEFT JOIN (${hostPairsSQL(P)}) AS hp ON hp.old_host = c.d_host`;
+  // A call whose message converted takes its part's sha; an orphan call (no message row: converted
+  // with its session) gets its own, over its key and content, never the join's empty default.
+  return `SELECT x.*, if(sp.message_id != '', sp.content_sha,
+        ${shaOf(['x.host', 'x.harness', 'x.harness_path', 'x.session_id', 'x.incarnation', 'x.call_id', 'x.message_id', 'x.tool_name', 'x.args'])}) AS content_sha,
+      toUInt64(0) AS rev, toUInt8(0) AS is_deleted
+    FROM (${typed}) AS x
+    LEFT JOIN (
+      SELECT host, harness, harness_path, session_id, message_id, any(content_sha) AS content_sha FROM ${P.session_parts} FINAL
+      WHERE adapter = 'legacy' AND ${bucketSQL('harness', 'session_id', n, b)} GROUP BY host, harness, harness_path, session_id, message_id
+    ) AS sp ON sp.host = x.host AND sp.harness = x.harness AND sp.harness_path = x.harness_path AND sp.session_id = x.session_id AND sp.message_id = x.message_id`;
+}
+
+/** The legacy session paths (convert-v3's rule), when convert-v3 does not export its own. */
+function legacyPathsSQL(N) {
+  return `SELECT z.session_id AS l_session, argMax(${conv.pathSQL(harnessSQL('z'), 'z.path')}, z.ingested_at) AS l_path FROM ${N.legacy.sessions} AS z FINAL GROUP BY z.session_id`;
+}
+
+const INSERT_PART_COLUMNS = [...PART_COLUMNS, 'rev', 'is_deleted', 'removed', 'first_seen', 'folder', 'project', 'text_len', 'origin', 'extra'];
+const INSERT_USAGE_COLUMNS = [...USAGE_COLUMNS, 'rev', 'is_deleted', 'removed', 'ts', 'origin'];
+function partsInsertSQL(N, P, n, b) { return `INSERT INTO ${P.session_parts} (${INSERT_PART_COLUMNS.join(', ')}) SELECT ${INSERT_PART_COLUMNS.join(', ')} FROM (${partsSelectSQL(N, P, n, b)})`; }
+function usageInsertSQL(N, P, n, b) { return `INSERT INTO ${P.session_usage} (${INSERT_USAGE_COLUMNS.join(', ')}) SELECT ${INSERT_USAGE_COLUMNS.join(', ')} FROM (${usageSelectSQL(N, P, n, b)})`; }
+const INSERT_SESSION_COLUMNS = [...SESSION_COLUMNS, 'rev', 'is_deleted', 'removed', 'folder', 'project', 'git_branch', 'origin', ...rollup.ROLLUP_COLUMNS.map(([c]) => c)];
+const INSERT_CALL_COLUMNS = [...CALL_COLUMNS, 'rev', 'is_deleted', 'removed'];
+/** Last for a bucket: after its parts, usage and calls (the rollup reads all three). callsInsertSQL after partsInsertSQL. */
+function sessionsInsertSQL(N, P, n, b) { return `INSERT INTO ${P.sessions} (${INSERT_SESSION_COLUMNS.join(', ')}) SELECT ${INSERT_SESSION_COLUMNS.join(', ')} FROM (${sessionsSelectSQL(N, P, n, b)})`; }
+function callsInsertSQL(N, P, n, b) { return `INSERT INTO ${P.calls} (${INSERT_CALL_COLUMNS.join(', ')}) SELECT ${INSERT_CALL_COLUMNS.join(', ')} FROM (${callsSelectSQL(N, P, n, b)})`; }
+
+/** A stored row's content_sha, recomputed from its columns: what a verifier runs. */
+function verifyShaSQL(P, table) {
+  const line = { session_parts: PART_LINE, session_usage: USAGE_LINE, sessions: SESSION_LINE }[table];
+  return `SELECT count() AS rows, countIf(content_sha != ${shaOf(line)}) AS mismatched
+    ${table === 'session_parts' ? `, countIf(message_content_sha != content_sha) AS msg_mismatched, countIf(cmp_sha != ${shaOf(CMP_LINE)}) AS cmp_mismatched` : ''}
+    FROM ${P[table]} FINAL WHERE adapter = 'legacy'`;
+}
+
+/** The names both sides of the conversion use. */
+function names(db, member) { return { N: v3Names(db, member), P: profileNames(db, member) }; }
+
+// ── running the conversion (memhouse migrate --v3-convert) ────────────────────────────────
+//
+// THE DRIVER (each line is a decision)
+//   buckets     the 0.18 rows split by cityHash64(harness, session_id) into n buckets (convert-v3's
+//               rule: at most BATCH_ROWS rows or BATCH_BYTES of text each), so one INSERT … SELECT
+//               stays bounded and a stopped run resumes per bucket
+//   complete    a bucket is done when its converted parts, calls and sessions hold every key its
+//               0.18 rows make: a message (session, origin, epoch, seq), a tool call (session, call
+//               id), a session key of its converted parts. Anything less reruns the bucket's four
+//               inserts in order (parts, usage, calls, sessions): each writes the same keys at rev 0
+//               with the same content, so a rerun collapses into what is there
+//   dedupe      once the capture has deduped converted rows (a legacy marker in session_sources), a
+//               tombstone cleanup may have dropped them, and a rerun would write them back: refused
+//               unless forced
+//   ledger      an events row per run: pending, then applied or failed
+//   reconcile   every stored converted row's content_sha (and a part's message_content_sha and
+//               cmp_sha) recomputed from its columns, and the buckets' completeness
+
+const CONVERT_SETTINGS = { ...conv.CONVERT_SETTINGS, ...SHA_SETTINGS };
+const INSERT_SETTINGS = { ...conv.INSERT_SETTINGS, ...SHA_SETTINGS };
+const bucketOf = (h, s, n) => (n > 1 ? `cityHash64(toString(${h}), toString(${s})) % ${n}` : '0');
+
+async function rowsOrEmpty(q, sql) {
+  try { return await q.rows(sql, CONVERT_SETTINGS); }
+  catch (e) {
+    if (/UNKNOWN_TABLE|Unknown table|doesn't exist|does not exist/i.test(String(e && e.message))) return [];
+    throw e;
+  }
+}
+const byBucket = (rows, field) => new Map(rows.map((r) => [Number(r.b), Number(r[field]) || 0]));
+const sumMap = (m) => [...m.values()].reduce((a, v) => a + v, 0);
+const addMaps = (x, y) => { const m = new Map(x); for (const [k, v] of y) m.set(k, (m.get(k) || 0) + v); return m; };
+
+/** Per bucket: what the 0.18 rows make, and what the profile holds of it. */
+async function planProfile(q, N, P, n) {
+  const L = N.legacy;
+  const [lm, pm, lc, lo, lk, pc, ws, le, hs] = await Promise.all([
+    q.rows(`SELECT ${bucketOf('h', 's', n)} AS b, count() AS rows, uniqExactIf((h, s, g, m_mid), m_keep) AS keys
+      FROM (${copiesSQL(N, P, 1, 0)}) GROUP BY b`, CONVERT_SETTINGS),
+    rowsOrEmpty(q, `SELECT ${bucketOf('harness', 'session_id', n)} AS b, uniqExact(host, toString(harness), toString(harness_path), session_id, message_id) AS keys
+      FROM ${P.session_parts} WHERE adapter = 'legacy' GROUP BY b`),
+    // every 0.18 call counts in rows, so one that does not convert (its message a duplicate, or no message
+    // of its session left) shows as a collision rather than vanishing
+    q.rows(`SELECT ${bucketOf('v_harness', 'v_session', n)} AS b, count() AS rows
+      FROM (${conv.legacyCallsSQL(N, 1, 0, { onePerKey: false })}) GROUP BY b`, CONVERT_SETTINGS),
+    // and so does a shipped call of a session with no shipped message, which no parse holds
+    q.rows(`SELECT ${bucketOf(harnessSQL('t'), sessionSQL('t'), n)} AS b, count() AS rows FROM ${L.tool_calls} AS t FINAL
+      WHERE t.origin = 'ship' AND (t.session_id, t.user_id) NOT IN (SELECT DISTINCT session_id, user_id FROM ${L.messages} WHERE origin = 'ship') GROUP BY b`, CONVERT_SETTINGS),
+    q.rows(`SELECT ${bucketOf('v_harness', 'v_session', n)} AS b, uniqExact(d_h0, d_s0, d_g, cid) AS keys
+      FROM (${callsDecisionSQL(N, P, 1, 0)}) GROUP BY b`, CONVERT_SETTINGS),
+    rowsOrEmpty(q, `SELECT ${bucketOf('harness', 'session_id', n)} AS b, uniqExact(host, toString(harness), toString(harness_path), session_id, call_id) AS keys
+      FROM ${P.calls} WHERE adapter = 'legacy' GROUP BY b`),
+    rowsOrEmpty(q, `SELECT ${bucketOf('harness', 'session_id', n)} AS b, uniqExact(host, toString(harness), toString(harness_path), session_id, incarnation) AS keys
+      FROM ${P.session_parts} WHERE adapter = 'legacy' GROUP BY b`),
+    // a 0.18 session with no message row converts too, as a session without messages
+    q.rows(`SELECT ${bucketOf('harness', 'session_id', n)} AS b, uniqExact(host, harness, harness_path, session_id, incarnation) AS keys
+      FROM (${emptySessionKeysSQL(N, P, 1, 0)}) GROUP BY b`, CONVERT_SETTINGS),
+    rowsOrEmpty(q, `SELECT ${bucketOf('harness', 'session_id', n)} AS b, uniqExact(host, toString(harness), toString(harness_path), session_id, incarnation) AS keys
+      FROM ${P.sessions} WHERE adapter = 'legacy' GROUP BY b`),
+  ]);
+  return {
+    parts: { rows: byBucket(lm, 'rows'), want: byBucket(lm, 'keys'), have: byBucket(pm, 'keys') },
+    calls: { rows: addMaps(byBucket(lc, 'rows'), byBucket(lo, 'rows')), want: byBucket(lk, 'keys'), have: byBucket(pc, 'keys') },
+    sessions: { want: addMaps(byBucket(ws, 'keys'), byBucket(le, 'keys')), have: byBucket(hs, 'keys') },
+  };
+}
+const complete = (p, b) => (p.want.get(b) || 0) === (p.have.get(b) || 0);
+function summarize(p, inserted, skipped) {
+  const out = { legacy_keys: sumMap(p.want), converted_keys: sumMap(p.have), buckets_inserted: inserted, buckets_skipped: skipped };
+  // 0.18 rows of a session's other copies the current copy holds again (true duplicates, not converted): reported, never hidden.
+  if (p.rows) { out.legacy_rows = sumMap(p.rows); out.collisions = out.legacy_rows - out.legacy_keys; }
+  return out;
+}
+
+/**
+ * Convert one member's 0.18 rooms (renamed into the archive by --v3-prepare) into the profile.
+ * @param q   { sql(sql, settings), rows(sql, settings) }
+ * @param ctx { db, member, ledger?, host?, forceAfterDedupe? }
+ */
+async function convertProfile(q, ctx, { batchRows = conv.BATCH_ROWS, batchBytes = conv.BATCH_BYTES, dryRun = false } = {}, ui = null) {
+  const { N, P } = names(ctx.db, ctx.member);
+  const say = (m) => ui && ui.ok && ui.ok(m);
+  const marked = await rowsOrEmpty(q, `SELECT count() AS n FROM ${P.session_sources} FINAL WHERE role = 'legacy' AND is_deleted = 0`);
+  const dedupedSessions = Number((marked[0] || {}).n) || 0;
+  const started = Date.now();
+  const size = await conv.legacySize(q, N);
+  const n = conv.bucketCount(size.rows, batchRows, size.bytes, batchBytes);
+  const before = await planProfile(q, N, P, n);
+  const done = (pl, b) => complete(pl.parts, b) && complete(pl.calls, b) && complete(pl.sessions, b);
+  // A conversion with every bucket complete writes nothing but its mark, so a dedupe is no reason to
+  // refuse it: a member converted before the mark existed gets it from a plain re-run.
+  if (dedupedSessions && !ctx.forceAfterDedupe && ![...Array(n).keys()].every((b) => done(before, b))) {
+    return { member: ctx.member, ok: false, deduped_sessions: dedupedSessions, refused: `${dedupedSessions} session(s) of ${ctx.member} are already deduped against their capture; `
+      + 're-converting could bring back rows the dedupe removed (and a cleanup may have dropped). Refusing.' };
+  }
+  const report = { member: ctx.member, source: N.legacy, target: { session_parts: P.session_parts, session_usage: P.session_usage, calls: P.calls, sessions: P.sessions },
+    buckets: n, legacy_text_bytes: size.bytes, dry_run: Boolean(dryRun) };
+  if (dryRun) {
+    for (const t of ['parts', 'calls', 'sessions']) report[t] = summarize(before[t], 0, 0);
+    report.pending_buckets = [...Array(n).keys()].filter((b) => !done(before, b));
+    report.ok = report.pending_buckets.length === 0;
+    return report;
+  }
+  const event = async (e) => { if (ctx.ledger) { try { await ctx.ledger.event(e); } catch { /* best effort */ } } };
+  await event({ kind: 'migration', id: '0200-profile-convert', status: 'pending', host: ctx.host || '', detail: `convert ${ctx.member}: ${n} bucket(s)` });
+  let inserted = 0; let skipped = 0;
+  try {
+    for (let b = 0; b < n; b++) {
+      if (done(before, b)) { skipped++; continue; }
+      for (const [t, build] of [['parts', partsInsertSQL], ['usage', usageInsertSQL], ['calls', callsInsertSQL], ['sessions', sessionsInsertSQL]]) {
+        await q.sql(build(N, P, n, b), INSERT_SETTINGS);
+        say(`${t}: bucket ${b + 1}/${n}`);
+      }
+      inserted++;
+    }
+  } catch (e) {
+    await event({ kind: 'migration', id: '0200-profile-convert', status: 'failed', host: ctx.host || '', detail: `convert ${ctx.member}: ${String(e && e.message).split('\n')[0]}` });
+    throw e;
+  }
+  const after = await planProfile(q, N, P, n);
+  for (const t of ['parts', 'calls', 'sessions']) { report[t] = summarize(after[t], inserted, skipped); report[t].converted_before = sumMap(before[t].have); }
+  report.ok = [...Array(n).keys()].every((b) => done(after, b));
+  // The mark that opens the house to schema-3 installs and --v3-switch (schema-choice.js): only a
+  // conversion that ran to the end writes it.
+  if (report.ok) await q.sql(`INSERT INTO ${P.meta} (key, value) VALUES ('profile_converted', ${lit(new Date(started).toISOString())})`, { async_insert: 0 });
+  report.seconds = Math.round((Date.now() - started) / 100) / 10;
+  await event({ kind: 'migration', id: '0200-profile-convert', status: report.ok ? 'applied' : 'failed', host: ctx.host || '',
+    rows_before: report.parts.legacy_rows, rows_after: report.parts.converted_keys,
+    detail: `convert ${ctx.member}: parts ${report.parts.converted_keys}/${report.parts.legacy_keys}, calls ${report.calls.converted_keys}/${report.calls.legacy_keys}, `
+      + `sessions ${report.sessions.converted_keys}/${report.sessions.legacy_keys}${report.parts.collisions ? `, ${report.parts.collisions} collision(s)` : ''}` });
+  return report;
+}
+
+/** The conversion's check: every converted row's shas recomputed from its columns, and every bucket complete. */
+async function reconcileProfile(q, ctx, { batchRows = conv.BATCH_ROWS, batchBytes = conv.BATCH_BYTES } = {}) {
+  const { N, P } = names(ctx.db, ctx.member);
+  const out = { member: ctx.member, tables: {} };
+  for (const t of ['session_parts', 'session_usage', 'sessions']) {
+    const r = (await rowsOrEmpty(q, verifyShaSQL(P, t)))[0] || {};
+    out.tables[t] = Object.fromEntries(Object.entries(r).map(([k, v]) => [k, Number(v) || 0]));
+  }
+  const size = await conv.legacySize(q, N);
+  const n = conv.bucketCount(size.rows, batchRows, size.bytes, batchBytes);
+  const pl = await planProfile(q, N, P, n);
+  out.buckets = n;
+  out.incomplete_buckets = [...Array(n).keys()].filter((b) => !(complete(pl.parts, b) && complete(pl.calls, b) && complete(pl.sessions, b)));
+  for (const t of ['parts', 'calls', 'sessions']) out[t] = summarize(pl[t], 0, 0);
+  out.ok = !out.incomplete_buckets.length && Object.values(out.tables).every((x) => !x.mismatched && !x.msg_mismatched && !x.cmp_mismatched);
+  return out;
+}
+
+module.exports = {
+  SHA_SETTINGS, PART_COLUMNS, PART_LINE, CMP_LINE, USAGE_COLUMNS, USAGE_LINE, SESSION_COLUMNS, SESSION_LINE, CALL_COLUMNS, FLAGS, GRANULARITY,
+  hostPairsSQL, oneMachineSQL, copiesSQL, callsDecisionSQL, GLOBAL_ID_HARNESSES, convertedMessagesSQL, runsSQL, partsSelectSQL, usageSelectSQL, sessionKeysSQL, emptySessionKeysSQL, sessionsSelectSQL, callsSelectSQL,
+  partsInsertSQL, usageInsertSQL, sessionsInsertSQL, callsInsertSQL, verifyShaSQL, names,
+  planProfile, convertProfile, reconcileProfile, CONVERT_SETTINGS, INSERT_SETTINGS,
+};