memhouse 0.18.2 → 0.18.3

package/editors/claude.js

@@ -195,11 +195,19 @@ function cleanPrompt(prompt) {
 // Parse one Claude session .jsonl into the adapter's message shape. When
 // `isSubagent` is set, each message is tagged `[subagent]` so folded subagent turns
 // are clearly attributed in the transcript.
-function parseSessionFile(filePath, isSubagent) {
+function parseSessionFile(filePath, isSubagent, agent = null) {
   const messages = [];
   let lines;
   try { lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean); } catch { return messages; }
   const tag = isSubagent ? '[subagent] ' : '';
+  // A folded subagent turn used to carry only the `[subagent]` tag: the house held the
+  // turns but not WHICH subagent said them, so one fork's transcript could not be isolated,
+  // cited, or told apart from a sibling's. An agent looking for the fork as its own session
+  // concluded it was never shipped. Every turn now carries the agent's id, the description
+  // the parent gave it, and its position within that subagent — in `extra`, which is not
+  // part of the line hash, so nothing already shipped is re-shipped for this.
+  let turn = 0;
+  const stamp = (m) => { if (agent) { m._agent = { ...agent, turn: turn++ }; } return m; };
 
   for (const line of lines) {
     let obj;
@@ -223,19 +231,19 @@ function parseSessionFile(filePath, isSubagent) {
 
     if (obj.type === 'user' && obj.message) {
       const content = extractContent(obj.message.content);
-      if (content) messages.push({ role: 'user', content: tag + content, _ts: at });
+      if (content) messages.push(stamp({ role: 'user', content: tag + content, _ts: at }));
     } else if (obj.type === 'assistant' && obj.message) {
       const { text, toolCalls } = extractAssistantContent(obj.message.content);
       const usage = obj.message.usage;
-      if (text) messages.push({
+      if (text) messages.push(stamp({
         role: 'assistant', content: tag + text, _model: obj.message.model,
         _inputTokens: usage?.input_tokens, _outputTokens: usage?.output_tokens,
         _cacheRead: usage?.cache_read_input_tokens, _cacheWrite: usage?.cache_creation_input_tokens,
         _toolCalls: toolCalls, _ts: at,
-      });
+      }));
     } else if (obj.type === 'system') {
       const text = typeof obj.message?.content === 'string' ? obj.message.content : '';
-      if (text) messages.push({ role: 'system', content: tag + text, _ts: at });
+      if (text) messages.push(stamp({ role: 'system', content: tag + text, _ts: at }));
     }
   }
   return messages;
@@ -252,14 +260,86 @@ function getMessages(chat) {
   // after the parent's turns, so nothing is lost and subagents are never
   // double-counted as standalone sessions.
   const subagentsDir = path.join(filePath.replace(/\.jsonl$/, ''), 'subagents');
-  try {
-    const files = fs.readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl')).sort();
-    for (const f of files) messages.push(...parseSessionFile(path.join(subagentsDir, f), true));
-  } catch { /* no subagents for this session */ }
+  const subFiles = subagentFiles(subagentsDir);
+  const named = subFiles.length ? subagentNames(filePath) : new Map();
+  for (const { file, workflow } of subFiles) {
+    const id = path.basename(file).replace(/^agent-/, '').replace(/\.jsonl$/, '');
+    const meta = named.get(id) || {};
+    const agent = { id, description: meta.description || '', type: meta.type || (workflow ? 'workflow-subagent' : ''), file: path.basename(file) };
+    if (workflow) agent.workflow = workflow;
+    const turns = parseSessionFile(file, true, agent);
+    // A fork the parent never named (a Workflow-run agent, or a parent from before the
+    // ids were reported) is described by its own first prompt — what it was told to do.
+    if (!agent.description) {
+      const first = turns.find((m) => m.role === 'user');
+      if (first) { const d = String(first.content).replace(/^\[subagent\] /, '').replace(/\s+/g, ' ').trim().slice(0, 160); for (const m of turns) m._agent.description = d; }
+    }
+    messages.push(...turns);
+  }
 
   return messages;
 }
 
+/**
+ * Every subagent transcript under a session, wherever Claude Code put it:
+ *   <session>/subagents/agent-<id>.jsonl                       — Agent tool forks
+ *   <session>/subagents/workflows/wf_<id>/agent-<id>.jsonl     — Workflow-run agents
+ * journal.jsonl and *.meta.json are bookkeeping, not transcripts. Sorted for a stable
+ * fold order. On real data the workflow layer held 100 of 165 forks and shipped none.
+ */
+function subagentFiles(subagentsDir) {
+  const out = [];
+  let names = [];
+  try { names = fs.readdirSync(subagentsDir); } catch { return out; }
+  for (const f of names.sort()) if (f.startsWith('agent-') && f.endsWith('.jsonl')) out.push({ file: path.join(subagentsDir, f), workflow: null });
+  const wfDir = path.join(subagentsDir, 'workflows');
+  let wfs = [];
+  try { wfs = fs.readdirSync(wfDir).filter((d) => d.startsWith('wf_')).sort(); } catch { return out; }
+  for (const wf of wfs) {
+    let files = [];
+    try { files = fs.readdirSync(path.join(wfDir, wf)); } catch { continue; }
+    for (const f of files.sort()) if (f.startsWith('agent-') && f.endsWith('.jsonl')) out.push({ file: path.join(wfDir, wf, f), workflow: wf });
+  }
+  return out;
+}
+
+/**
+ * What the parent called each subagent. The parent's `Agent` tool_use carries the
+ * description and subagent_type; the tool_result that answers it names the agentId
+ * ("agentId: <id>"). Join the two through tool_use_id → a map agentId → {description, type}.
+ * Best effort: a parent that predates the ids, or a truncated line, just yields no name.
+ */
+function subagentNames(parentFile) {
+  const byToolUse = new Map(); const out = new Map();
+  let lines = [];
+  try { lines = fs.readFileSync(parentFile, 'utf-8').split('\n').filter(Boolean); } catch { return out; }
+  for (const line of lines) {
+    let obj; try { obj = JSON.parse(line); } catch { continue; }
+    const content = obj.message && Array.isArray(obj.message.content) ? obj.message.content : [];
+    for (const c of content) {
+      if (c && c.type === 'tool_use' && c.name === 'Agent' && c.id) {
+        byToolUse.set(c.id, { description: String((c.input && c.input.description) || ''), type: String((c.input && c.input.subagent_type) || '') });
+      } else if (c && c.type === 'tool_result' && c.tool_use_id && byToolUse.has(c.tool_use_id)) {
+        const text = typeof c.content === 'string' ? c.content : (Array.isArray(c.content) ? c.content.map((x) => (x && x.text) || '').join('\n') : '');
+        const m = /agentId:\s*([0-9a-f]{6,})/i.exec(text);
+        if (m) out.set(m[1], byToolUse.get(c.tool_use_id));
+      }
+    }
+    // A background subagent reports through a task notification instead — a user-role
+    // line whose text carries <task-id>agentId</task-id> and <tool-use-id>toolu_…</tool-use-id>.
+    // On real data 30 of 65 forks were named only this way.
+    const flat = typeof (obj.message && obj.message.content) === 'string' ? obj.message.content
+      : content.map((x) => (x && typeof x.text === 'string') ? x.text : '').join('\n');
+    if (flat.includes('<task-notification>')) {
+      for (const block of flat.split('<task-notification>').slice(1)) {
+        const t = /<task-id>([0-9a-f]{6,})<\/task-id>/i.exec(block); const u = /<tool-use-id>(toolu_[A-Za-z0-9]+)<\/tool-use-id>/.exec(block);
+        if (t && u && byToolUse.has(u[1]) && !out.has(t[1])) out.set(t[1], byToolUse.get(u[1]));
+      }
+    }
+  }
+  return out;
+}
+
 function extractContent(content) {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
@@ -420,4 +500,4 @@ function getMCPServers() {
 // answer to a different question: where this pilot's Claude Code instances live. Two
 // implementations of "find every CLAUDE_CONFIG_DIR" would drift the first time a playbook
 // layout changes, and this is the copy exercised on every single ship.
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers, discoverClaudeRoots };
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers, discoverClaudeRoots, subagentNames, subagentFiles };

package/memhouse/delivery/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mem",
   "description": "Conversation memory for AI agents over the memhouse typed ClickHouse store: recall past sessions and answer from them, run analytics, check the house, bring people in, and administer the server. Skills install as /mem:recall, /mem:sql, /mem:house, /mem:access, and /mem:admin.",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "author": {
     "name": "Ramazan Polat"
   },

package/memhouse/delivery/plugin/reference/HOUSE.md

@@ -92,6 +92,21 @@ wrong rooms. Say whose memory an answer came from.
 
 ## Schema
 
+**Subagents (forks) live inside their parent session.** Claude Code writes them to
+`<session>/subagents/agent-<id>.jsonl` (Agent tool) and
+`<session>/subagents/workflows/wf_<id>/agent-<id>.jsonl` (Workflow runs); the shipper folds them into the parent with
+`is_subagent = 1` and stamps *which* one in `extra.agent`. Looking for a fork as its own
+session finds nothing — look inside the parent:
+
+```sql
+-- the subagents a session spawned
+SELECT toString(extra.agent.id) AS agent, any(toString(extra.agent.description)) AS asked_to, count() AS turns
+FROM messages WHERE session_id = '<sid>' AND is_subagent GROUP BY agent   -- toString: a JSON path cannot be a GROUP BY key
+-- one subagent's transcript, in order
+SELECT seq, role, substring(text, 1, 2000) FROM messages
+WHERE session_id = '<sid>' AND extra.agent.id = '<agent>' ORDER BY seq
+```
+
 **`messages`** — one row per turn.
 
 | column | meaning |
@@ -102,6 +117,8 @@ wrong rooms. Say whose memory an answer came from.
 | `host` | the machine, `<hostname>-<8 hex>` — random per install, not derived |
 | `ts` | when the turn happened (`DateTime64(3,'UTC')`) |
 | `role` | `user`, `assistant`, `system` |
+| `is_subagent` | 1 for a turn that a Claude Code **subagent** (a fork) produced; folded into the parent session after the parent's own turns. Subagents are never separate sessions. |
+| `extra` | JSON. For a subagent turn: `extra.agent.id`, `extra.agent.description` (what the parent asked it to do, else the fork's own first prompt), `extra.agent.type` (`general-purpose`, `workflow-subagent`, …), `extra.agent.turn` (position within that subagent), and `extra.agent.workflow` (`wf_…`) when a Workflow run spawned it. Empty `{}` otherwise, and on rows shipped before 0.18.3. |
 | `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`, `cache_write_tokens` | usage; **empty for several adapters** — see below |
 | `text` | the turn, **truncated at 50,000 chars** |
 | `text_ngram`, `text_word` | `MATERIALIZED lower(text)`, carrying the text indexes |

package/memhouse/delivery/plugin/skills/recall/SKILL.md

@@ -112,6 +112,11 @@ Beyond the three in the reference:
 
 - **Ranking is yours.** There is no relevance score in the store. `hits` plus recency is
   the whole of it — say so rather than implying the top row is "the best match".
+- **A subagent (fork) is not a session.** Its turns are inside the parent session with
+  `is_subagent = 1` and `extra.agent.id` / `extra.agent.description` saying which one; the
+  reference has the two queries. "Find the fork that did X" → search `messages` as usual,
+  then group the hits by `toString(extra.agent.id)` — never conclude it was not shipped because no
+  session carries its name.
 - **Tool *results* are not stored.** "What did that command print" is unanswerable from
   the house; only the invocation and its arguments survive.
 - **`memhouse search`** exists as a CLI, but it joins your terms into ONE literal phrase

package/memhouse/house/house.js

@@ -306,6 +306,117 @@ function sessionsRollup({ sessions, messages }) {
   )`;
 }
 
+// The precomputed rollups' table names. One place, because the shipper that fills them,
+// the runtime probe and the read layer must all agree.
+const SESSION_STATS = 'session_stats';
+const MODEL_STATS = 'session_model_stats';
+const TOOL_STATS = 'session_tool_stats';
+// One-layout: like every room, a stat table is named for its member — `<member>_session_stats`
+// — so it sits under the same `<db>.<member>_*` grant the member already holds. No
+// database-level privilege exists in this layout, and none is needed.
+function statTableNames(member) {
+  return {
+    session_stats: physicalRoom(SESSION_STATS, member),
+    model_stats: physicalRoom(MODEL_STATS, member),
+    tool_stats: physicalRoom(TOOL_STATS, member),
+  };
+}
+
+/**
+ * The precomputed rollups — the tables the dashboard reads instead of rebuilding the
+ * session rollup on every query. Measured on a 714k-message house: 1,413,624 rows read
+ * per query became ~1,250, and a page load went from 4–10 seconds to ~250 ms.
+ *
+ * REFRESHED BY THE SHIPPER, NOT BY A MATERIALIZED VIEW — and that is forced, not chosen.
+ * The obvious tool is a refreshable materialized view (`REFRESH EVERY 5 MINUTE TO t`),
+ * which is exactly what the 0.17 line uses. It cannot exist in this layout: a refreshable
+ * view swaps its target atomically through a temporary table with a generated name, so
+ * ClickHouse demands `SELECT, INSERT, CREATE TABLE, DROP TABLE ON <db>.*` — the whole
+ * database — and a one-layout member holds `<db>.<member>_*` and nothing else, on
+ * purpose. Measured on 25.8: the CREATE is refused with exactly that message, and the
+ * grant that would satisfy it is the one this layout exists to withhold.
+ *
+ * (An ordinary insert-trigger MV is wrong for a different reason: it counts every
+ * ReplacingMergeTree version the merge has not collapsed yet, cannot see the epoch
+ * filter, and cannot join.)
+ *
+ * So the shipper runs the rollup itself, once at the end of every pass — the same
+ * cadence a view would have had — and INSERTs the result stamped with one
+ * `refreshed_at`. Every insert is a complete snapshot, a GENERATION; the read layer
+ * takes only the newest generation. Nothing is deleted, nothing is swapped, nothing
+ * needs a privilege beyond INSERT and SELECT on the member's own rooms. A TTL of one day
+ * keeps old generations from accumulating (288 a day at the default cadence), and the
+ * sorting key leads with `refreshed_at` so reading the newest one is one index range,
+ * not a scan.
+ *
+ * Built from the SAME rollup text the read layer would otherwise run, so the two
+ * cannot drift; column types are inferred with EMPTY AS for the same reason.
+ */
+const STAT_TTL = 'TTL toDateTime(refreshed_at) + INTERVAL 1 DAY';
+
+function statBodies(rooms) {
+  // sessionsRollup wraps itself in parentheses for the FROM position; strip them.
+  const rollup = sessionsRollup(rooms).replace(/^\s*\(/, '').replace(/\)\s*$/, '');
+  return {
+    session_stats: {
+      key: '(refreshed_at, session_id, user_id)',
+      body: rollup,
+    },
+    // One row per (session, user, model) with the message count and the four token sums.
+    // Every model/cost aggregate the dashboard runs is a sum or argMax over these rows —
+    // a few thousand — instead of a scan of the full messages room. The read layer's
+    // any-token predicates survive unchanged: a zero-token row contributes zero to every
+    // sum, so filtering before summing and summing over everything agree.
+    model_stats: {
+      key: '(refreshed_at, session_id, user_id, model)',
+      body: `SELECT session_id, user_id, any(source) AS source, any(folder) AS folder, model,
+       count() AS msgs,
+       sum(input_tokens) AS input_tokens, sum(output_tokens) AS output_tokens,
+       sum(cache_read_tokens) AS cache_read_tokens, sum(cache_write_tokens) AS cache_write_tokens
+FROM ${rooms.messages} AS m
+GROUP BY session_id, user_id, model`,
+    },
+    // One row per (session, user, tool_name) with the call count. NOTE the epoch source:
+    // rooms.tool_calls is currentParse(tool_calls, 'messages') — the tool room takes its
+    // epoch from MESSAGES, because a parse that keeps its messages but emits no tool calls
+    // writes nothing at the new epoch, and this room's own max(epoch) would resurrect the
+    // superseded parse's calls.
+    tool_stats: {
+      key: '(refreshed_at, session_id, user_id, tool_name)',
+      body: `SELECT session_id, user_id, any(source) AS source, any(folder) AS folder, tool_name,
+       count() AS calls
+FROM ${rooms.tool_calls} AS tc
+GROUP BY session_id, user_id, tool_name`,
+    },
+  };
+}
+
+/** The CREATE statements — additive, idempotent, run by ensureSchema. */
+function statCreateStatements(rooms) {
+  const names = statTableNames(rooms.member);
+  const bodies = statBodies(rooms);
+  return Object.keys(bodies).map((k) =>
+    `CREATE TABLE IF NOT EXISTS ${names[k]} ENGINE = MergeTree ORDER BY ${bodies[k].key} ${STAT_TTL} `
+    + `EMPTY AS SELECT now64(3) AS refreshed_at, * FROM (${bodies[k].body})`);
+}
+
+/**
+ * The refresh — one INSERT per table, one generation per call. All three carry the same
+ * `refreshed_at` so a reader never mixes a session_stats generation with a model_stats
+ * one. Run by the shipper after every pass and by --ensure-schema.
+ */
+function statRefreshStatements(rooms, at = 'now64(3)') {
+  const names = statTableNames(rooms.member);
+  const bodies = statBodies(rooms);
+  return Object.keys(bodies).map((k) =>
+    `INSERT INTO ${names[k]} SELECT ${at} AS refreshed_at, * FROM (${bodies[k].body})`);
+}
+
+/** The read-side source for one stat table: its newest generation, and nothing else. */
+function latestGeneration(table) {
+  return `(SELECT * FROM ${table} WHERE refreshed_at = (SELECT max(refreshed_at) FROM ${table}))`;
+}
+
 /**
  * The settings every read needs. `final` collapses ReplacingMergeTree versions;
  * `join_use_nulls` is what the rollup's coalesce depends on.
@@ -381,8 +492,67 @@ async function currentUser(client) {
 }
 
 /** Resolve the rooms for whoever this client is connected as. */
+/**
+ * The precomputed rollup, when the house has one.
+ *
+ * `sessions_v` is a SAVED QUERY that rebuilds the whole rollup — sessions FINAL joined
+ * to the current parse of messages, grouped over the entire house — on every call. A
+ * house that has run the session_stats migration carries the same rows as a flat table,
+ * refreshed on a timer, and the read layer can name that instead. Measured on a 714k
+ * message house: 1,413,624 rows read per query becomes 1,230, and p50 query time 68ms
+ * becomes 4ms.
+ *
+ * Resolved at RUNTIME rather than by version, and that is the point: one binary has to
+ * serve a migrated house, a house whose migration has not run, and a friend's house
+ * shared read-only that was never migrated at all. Asking the server what exists is the
+ * only answer that is correct in all three.
+ */
+async function statTables(client, member) {
+  const names = statTableNames(member);
+  const wanted = Object.values(names);
+  try {
+    const rs = await client.query({
+      query: `SELECT name FROM system.tables
+              WHERE database = currentDatabase()
+                AND name IN (${wanted.map((n) => `'${n}'`).join(', ')})`,
+      format: 'JSONEachRow',
+    });
+    const present = (await rs.json()).map((r) => r.name);
+    // Present is not enough: a table exists from the moment ensureSchema creates it and
+    // holds nothing until the first refresh lands. A dashboard reading it then would show
+    // a house with no sessions at all (caught by house-test the first time). An empty
+    // stat table reads as absent, so the inline rollup answers until the table can.
+    const usable = new Set();
+    for (const name of present) {
+      try {
+        const c = await client.query({ query: `SELECT count() AS n FROM ${name}`, format: 'JSONEachRow' });
+        const rows = await c.json();
+        if (Number(rows[0] && rows[0].n) > 0) usable.add(name);
+      } catch { /* unreadable: treat as absent */ }
+    }
+    return usable;
+  } catch {
+    // No grant on system.tables is not an error — it means "assume none", and the
+    // subquery path is always correct.
+    return new Set();
+  }
+}
+
+async function hasSessionStats(client, member) {
+  return (await statTables(client, member)).has(statTableNames(member).session_stats);
+}
+
 async function resolveRooms(client) {
-  return roomNames(await currentUser(client));
+  const rooms = roomNames(await currentUser(client));
+  const names = statTableNames(rooms.member);
+  const have = await statTables(client, rooms.member);
+  if (have.has(names.session_stats)) rooms.sessions_v = latestGeneration(names.session_stats);
+  // Null when absent: the read layer branches to the legacy scan-the-room SQL. Never a
+  // token substitution, because the legacy SQL has a different shape, not just a
+  // different table name.
+  rooms.model_stats = have.has(names.model_stats) ? latestGeneration(names.model_stats) : null;
+  rooms.tool_stats = have.has(names.tool_stats) ? latestGeneration(names.tool_stats) : null;
+  return rooms;
 }
 
 /**
@@ -426,4 +596,6 @@ module.exports = {
   READ_SETTINGS, MEMBER_PIN,
   installCommand, assertUsableName,
   sessionsRollup, currentParse, createStatement, roomNames, currentUser, resolveRooms,
+  SESSION_STATS, MODEL_STATS, TOOL_STATS, statTableNames, hasSessionStats, statTables,
+  statCreateStatements, statRefreshStatements, latestGeneration,
 };

package/memhouse/server/queries.js

@@ -140,6 +140,28 @@ function inSessions(f, col) {
   return ` AND (${alias}.session_id, ${alias}.user_id) IN (SELECT session_id, user_id FROM {{sessions_v}} AS c WHERE 1=1${f.and})`;
 }
 
+/**
+ * Narrow a query to an explicit set of (session_id, user_id) pairs.
+ *
+ * Distinct from inSessions(), which restricts to whatever the USER filtered to. This
+ * restricts to the rows a caller is actually going to use — the fifty sessions on the
+ * page, not the twelve hundred in the house.
+ *
+ * arrayZip, not two INs: the rooms are keyed on the PAIR, and matching the columns
+ * independently would pull in another member's rows for a colliding adapter-local
+ * session_id. Same idiom getDeepAnalytics already uses.
+ */
+function scopeAnd(scope, alias) {
+  if (!scope || !scope.ids || !scope.ids.length) return '';
+  const a = alias ? `${alias}.` : '';
+  return ` AND (${a}session_id, ${a}user_id) IN arrayZip({scopeIds:Array(String)}, {scopeUsers:Array(String)})`;
+}
+
+function scopeParams(f, scope) {
+  if (!scope || !scope.ids || !scope.ids.length) return f.params;
+  return { ...f.params, scopeIds: scope.ids, scopeUsers: scope.users };
+}
+
 // Fold a [{name|model, cnt}] list through normalizeModelName into a freq map.
 function normalizedModelFreq(rows) {
   const freq = {};
@@ -151,37 +173,52 @@ function normalizedModelFreq(rows) {
 }
 // The same exclusions as EXCLUDED_MODELS, usable in JS.
 const EXCLUDED_MODEL_SET = new Set(['', '<synthetic>']);
-const topN = (freq, n) => Object.entries(freq).sort((a, b) => b[1] - a[1]).slice(0, n)
+// Tiebreak on the name. A top-N cut over counts alone is not a total order: two tools
+// tied at the cut line resolve by arrival order, so the same house can show a different
+// tenth tool on consecutive loads. Same rule as getChats' ORDER BY tiebreaker.
+const topN = (freq, n) => Object.entries(freq).sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, n)
   .map(([name, count]) => ({ name, count }));
 
 // ── overview ────────────────────────────────────────────────────────────────────
 async function getOverview(opts = {}) {
   const f = filters(opts);
-  // Same definition as getChats(). The nav bar read this and the Sessions page read
-  // getChats, so a house with one placeholder session showed "9 sessions" beside
-  // "8 sessions" in the same header, and the depth histogram summed to 7. A session row
-  // with no name and no messages is a placeholder the shipper keeps to absorb the
-  // incremental skip; it is not a conversation, and only one of the two counters knew.
-  const totalChats = Number((await q1(
-    `SELECT count() AS cnt FROM {{sessions_v}} AS c WHERE 1=1${f.and} AND (c.name != '' OR c.total_msgs > 0)`,
-    f.params)).cnt);
-
-  // Root parity WAS: without a folder filter the editor breakdown is global — which put
-  // "34 + 3" chips under a header reading "3 sessions" when an editor filter was applied,
-  // and 12 under a header of 11 with no filter at all. Parity with a wrong number is not a
-  // feature.
-  const editors = await q(
-    `SELECT source, count() AS count FROM {{sessions_v}} AS c
-     WHERE (c.name != '' OR c.total_msgs > 0)${f.and} GROUP BY source ORDER BY count DESC`, f.params);
-
-  const modes = await q(`SELECT mode, count() AS count FROM {{sessions_v}} AS c WHERE mode != ''${f.and} GROUP BY mode`, f.params);
+  // Six independent reads, issued together. They share nothing but the filter, and every
+  // one of them is a full round trip: awaited in sequence they cost 6 x RTT before any
+  // result exists. Measured against a ClickHouse 6,000 km away, that sequencing — not the
+  // database — was roughly two thirds of what the browser waited for.
+  //
+  // The comments on each query below are the reasons its SHAPE is what it is; none of
+  // them is a reason for it to wait on the one above.
+  const [totalRow, editors, modes, rows, projects, range] = await Promise.all([
+    // Same definition as getChats(). The nav bar read this and the Sessions page read
+    // getChats, so a house with one placeholder session showed "9 sessions" beside
+    // "8 sessions" in the same header, and the depth histogram summed to 7. A session row
+    // with no name and no messages is a placeholder the shipper keeps to absorb the
+    // incremental skip; it is not a conversation, and only one of the two counters knew.
+    q1(`SELECT count() AS cnt FROM {{sessions_v}} AS c WHERE 1=1${f.and} AND (c.name != '' OR c.total_msgs > 0)`,
+      f.params),
+    // Root parity WAS: without a folder filter the editor breakdown is global — which put
+    // "34 + 3" chips under a header reading "3 sessions" when an editor filter was applied,
+    // and 12 under a header of 11 with no filter at all. Parity with a wrong number is not a
+    // feature.
+    q(`SELECT source, count() AS count FROM {{sessions_v}} AS c
+       WHERE (c.name != '' OR c.total_msgs > 0)${f.and} GROUP BY source ORDER BY count DESC`, f.params),
+    q(`SELECT mode, count() AS count FROM {{sessions_v}} AS c WHERE mode != ''${f.and} GROUP BY mode`, f.params),
+    q(`
+      SELECT formatDateTime(${TS}, '%Y-%m', 'UTC') AS month, source, count() AS count
+      FROM {{sessions_v}} AS c WHERE 1=1${f.and}
+      GROUP BY month, source ORDER BY month`, f.params),
+    q(`
+      SELECT folder, count() AS count FROM {{sessions_v}} AS c
+      WHERE folder != ''${f.and} GROUP BY folder ORDER BY count DESC LIMIT 20`, f.params),
+    q1(`SELECT min(${MS}) AS oldest, max(${MS}) AS newest FROM {{sessions_v}} AS c WHERE 1=1${f.and}`, f.params),
+  ]);
+
+  const totalChats = Number(totalRow.cnt);
+
   const byMode = {};
   for (const m of modes) byMode[m.mode] = Number(m.count);
 
-  const rows = await q(`
-    SELECT formatDateTime(${TS}, '%Y-%m', 'UTC') AS month, source, count() AS count
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and}
-    GROUP BY month, source ORDER BY month`, f.params);
   const monthMap = {};
   for (const r of rows) {
     if (!monthMap[r.month]) monthMap[r.month] = { count: 0, editors: {} };
@@ -190,17 +227,12 @@ async function getOverview(opts = {}) {
   }
   const byMonth = Object.keys(monthMap).sort().map(m => ({ month: m, ...monthMap[m] }));
 
-  const projects = await q(`
-    SELECT folder, count() AS count FROM {{sessions_v}} AS c
-    WHERE folder != ''${f.and} GROUP BY folder ORDER BY count DESC LIMIT 20`, f.params);
   const topProjects = projects.map(p => ({
     name: p.folder.split(/[/\\]/).slice(-2).join('/'),
     fullPath: p.folder,
     count: Number(p.count),
   }));
 
-  const range = await q1(`SELECT min(${MS}) AS oldest, max(${MS}) AS newest FROM {{sessions_v}} AS c WHERE 1=1${f.and}`, f.params);
-
   return {
     totalChats,
     editors: editors.map(e => ({ id: e.source, count: Number(e.count) })),
@@ -238,21 +270,62 @@ async function getDailyActivity(opts = {}) {
 async function getDashboardStats(opts = {}) {
   const f = filters(opts);
   const p = { ...f.params, tz: TZ };
+  const r = await rooms();
 
-  const hourlyRows = await q(`
+  // Nine independent reads, one round trip. Sequential, this endpoint paid 9 x RTT
+  // before any result existed — the largest fan-out on the dashboard. Each query's
+  // shape is unchanged; only the waiting is gone.
+  const [hourlyRows, weekdayRows, depthRows, tokenRow, streakRows,
+         monthEditorRows, velocityRows, modelRows, toolRows] = await Promise.all([
+    q(`
     SELECT toHour(${TS}, {tz:String}) AS hour, count() AS count
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and} GROUP BY hour ORDER BY hour`, p);
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and} GROUP BY hour ORDER BY hour`, p),
+    q(`
+    SELECT toDayOfWeek(${TS}, 0, {tz:String}) % 7 AS dow, count() AS count
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and} GROUP BY dow ORDER BY dow`, p),
+    q(`
+    SELECT total_msgs AS msgs FROM {{sessions_v}} AS c WHERE total_msgs > 0${f.and}`, f.params),
+    q1(`
+    SELECT COALESCE(sum(input_tokens), 0) AS input, COALESCE(sum(output_tokens), 0) AS output,
+           COALESCE(sum(cache_read_tokens), 0) AS cacheRead, COALESCE(sum(cache_write_tokens), 0) AS cacheWrite,
+           COALESCE(sum(user_chars), 0) AS userChars, COALESCE(sum(assistant_chars), 0) AS assistantChars,
+           COALESCE(sum(total_msgs), 0) AS messages,
+           -- The SAME definition the KPI beside it uses. A plain count() here put a
+           -- fourth session number on a screen that already had three: nav 11, chips 12,
+           -- avg depth 40/12, histogram 10.
+           countIf(c.name != '' OR c.total_msgs > 0) AS sessions
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and}`, f.params),
+    q(`
+    SELECT DISTINCT formatDateTime(${TS}, '%Y-%m-%d', {tz:String}) AS day
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and} ORDER BY day`, p),
+    q(`
+    SELECT formatDateTime(${TS}, '%Y-%m', 'UTC') AS month, source, count() AS count
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and} GROUP BY month, source ORDER BY month`, f.params),
+    q(`
+    SELECT formatDateTime(c.last_updated_at, '%Y-%m', 'UTC') AS month,
+           avg(total_msgs) AS avgMsgs, avg(input_tokens + output_tokens) AS avgTokens
+    FROM {{sessions_v}} AS c WHERE c.last_updated_at IS NOT NULL${f.and}
+    GROUP BY month ORDER BY month`, f.params),
+    q(r.model_stats ? `
+    SELECT m.model AS model, sum(m.msgs) AS cnt FROM {{model_stats}} AS m
+    WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
+    GROUP BY model` : `
+    SELECT m.model AS model, count() AS cnt FROM {{messages}} AS m
+    WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
+    GROUP BY model`, f.params),
+    q(r.tool_stats ? `
+    SELECT tool_name, sum(tc.calls) AS cnt FROM {{tool_stats}} AS tc
+    WHERE 1=1${inSessions(f, 'tc.session_id')} GROUP BY tool_name` : `
+    SELECT tool_name, count() AS cnt FROM {{tool_calls}} AS tc
+    WHERE 1=1${inSessions(f, 'tc.session_id')} GROUP BY tool_name`, f.params),
+  ]);
+
   const hourly = new Array(24).fill(0);
   for (const r of hourlyRows) hourly[Number(r.hour)] = Number(r.count);
 
-  const weekdayRows = await q(`
-    SELECT toDayOfWeek(${TS}, 0, {tz:String}) % 7 AS dow, count() AS count
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and} GROUP BY dow ORDER BY dow`, p);
   const weekdays = new Array(7).fill(0);
   for (const r of weekdayRows) weekdays[Number(r.dow)] = Number(r.count);
 
-  const depthRows = await q(`
-    SELECT total_msgs AS msgs FROM {{sessions_v}} AS c WHERE total_msgs > 0${f.and}`, f.params);
   const depthBuckets = { '1': 0, '2-5': 0, '6-10': 0, '11-20': 0, '21-50': 0, '51-100': 0, '100+': 0 };
   for (const r of depthRows) {
     const m = Number(r.msgs);
@@ -265,20 +338,6 @@ async function getDashboardStats(opts = {}) {
     else depthBuckets['100+']++;
   }
 
-  const tokenRow = await q1(`
-    SELECT COALESCE(sum(input_tokens), 0) AS input, COALESCE(sum(output_tokens), 0) AS output,
-           COALESCE(sum(cache_read_tokens), 0) AS cacheRead, COALESCE(sum(cache_write_tokens), 0) AS cacheWrite,
-           COALESCE(sum(user_chars), 0) AS userChars, COALESCE(sum(assistant_chars), 0) AS assistantChars,
-           COALESCE(sum(total_msgs), 0) AS messages,
-           -- The SAME definition the KPI beside it uses. A plain count() here put a
-           -- fourth session number on a screen that already had three: nav 11, chips 12,
-           -- avg depth 40/12, histogram 10.
-           countIf(c.name != '' OR c.total_msgs > 0) AS sessions
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and}`, f.params);
-
-  const streakRows = await q(`
-    SELECT DISTINCT formatDateTime(${TS}, '%Y-%m-%d', {tz:String}) AS day
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and} ORDER BY day`, p);
   let currentStreak = 0, longestStreak = 0, tempStreak = 1;
   const today = new Date().toISOString().split('T')[0];
   for (let i = 1; i < streakRows.length; i++) {
@@ -299,9 +358,6 @@ async function getDashboardStats(opts = {}) {
   }
   if (streakRows.length === 0) longestStreak = 0;
 
-  const monthEditorRows = await q(`
-    SELECT formatDateTime(${TS}, '%Y-%m', 'UTC') AS month, source, count() AS count
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and} GROUP BY month, source ORDER BY month`, f.params);
   const monthEditors = {};
   const allSources = new Set();
   for (const r of monthEditorRows) {
@@ -310,21 +366,8 @@ async function getDashboardStats(opts = {}) {
     allSources.add(r.source);
   }
 
-  const velocityRows = await q(`
-    SELECT formatDateTime(c.last_updated_at, '%Y-%m', 'UTC') AS month,
-           avg(total_msgs) AS avgMsgs, avg(input_tokens + output_tokens) AS avgTokens
-    FROM {{sessions_v}} AS c WHERE c.last_updated_at IS NOT NULL${f.and}
-    GROUP BY month ORDER BY month`, f.params);
-
-  const modelRows = await q(`
-    SELECT m.model AS model, count() AS cnt FROM {{messages}} AS m
-    WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
-    GROUP BY model`, f.params);
   const topModels = topN(normalizedModelFreq(modelRows), 10);
 
-  const toolRows = await q(`
-    SELECT tool_name, count() AS cnt FROM {{tool_calls}} AS tc
-    WHERE 1=1${inSessions(f, 'tc.session_id')} GROUP BY tool_name`, f.params);
   let totalToolCalls = 0;
   const toolFreq = {};
   for (const r of toolRows) { toolFreq[r.tool_name] = Number(r.cnt); totalToolCalls += Number(r.cnt); }
@@ -373,7 +416,13 @@ async function getChats(opts = {}) {
     FROM {{sessions_v}} AS c WHERE 1=1${f.and}`;
   const params = { ...f.params };
   if (opts.named !== false) sql += " AND (c.name != '' OR c.total_msgs > 0)";
