memhouse 0.17.0 → 0.17.1

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.17.0",
+  "version": "0.17.1",
   "author": {
     "name": "Ramazan Polat"
   },

package/memhouse/house/house.js

@@ -288,6 +288,97 @@ function sessionsRollup({ sessions, messages }) {
   )`;
 }
 
+// The precomputed rollup's table name. One place, because the migration, the runtime
+// probe and the read layer must all agree on it.
+const SESSION_STATS = 'session_stats';
+// The per-(session, model) and per-(session, tool) rollups — what lets the cost, model
+// and tool queries stop scanning the messages/tool_calls rooms entirely. Same refresh
+// mechanism as SESSION_STATS; same fallback rule: absent tables mean the legacy SQL.
+const MODEL_STATS = 'session_model_stats';
+const TOOL_STATS = 'session_tool_stats';
+
+/**
+ * The DDL that materializes the rollup, as [target, view].
+ *
+ * A REFRESHABLE materialized view, not an ordinary one, and the distinction is not a
+ * preference — an ordinary MV is an insert trigger, and all three of this schema's
+ * defining properties break it:
+ *
+ *   DUPLICATES. The rooms are ReplacingMergeTree; the engine collapses re-inserted rows
+ *   at MERGE time, long after a trigger has already added them to a sum(). On a real
+ *   house that is 1,226,770 stored rows for 685,649 real ones — token totals ~1.8x high,
+ *   with nothing to indicate it.
+ *
+ *   EPOCHS. A trigger firing at insert cannot know a later parse will supersede the rows
+ *   it is aggregating, so superseded parses would stay in the totals forever.
+ *
+ *   THE JOIN. A trigger fires on one source table; the rollup joins sessions to messages.
+ *
+ * A refreshable view has none of those problems because it is not a trigger: it runs
+ * THIS ALREADY-CORRECT QUERY on a schedule and atomically swaps the target. FINAL, the
+ * epoch filter and the join all work exactly as they do in the subquery, because it IS
+ * the subquery. The price is staleness bounded by the interval — and the shipper's own
+ * default cadence is 300s, so a 5-minute refresh adds no lag to data arriving every 5.
+ *
+ * The target's columns are inferred with EMPTY AS, so the table and the rollup cannot
+ * drift: change sessionsRollup and the next migration rebuilds the table to match.
+ */
+function sessionStatsStatements(rooms, { intervalMinutes = 5 } = {}) {
+  const rollup = sessionsRollup(rooms);
+  // sessionsRollup wraps itself in parentheses for the FROM position; strip them.
+  const body = rollup.replace(/^\s*\(/, '').replace(/\)\s*$/, '');
+  return [
+    `CREATE TABLE IF NOT EXISTS ${SESSION_STATS} ENGINE = MergeTree `
+      + `ORDER BY (session_id, user_id) EMPTY AS ${body}`,
+    `CREATE MATERIALIZED VIEW IF NOT EXISTS ${SESSION_STATS}_mv `
+      + `REFRESH EVERY ${intervalMinutes} MINUTE TO ${SESSION_STATS} AS ${body}`,
+  ];
+}
+
+/**
+ * The two fine-grained rollups, same shape as sessionStatsStatements.
+ *
+ * MODEL_STATS one row per (session, user, source, folder, model), token sums included.
+ * Every model/cost aggregate the dashboard runs is a sum or argMax over these rows —
+ * a few thousand of them — instead of a scan of the full messages room. The ORPHAN
+ * (any-token) predicates in the read layer survive unchanged: a message row with zero
+ * tokens contributes zero to every sum, so filtering it out before summing and summing
+ * over everything produce the same number.
+ *
+ * TOOL_STATS one row per (session, user, source, folder, tool_name) with the call
+ * count. NOTE the epoch source: 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 here at the new epoch, and this room's own max(epoch)
+ * would resurrect the superseded parse's calls.
+ */
+function sessionModelStatsStatements(rooms, { intervalMinutes = 5 } = {}) {
+  const 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`;
+  return [
+    `CREATE TABLE IF NOT EXISTS ${MODEL_STATS} ENGINE = MergeTree `
+      + `ORDER BY (session_id, user_id, model) EMPTY AS ${body}`,
+    `CREATE MATERIALIZED VIEW IF NOT EXISTS ${MODEL_STATS}_mv `
+      + `REFRESH EVERY ${intervalMinutes} MINUTE TO ${MODEL_STATS} AS ${body}`,
+  ];
+}
+
+function sessionToolStatsStatements(rooms, { intervalMinutes = 5 } = {}) {
+  const 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`;
+  return [
+    `CREATE TABLE IF NOT EXISTS ${TOOL_STATS} ENGINE = MergeTree `
+      + `ORDER BY (session_id, user_id, tool_name) EMPTY AS ${body}`,
+    `CREATE MATERIALIZED VIEW IF NOT EXISTS ${TOOL_STATS}_mv `
+      + `REFRESH EVERY ${intervalMinutes} MINUTE TO ${TOOL_STATS} AS ${body}`,
+  ];
+}
+
 /**
  * The settings every read needs. `final` collapses ReplacingMergeTree versions;
  * `join_use_nulls` is what the rollup's coalesce depends on.
@@ -333,8 +424,65 @@ 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) {
+  try {
+    const rs = await client.query({
+      query: `SELECT name FROM system.tables
+              WHERE database = currentDatabase()
+                AND name IN ('${SESSION_STATS}', '${MODEL_STATS}', '${TOOL_STATS}')`,
+      format: 'JSONEachRow',
+    });
+    const present = (await rs.json()).map((r) => r.name);
+    // Present is not enough: a refreshable view populates its target on its FIRST
+    // refresh, which is scheduled, not immediate. Between `install` and that refresh the
+    // table exists and is empty — and a dashboard reading it 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) {
+  return (await statTables(client)).has(SESSION_STATS);
+}
+
 async function resolveRooms(client) {
-  return roomNames(await currentUser(client));
+  const rooms = roomNames(await currentUser(client));
+  const have = await statTables(client);
+  if (have.has(SESSION_STATS)) rooms.sessions_v = 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(MODEL_STATS) ? MODEL_STATS : null;
+  rooms.tool_stats = have.has(TOOL_STATS) ? TOOL_STATS : null;
+  return rooms;
 }
 
 module.exports = {
@@ -343,4 +491,6 @@ module.exports = {
   READ_SETTINGS, MEMBER_PIN,
   installCommand, assertUsableName,
   sessionsRollup, currentParse, createStatement, roomNames, currentUser, resolveRooms,
+  SESSION_STATS, MODEL_STATS, TOOL_STATS, hasSessionStats, statTables,
+  sessionStatsStatements, sessionModelStatsStatements, sessionToolStatsStatements,
 };

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

@@ -63,6 +63,8 @@ const selfSnap = selfUpdate.snapshot(__filename);
 const {
   resolveRooms, READ_SETTINGS, ROOM_TYPES, META_TYPES, SCHEMA_VERSION, MEMBER_PIN,
   SUPPORTED_SCHEMAS, keyProblem,
+  sessionStatsStatements, sessionModelStatsStatements, sessionToolStatsStatements,
+  SESSION_STATS, MODEL_STATS, TOOL_STATS,
 } = 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
@@ -448,6 +450,36 @@ 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 plus the refreshable views that fill them;
+  // the read layer probes for them at startup and falls back to the inline rollup when
+  // they are absent, so a denied CREATE here degrades to slow, never to wrong. Built from
+  // the SAME rollup text the read layer would otherwise run, so the two cannot drift.
+  const statStmts = [
+    ...sessionStatsStatements(rooms), ...sessionModelStatsStatements(rooms), ...sessionToolStatsStatements(rooms),
+  ];
+  for (const q of statStmts) {
+    try {
+      await client.command({
+        query: q,
+        // 26.x defaults the flag on; 25.x wants it stated. Query-scoped, like the
+        // text-index flag above.
+        clickhouse_settings: { async_insert: 0, allow_experimental_refreshable_materialized_view: 1 },
+      });
+    } 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;
+    }
+  }
+  // Kick the first population now rather than waiting for the schedule: a refreshable
+  // view's first refresh lands at its next interval boundary, and until then the read
+  // layer (correctly) ignores the empty table and runs the slow rollup. Best effort —
+  // the schedule gets there on its own, this just makes install/update fast at once.
+  for (const mv of [`${SESSION_STATS}_mv`, `${MODEL_STATS}_mv`, `${TOOL_STATS}_mv`]) {
+    try { await client.command({ query: `SYSTEM REFRESH VIEW ${mv}` }); } catch { /* no grant, or not there */ }
+  }
   if (denied) {
     console.error(`[memhouse] ${denied} schema statement(s) needed rights you do not hold — continuing with what you can do.`);
     console.error('[memhouse] creating or replacing a ROOM is the house owner\'s job; adding a missing COLUMN is not.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memhouse",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "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": {