-  sql += ` ORDER BY ${MS} DESC`;
+  // Tiebreak on the session key. `ORDER BY <ts> DESC` alone is not a total order —
+  // sessions that stopped in the same millisecond tie, and ClickHouse is free to return
+  // ties in any order, INCLUDING A DIFFERENT ONE PER QUERY. With LIMIT/OFFSET on top,
+  // that means page 2 can repeat or skip a row that page 1 already showed. Found by
+  // diffing this endpoint's response between two equivalent sources: identical rows,
+  // different order, 129 distinct timestamps across 300 sessions.
+  sql += ` ORDER BY ${MS} DESC, c.session_id, c.user_id`;
   if (opts.limit) { sql += ' LIMIT {limit:UInt64}'; params.limit = opts.limit; }
   if (opts.offset) { sql += ' OFFSET {offset:UInt64}'; params.offset = opts.offset; }
   const rows = await q(sql, params);
@@ -388,7 +437,13 @@ async function getChats(opts = {}) {
   // and left the next one. computePerChatCosts already handles all of them — the orphan
   // bucket, the source-dominant and global-dominant fallbacks, the char estimate — so call
   // it instead of growing a second copy of the same logic.
-  const perChat = await computePerChatCosts(f);
+  // Price the fifty rows on the page, not the twelve hundred in the house. This query
+  // set was the most expensive thing the dashboard ran — 1,413,624 rows read and 272 MiB
+  // per call, three endpoints calling it — and getChats used ~4% of what it asked for.
+  const perChat = await computePerChatCosts(f, {
+    ids: rows.map((r) => String(r.id)),
+    users: rows.map((r) => String(r.user_id)),
+  });
   const costBySession = {};
   const topModelBySession = {};
   for (const r of perChat) {
@@ -455,14 +510,15 @@ async function getChat(id) {
   // Sessions are keyed (session_id, user_id): constrain the row reloads to the
   // selected rollup's writer, or an owner/no-RLS reader viewing a house where two
   // members share an adapter-local session_id would see their rows merged.
-  const messages = await q(`
+  const [messages, toolCalls] = await Promise.all([
+    q(`
     SELECT role, text AS content, model, input_tokens, output_tokens
     FROM {{messages}} WHERE session_id = {cid:String} AND user_id = {uid:String} ORDER BY seq`,
-    { cid: chat.id, uid: chat.user_id });
-
-  const toolCalls = await q(`
+      { cid: chat.id, uid: chat.user_id }),
+    q(`
     SELECT tool_name, args FROM {{tool_calls}} WHERE session_id = {cid:String} AND user_id = {uid:String} ORDER BY idx`,
-    { cid: chat.id, uid: chat.user_id });
+      { cid: chat.id, uid: chat.user_id }),
+  ]);
   const toolCallDetails = toolCalls.map(tc => ({ name: tc.tool_name, args: safeParseJson(tc.args) }));
 
   let toolMessages = 0, systemMessages = 0;
@@ -498,15 +554,37 @@ async function getChat(id) {
 
 // ── projects ────────────────────────────────────────────────────────────────────
 async function getProjects(opts = {}) {
+  const r = await rooms();
   const df = filters({
     hiddenFolders: opts.includeHidden ? [] : opts.hiddenFolders,
     dateFrom: opts.dateFrom, dateTo: opts.dateTo,
   });
 
-  const perSource = await q(`
+  // Four independent reads, one round trip.
+  const [perSource, sums, modelRows, toolRows] = await Promise.all([
+    q(`
     SELECT folder, source, count() AS count, min(${MS}) AS first_seen, max(${MS}) AS last_seen
     FROM {{sessions_v}} AS c WHERE folder != ''${df.and}
-    GROUP BY folder, source ORDER BY folder, count DESC`, df.params);
+    GROUP BY folder, source ORDER BY folder, count DESC`, df.params),
+    q(`
+    SELECT folder, sum(total_msgs) AS totalMessages,
+           sum(input_tokens) AS totalInputTokens, sum(output_tokens) AS totalOutputTokens,
+           sum(user_chars) AS totalUserChars, sum(assistant_chars) AS totalAssistantChars,
+           sum(cache_read_tokens) AS totalCacheRead, sum(cache_write_tokens) AS totalCacheWrite
+    FROM {{sessions_v}} AS c WHERE folder != ''${df.and} GROUP BY folder`, df.params),
+    q(r.model_stats ? `
+    SELECT m.folder AS folder, m.model AS model, sum(m.msgs) AS cnt FROM {{model_stats}} AS m
+    WHERE m.folder != '' AND m.model NOT IN ${EXCLUDED_MODELS}${inSessions(df, 'm.session_id')}
+    GROUP BY folder, model` : `
+    SELECT m.folder AS folder, m.model AS model, count() AS cnt FROM {{messages}} AS m
+    WHERE m.folder != '' AND m.model NOT IN ${EXCLUDED_MODELS}${inSessions(df, 'm.session_id')}
+    GROUP BY folder, model`, df.params),
+    q(r.tool_stats ? `
+    SELECT tc.folder AS folder, tc.tool_name AS tool_name, sum(tc.calls) AS cnt FROM {{tool_stats}} AS tc
+    WHERE tc.folder != ''${inSessions(df, 'tc.session_id')} GROUP BY folder, tool_name` : `
+    SELECT tc.folder AS folder, tc.tool_name AS tool_name, count() AS cnt FROM {{tool_calls}} AS tc
+    WHERE tc.folder != ''${inSessions(df, 'tc.session_id')} GROUP BY folder, tool_name`, df.params),
+  ]);
 
   const map = {};
   for (const r of perSource) {
@@ -517,19 +595,9 @@ async function getProjects(opts = {}) {
     if (r.last_seen != null && r.last_seen > map[r.folder].lastSeen) map[r.folder].lastSeen = r.last_seen;
   }
 
-  const sums = await q(`
-    SELECT folder, sum(total_msgs) AS totalMessages,
-           sum(input_tokens) AS totalInputTokens, sum(output_tokens) AS totalOutputTokens,
-           sum(user_chars) AS totalUserChars, sum(assistant_chars) AS totalAssistantChars,
-           sum(cache_read_tokens) AS totalCacheRead, sum(cache_write_tokens) AS totalCacheWrite
-    FROM {{sessions_v}} AS c WHERE folder != ''${df.and} GROUP BY folder`, df.params);
   const sumByFolder = {};
   for (const r of sums) sumByFolder[r.folder] = r;
 
-  const modelRows = await q(`
-    SELECT m.folder AS folder, m.model AS model, count() AS cnt FROM {{messages}} AS m
-    WHERE m.folder != '' AND m.model NOT IN ${EXCLUDED_MODELS}${inSessions(df, 'm.session_id')}
-    GROUP BY folder, model`, df.params);
   const modelsByFolder = {};
   for (const r of modelRows) {
     const k = normalizeModelName(r.model) || r.model;
@@ -537,9 +605,6 @@ async function getProjects(opts = {}) {
     modelsByFolder[r.folder][k] = (modelsByFolder[r.folder][k] || 0) + Number(r.cnt);
   }
 
-  const toolRows = await q(`
-    SELECT tc.folder AS folder, tc.tool_name AS tool_name, count() AS cnt FROM {{tool_calls}} AS tc
-    WHERE tc.folder != ''${inSessions(df, 'tc.session_id')} GROUP BY folder, tool_name`, df.params);
   const toolsByFolder = {};
   for (const r of toolRows) {
     if (!toolsByFolder[r.folder]) toolsByFolder[r.folder] = {};
@@ -582,7 +647,7 @@ async function getDeepAnalytics(opts = {}) {
   let sql = `
     SELECT c.session_id AS id, c.user_id AS user_id, c.total_msgs AS msgs, c.user_chars AS uc, c.assistant_chars AS ac,
            c.input_tokens AS ti, c.output_tokens AS to_, c.cache_read_tokens AS cr, c.cache_write_tokens AS cw
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and} ORDER BY ${MS} DESC`;
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and} ORDER BY ${MS} DESC, c.session_id, c.user_id`;
   const params = { ...f.params };
   if (opts.limit) { sql += ' LIMIT {limit:UInt64}'; params.limit = opts.limit; }
   const rows = await q(sql, params);
@@ -606,18 +671,26 @@ async function getDeepAnalytics(opts = {}) {
   let topTools = [], topModels = [], totalToolCalls = 0;
   if (ids.length > 0) {
     const pairs = { ids, users };
-    const toolRows = await q(`
+    const r = await rooms();
+    const [toolRows, modelRows] = await Promise.all([
+      q(r.tool_stats ? `
+      SELECT tool_name, sum(calls) AS cnt FROM {{tool_stats}}
+      WHERE (session_id, user_id) IN arrayZip({ids:Array(String)}, {users:Array(String)})
+      GROUP BY tool_name` : `
       SELECT tool_name, count() AS cnt FROM {{tool_calls}}
       WHERE (session_id, user_id) IN arrayZip({ids:Array(String)}, {users:Array(String)})
-      GROUP BY tool_name`, pairs);
+      GROUP BY tool_name`, pairs),
+      q(r.model_stats ? `
+      SELECT model, sum(msgs) AS cnt FROM {{model_stats}}
+      WHERE (session_id, user_id) IN arrayZip({ids:Array(String)}, {users:Array(String)})
+        AND model NOT IN ${EXCLUDED_MODELS} GROUP BY model` : `
+      SELECT model, count() AS cnt FROM {{messages}}
+      WHERE (session_id, user_id) IN arrayZip({ids:Array(String)}, {users:Array(String)})
+        AND model NOT IN ${EXCLUDED_MODELS} GROUP BY model`, pairs),
+    ]);
     const toolFreq = {};
     for (const r of toolRows) { toolFreq[r.tool_name] = Number(r.cnt); totalToolCalls += Number(r.cnt); }
     topTools = topN(toolFreq, 30);
-
-    const modelRows = await q(`
-      SELECT model, count() AS cnt FROM {{messages}}
-      WHERE (session_id, user_id) IN arrayZip({ids:Array(String)}, {users:Array(String)})
-        AND model NOT IN ${EXCLUDED_MODELS} GROUP BY model`, pairs);
     topModels = topN(normalizedModelFreq(modelRows), 20);
   }
 
@@ -674,13 +747,19 @@ async function getToolCalls(toolName, opts = {}) {
 const ORPHAN_TOKENS = '(m.input_tokens > 0 OR m.output_tokens > 0 OR m.cache_read_tokens > 0 OR m.cache_write_tokens > 0)';
 
 // session_id → dominant model (most frequent across the session's messages).
-async function sessionDominantMap(f) {
-  const rows = await q(`
+async function sessionDominantMap(f, scope = null) {
+  // model_stats already holds one row per (session, model) with the message count —
+  // argMax over a few thousand pre-aggregated rows instead of a scan of the room.
+  const r = await rooms();
+  const rows = await q(r.model_stats ? `
+    SELECT session_id, user_id, argMax(model, msgs) AS dominant
+    FROM {{model_stats}} AS m WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}${scopeAnd(scope, 'm')}
+    GROUP BY session_id, user_id` : `
     SELECT session_id, user_id, argMax(model, cnt) AS dominant
     FROM (SELECT m.session_id AS session_id, m.user_id AS user_id, m.model AS model, count() AS cnt
-          FROM {{messages}} AS m WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
+          FROM {{messages}} AS m WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}${scopeAnd(scope, 'm')}
           GROUP BY session_id, user_id, model)
-    GROUP BY session_id, user_id`, f.params);
+    GROUP BY session_id, user_id`, scopeParams(f, scope));
   const map = {};
   for (const r of rows) map[`${r.session_id}::${r.user_id}`] = r.dominant;
   return map;
@@ -688,7 +767,11 @@ async function sessionDominantMap(f) {
 
 // source → dominant model + global dominant (for sessions with tokens but no model).
 async function sourceDominantMap(f) {
-  const rows = await q(`
+  const r = await rooms();
+  const rows = await q(r.model_stats ? `
+    SELECT m.source AS source, m.model AS model, sum(m.msgs) AS cnt
+    FROM {{model_stats}} AS m WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
+    GROUP BY source, model` : `
     SELECT m.source AS source, m.model AS model, count() AS cnt
     FROM {{messages}} AS m WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
     GROUP BY source, model`, f.params);
@@ -709,21 +792,50 @@ const CHARS_PER_TOKEN = 4;
 async function estimateCosts(opts = {}) {
   const f = filters(opts, { editorLike: true });
 
-  const modelTokens = await q(`
+  // Five independent reads, one round trip. sourceDominantMap stays lazy below — it is
+  // only needed when unmodeled sessions exist, which most passes have none of.
+  //
+  // The ORPHAN_TOKENS predicate is dropped on the model_stats path on purpose: it
+  // filtered individual message rows to any-token ones before summing, and a row with
+  // zero tokens contributes zero to every sum — the predicate saved work, never changed
+  // a number. The stat rows are already summed, so there is no work left to save.
+  const r = await rooms();
+  const [modelTokens, orphanRows, dominantMap, charRows, unmodeledRows] = await Promise.all([
+    q(r.model_stats ? `
+    SELECT m.model AS model, sum(m.input_tokens) AS input, sum(m.output_tokens) AS output,
+           sum(m.cache_read_tokens) AS cacheRead, sum(m.cache_write_tokens) AS cacheWrite
+    FROM {{model_stats}} AS m
+    WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
+    GROUP BY model` : `
     SELECT m.model AS model, sum(m.input_tokens) AS input, sum(m.output_tokens) AS output,
            sum(m.cache_read_tokens) AS cacheRead, sum(m.cache_write_tokens) AS cacheWrite
     FROM {{messages}} AS m
     WHERE m.model NOT IN ${EXCLUDED_MODELS} AND ${ORPHAN_TOKENS}${inSessions(f, 'm.session_id')}
-    GROUP BY model`, f.params);
-
-  const orphanRows = await q(`
+    GROUP BY model`, f.params),
+    q(r.model_stats ? `
+    SELECT m.session_id AS session_id, m.user_id AS user_id, sum(m.input_tokens) AS input, sum(m.output_tokens) AS output,
+           sum(m.cache_read_tokens) AS cacheRead, sum(m.cache_write_tokens) AS cacheWrite
+    FROM {{model_stats}} AS m
+    WHERE m.model IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}
+    GROUP BY session_id, user_id
+    HAVING sum(m.input_tokens) > 0 OR sum(m.output_tokens) > 0 OR sum(m.cache_read_tokens) > 0 OR sum(m.cache_write_tokens) > 0` : `
     SELECT m.session_id AS session_id, m.user_id AS user_id, sum(m.input_tokens) AS input, sum(m.output_tokens) AS output,
            sum(m.cache_read_tokens) AS cacheRead, sum(m.cache_write_tokens) AS cacheWrite
     FROM {{messages}} AS m
     WHERE m.model IN ${EXCLUDED_MODELS} AND ${ORPHAN_TOKENS}${inSessions(f, 'm.session_id')}
-    GROUP BY session_id, user_id`, f.params);
-
-  const dominantMap = await sessionDominantMap(f);
+    GROUP BY session_id, user_id`, f.params),
+    sessionDominantMap(f),
+    q(`
+    SELECT c.session_id AS session_id, c.user_id AS user_id, c.user_chars AS userChars, c.assistant_chars AS asstChars
+    FROM {{sessions_v}} AS c
+    WHERE notEmpty(c.models) AND c.input_tokens = 0 AND c.output_tokens = 0
+      AND (c.user_chars > 0 OR c.assistant_chars > 0)${f.and}`, f.params),
+    q(`
+    SELECT c.source AS source, c.input_tokens AS input, c.output_tokens AS output,
+           c.cache_read_tokens AS cacheRead, c.cache_write_tokens AS cacheWrite
+    FROM {{sessions_v}} AS c
+    WHERE empty(c.models) AND (c.input_tokens > 0 OR c.output_tokens > 0)${f.and}`, f.params),
+  ]);
 
   const orphanByModel = {};
   const addOrphan = (dominant, input, output, cacheRead, cacheWrite) => {
@@ -739,22 +851,12 @@ async function estimateCosts(opts = {}) {
   }
 
   // Sessions that name models but report zero tokens → estimate from chars.
-  const charRows = await q(`
-    SELECT c.session_id AS session_id, c.user_id AS user_id, c.user_chars AS userChars, c.assistant_chars AS asstChars
-    FROM {{sessions_v}} AS c
-    WHERE notEmpty(c.models) AND c.input_tokens = 0 AND c.output_tokens = 0
-      AND (c.user_chars > 0 OR c.assistant_chars > 0)${f.and}`, f.params);
   for (const r of charRows) {
     const dominant = dominantMap[`${r.session_id}::${r.user_id}`];
     if (dominant) addOrphan(dominant, Math.round((Number(r.userChars) || 0) / CHARS_PER_TOKEN), Math.round((Number(r.asstChars) || 0) / CHARS_PER_TOKEN), 0, 0);
   }
 
   // Sessions with tokens but NO model at all → the source's dominant model.
-  const unmodeledRows = await q(`
-    SELECT c.source AS source, c.input_tokens AS input, c.output_tokens AS output,
-           c.cache_read_tokens AS cacheRead, c.cache_write_tokens AS cacheWrite
-    FROM {{sessions_v}} AS c
-    WHERE empty(c.models) AND (c.input_tokens > 0 OR c.output_tokens > 0)${f.and}`, f.params);
   if (unmodeledRows.length > 0) {
     const { sourceDominant, globalDominant } = await sourceDominantMap(f);
     for (const r of unmodeledRows) {
@@ -792,26 +894,43 @@ async function estimateCosts(opts = {}) {
 
 // Per-session cost attribution in a FIXED number of bulk queries (no per-session
 // round-trips). Mirrors root computePerChatCosts.
-async function computePerChatCosts(f) {
-  const aRows = await q(`
+/**
+ * @param {object} f      the user's filter
+ * @param {object|null} scope  {ids, users} — the sessions the caller will actually use.
+ *   getChats passes the page it just fetched; the cost pages pass nothing, because they
+ *   are pricing the whole house on purpose.
+ */
+async function computePerChatCosts(f, scope = null) {
+  const p = scopeParams(f, scope);
+  const r = await rooms();
+  // Five independent reads, one round trip. This function is called by three endpoints;
+  // sequential, it alone cost 5 x RTT per call. On the model_stats path the ORPHAN
+  // predicate is dropped/HAVINGed for the reason written in estimateCosts.
+  const [aRows, bRows, cRows, dominantMap, sourceDominants] = await Promise.all([
+    q(r.model_stats ? `
+    SELECT m.session_id AS session_id, m.user_id AS user_id, m.model AS model, sum(m.input_tokens) AS i, sum(m.output_tokens) AS o,
+           sum(m.cache_read_tokens) AS cr, sum(m.cache_write_tokens) AS cw
+    FROM {{model_stats}} AS m
+    WHERE m.model NOT IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}${scopeAnd(scope, 'm')}
+    GROUP BY session_id, user_id, model` : `
     SELECT m.session_id AS session_id, m.user_id AS user_id, m.model AS model, sum(m.input_tokens) AS i, sum(m.output_tokens) AS o,
            sum(m.cache_read_tokens) AS cr, sum(m.cache_write_tokens) AS cw
     FROM {{messages}} AS m
-    WHERE m.model NOT IN ${EXCLUDED_MODELS} AND ${ORPHAN_TOKENS}${inSessions(f, 'm.session_id')}
-    GROUP BY session_id, user_id, model`, f.params);
-  const byChatModel = {};
-  for (const r of aRows) { const k = `${r.session_id}::${r.user_id}`; (byChatModel[k] = byChatModel[k] || []).push(r); }
-
-  const bRows = await q(`
+    WHERE m.model NOT IN ${EXCLUDED_MODELS} AND ${ORPHAN_TOKENS}${inSessions(f, 'm.session_id')}${scopeAnd(scope, 'm')}
+    GROUP BY session_id, user_id, model`, p),
+    q(r.model_stats ? `
+    SELECT m.session_id AS session_id, m.user_id AS user_id, sum(m.input_tokens) AS i, sum(m.output_tokens) AS o,
+           sum(m.cache_read_tokens) AS cr, sum(m.cache_write_tokens) AS cw
+    FROM {{model_stats}} AS m
+    WHERE m.model IN ${EXCLUDED_MODELS}${inSessions(f, 'm.session_id')}${scopeAnd(scope, 'm')}
+    GROUP BY session_id, user_id
+    HAVING sum(m.input_tokens) > 0 OR sum(m.output_tokens) > 0 OR sum(m.cache_read_tokens) > 0 OR sum(m.cache_write_tokens) > 0` : `
     SELECT m.session_id AS session_id, m.user_id AS user_id, sum(m.input_tokens) AS i, sum(m.output_tokens) AS o,
            sum(m.cache_read_tokens) AS cr, sum(m.cache_write_tokens) AS cw
     FROM {{messages}} AS m
-    WHERE m.model IN ${EXCLUDED_MODELS} AND ${ORPHAN_TOKENS}${inSessions(f, 'm.session_id')}
-    GROUP BY session_id, user_id`, f.params);
-  const orphanByChat = {};
-  for (const r of bRows) orphanByChat[`${r.session_id}::${r.user_id}`] = r;
-
-  const cRows = await q(`
+    WHERE m.model IN ${EXCLUDED_MODELS} AND ${ORPHAN_TOKENS}${inSessions(f, 'm.session_id')}${scopeAnd(scope, 'm')}
+    GROUP BY session_id, user_id`, p),
+    q(`
     SELECT c.session_id AS id, c.user_id AS user_id, c.source AS source, c.name AS name, c.folder AS folder,
            toUnixTimestamp64Milli(c.last_updated_at) AS last_updated_at,
            toUnixTimestamp64Milli(c.created_at) AS created_at,
@@ -820,10 +939,22 @@ async function computePerChatCosts(f) {
            c.input_tokens AS ti, c.output_tokens AS to_,
            c.cache_read_tokens AS cr, c.cache_write_tokens AS cw,
            formatDateTime(${TS}, '%Y-%m', 'UTC') AS month
-    FROM {{sessions_v}} AS c WHERE 1=1${f.and}`, f.params);
+    FROM {{sessions_v}} AS c WHERE 1=1${f.and}${scopeAnd(scope, 'c')}`, p),
+    sessionDominantMap(f, scope),
+    // NOT scoped, deliberately. This is the house-wide "which model does this editor
+    // usually run", used to price sessions that recorded no model at all. Computed from
+    // the fifty rows on the page it would answer differently on page 1 than on page 2,
+    // and the same session would report a different cost depending on where it was read.
+    // Its scope is the user's FILTER, which is what it has always been.
+    sourceDominantMap(f),
+  ]);
+  const { sourceDominant, globalDominant } = sourceDominants;
 
-  const dominantMap = await sessionDominantMap(f);
-  const { sourceDominant, globalDominant } = await sourceDominantMap(f);
+  const byChatModel = {};
+  for (const r of aRows) { const k = `${r.session_id}::${r.user_id}`; (byChatModel[k] = byChatModel[k] || []).push(r); }
+
+  const orphanByChat = {};
+  for (const r of bRows) orphanByChat[`${r.session_id}::${r.user_id}`] = r;
 
   const out = [];
   for (const c of cRows) {
@@ -868,8 +999,7 @@ async function computePerChatCosts(f) {
 
 async function getCostAnalytics(opts = {}) {
   const f = filters(opts, { editorLike: true });
-  const overall = await estimateCosts(opts);
-  const perChat = await computePerChatCosts(f);
+  const [overall, perChat] = await Promise.all([estimateCosts(opts), computePerChatCosts(f)]);
 
   const editorAgg = {}, projectAgg = {}, monthCosts = {};
   const sessionCosts = [];
@@ -893,7 +1023,11 @@ async function getCostAnalytics(opts = {}) {
   const byEditor = Object.entries(editorAgg).map(([editor, d]) => ({ editor, cost: d.cost, models: d.models.size })).sort((a, b) => b.cost - a.cost);
   const byProject = Object.entries(projectAgg).map(([folder, cost]) => ({ folder, name: folder.split('/').pop(), cost })).sort((a, b) => b.cost - a.cost).slice(0, 20);
   const monthly = Object.entries(monthCosts).sort((a, b) => a[0].localeCompare(b[0])).map(([month, d]) => ({ month, cost: Math.round(d.cost * 100) / 100, sessions: d.sessions }));
-  sessionCosts.sort((a, b) => b.cost - a.cost);
+  // Same total-order rule as getChats: a top-50 cut over ties must not depend on the
+  // order the rows happened to arrive in. Every session in a synthetic house costs the
+  // same, and the list changed identity between two equivalent sources without a
+  // secondary key.
+  sessionCosts.sort((a, b) => (b.cost - a.cost) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
 
   const totalSessions = sessionCosts.length;
   const avgPerSession = totalSessions > 0 ? overall.totalCost / totalSessions : 0;

package/memhouse/shipper/ship.js

@@ -62,7 +62,9 @@ const selfUpdate = require('../self-update');
 const selfSnap = selfUpdate.snapshot(__filename);
 const {
   resolveRooms, READ_SETTINGS, ROOM_TYPES, META_TYPES, SCHEMA_VERSION, MEMBER_PIN, createStatement,
-  SUPPORTED_SCHEMAS, keyProblem, legacyTextIndexDialect, isTextIndexGrammarRefusal, textIndexDialectFor } = require('../house/house');
+  SUPPORTED_SCHEMAS, keyProblem, legacyTextIndexDialect, isTextIndexGrammarRefusal, textIndexDialectFor,
+  statCreateStatements, statRefreshStatements, statTableNames,
+} = require('../house/house');
 // Rooms plus the house's own record of itself. Every table the template declares, which
 // is what the column healer and the drift warning have to cover — a column added to
 // events would otherwise roll out to nobody.
@@ -463,6 +465,24 @@ async function ensureSchema(client) {
       throw e;
     }
   }
+  // The precomputed rollups — additive, so they belong here and not in a migration (see
+  // migrate.js's rule). Three plain tables the shipper fills after every pass; the read
+  // layer probes for them at startup and falls back to the inline rollup when they are
+  // absent or empty, so a denied CREATE here degrades to slow, never to wrong. Why they
+  // are shipper-filled and not materialized views: house.js, above statBodies.
+  for (const q of statCreateStatements(rooms)) {
+    try {
+      await client.command({ query: q, clickhouse_settings: { async_insert: 0 } });
+    } catch (e) {
+      const m = e && e.message ? e.message : String(e);
+      if (/Not enough privileges|ACCESS_DENIED/i.test(m)) { denied++; continue; }
+      if (/ALREADY_EXISTS|already exists/i.test(m)) { continue; }
+      throw e;
+    }
+  }
+  // First generation now, so install and update are fast at once instead of after the
+  // next pass. Best effort: a denied CREATE above means these fail too, quietly.
+  await refreshStats(client, rooms);
   if (denied) {
     // In a SHARED house this is the designed state, not a shortfall: the operator creates
     // each member's rooms during `invite` precisely so the member cannot — a member who
@@ -903,8 +923,11 @@ function rowsForChat(chat, host) {
       text,
       project,
       folder,
-      is_subagent: text.startsWith('[subagent]'),
-      extra: {},
+      is_subagent: text.startsWith('[subagent]') || Boolean(m._agent),
+      // Which subagent (Claude Code fork) a folded turn belongs to — id, the description
+      // the parent gave it, its type, and the turn's position within that subagent — so
+      // one fork's transcript is `WHERE extra.agent.id = '…' ORDER BY seq`. Not hashed.
+      extra: m._agent ? { agent: { id: String(m._agent.id || ''), description: String(m._agent.description || ''), type: String(m._agent.type || ''), turn: Number(m._agent.turn) || 0, ...(m._agent.workflow ? { workflow: String(m._agent.workflow) } : {}) } } : {},
     };
     // Hash the content fields only (not ts — it is synthesized and may drift).
     row.line_hash = lineHash({
@@ -1051,6 +1074,38 @@ async function loadStoredParse(client, rooms, id, uid, epoch) {
   return { hashes, tools };
 }
 
+/**
+ * Recompute the three stat tables — one generation, one INSERT each, all stamped with the
+ * same refreshed_at. Runs at the end of every ship pass, which is exactly the cadence a
+ * refreshable view would have had, and after --ensure-schema. Best effort: a house whose
+ * tables were never created (a denied CREATE) fails every INSERT here, and the read layer
+ * is already on the inline rollup.
+ */
+async function refreshStats(client, rooms) {
+  // One timestamp for all three, taken once — three now64() calls would be three
+  // generations, and the read layer would pair session_stats from one with model_stats
+  // from another.
+  let at;
+  try {
+    const rs = await client.query({ query: 'SELECT toString(now64(3)) AS t', format: 'JSONEachRow' });
+    at = `toDateTime64('${(await rs.json())[0].t}', 3, 'UTC')`;
+  } catch { return 0; }
+  let done = 0;
+  for (const q of statRefreshStatements(rooms, at)) {
+    try {
+      await client.command({ query: q, clickhouse_settings: { ...READ_SETTINGS, async_insert: 0 } });
+      done++;
+    } catch (e) {
+      const m = e && e.message ? e.message : String(e);
+      if (!/Not enough privileges|ACCESS_DENIED|UNKNOWN_TABLE|doesn't exist|does not exist/i.test(m)) {
+        console.error(`[memhouse] stats refresh: ${m.split('\n')[0]}`);
+      }
+      return done;
+    }
+  }
+  return done;
+}
+
 // One shipping pass. Incremental unless opts.full: a chat is skipped when the house
 // already has it at least as fresh (last_updated_at) and at least as large
 // (extra.bubbleCount) — both readable without parsing the chat.
@@ -1198,6 +1253,9 @@ async function runShip(client, opts = {}) {
     for (const r of rows.toolRows) { r.epoch = epoch; await push('tool_calls', scrub(r)); toolRows++; }
   }
   for (const table of Object.keys(batches)) await flush(table);
+  // The dashboard's tables, recomputed from what this pass just wrote. Skipped on a pass
+  // that shipped nothing: the previous generation is still exact.
+  if (sessions > 0) await refreshStats(client, rooms);
   // Anything that only failed while reading messages — the sink is reset by the
   // next getAllChats(), so unreported here means never reported at all.
   reportAdapterErrors(warned);
@@ -1352,7 +1410,7 @@ async function main() {
   }
 }
 
-module.exports = { runShip, ensureSchema, templateColumns, decideEpoch };
+module.exports = { runShip, ensureSchema, refreshStats, templateColumns, decideEpoch };
 
 if (require.main === module) {
   main().catch((e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memhouse",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "description": "memhouse \u2014 agent conversation memory across 17 editors: parse-on-client shippers, a typed ClickHouse store with one set of rooms per member, kernel-agency install, and the agentlytics dashboard",
   "main": "bin/memhouse.js",
   "bin": {
@@ -28,7 +28,8 @@
     "dev": "cd ui && npm run dev",
     "test": "node misc/syntax-check.js && node misc/unit-test.js",
     "test:house": "node misc/house-test.js",
-    "prepack": "cd ui && npm install --no-audit --no-fund && npm run build"
+    "prepack": "cd ui && npm install --no-audit --no-fund && npm run build",
+    "prepublishOnly": "node misc/publish-guard.js"
   },
   "keywords": [
     "memory",