perf: v2.5.10 — ready for 10+ concurrent users, leaner locally

Measured on a copy of a real 1.2 GB / 253K-event database, 10 simulated
browsers + 10 hooks/s for 90 s: event-loop delay p99 1239 ms → 32 ms (max
2.0 s → 94 ms), 266 failed requests → 0, 74 → 111 requests/s served, server
RSS 633 → 346 MB. Entry bundle 975 KB raw → 394 KB (106 KB brotli).

Server
- /api/analytics: the events-table scans run in the read worker
  (scoped-stats eventAggregates, read-pool job analyticsEvents); runRead takes
  maxAgeMs — analytics 10 s, /api/workflows 30 s — keyed by the args
- /api/workflows/skill-usage: +event_type and a tool_name range instead of
  LIKE, so it uses idx_events_tool (784 ms → a few ms)
- idx_events_session_type_tool (session_id, event_type, tool_name,
  created_at) replaces idx_events_session_type: covering reads for session
  stats, the hook dedupes and the import resume point (1.2 s → 20 ms); 64 MB
  cache_size and 256 MB mmap_size on both connections
- WAL: the server sets wal_autocheckpoint = 0 and checkpoints PASSIVE every
  DASHBOARD_WAL_CHECKPOINT_MS (5 s) from the read worker's own writable
  connection; a failed checkpoint restores the automatic one (hook COMMIT p95
  109 ms → 15 ms at 100 hooks/s)
- tmux: one list-sessions answers a whole GET /api/lanes and the heal beat
  (liveSessions), shared for 1 s and cleared by this process's new/kill —
  GET /api/run's sync spawns had blocked 60 s of a 90 s run; the heal beat
  skips tmux when nothing runs; attach options chained into 2 spawns
- hooks: TurnDuration/APIError deduped against one read per hook instead of a
  query per transcript entry (23 ms/hook on a 763-turn session); one lane
  scan per hook; hourly upserts skip rows that did not grow; frames are sent
  after the transaction commits (and after the pane binding); new_event
  carries its row id; a split pane's (slot 1–9) hooks no longer rebind the
  lane's session_id
- watchdog liveness probe runs ps asynchronously; transcript newline scan via
  indexOf; startup subagent backfill fingerprints the files it already checked
- pty attach: backpressure (pause past 1 MB unsent, resume under 256 KB)
- static: hashed assets served from their pre-compressed .br/.gz sibling

Client
- hidden tabs neither refetch on WS events nor poll (useLiveRefresh, panes,
  lane cards, git header, changes panel, settings); no per-tab hourly
  /updates/check (the server already checks)
- refetch storms throttled (workspace tree/session list 3 s, /api/run only on
  a run-key change, notification pane lookup only when shown); WS reconnect
  jitter; terminal retry backoff 1.5 → 30 s, stops on 1008
- heavier throttles for aggregates (15 s) and detail views; Monitor keepIfSame;
  GET in-flight dedupe in request()
- lazy Dashboard/History, xterm (with the first terminal), lane modals, Sagi
  (only while enabled); only the active locale loads; Workspace chunk
  prefetched on a /workspace deep link
- Sagi: no work while disabled, pupil via CSS variables, memo avatar
- build: .br/.gz siblings, sourcemap hidden; service worker no longer caches
  /assets/ (cache v3 drops the old one)

Tests: scripts/test-server.js drops the GIT_DIR-family variables a hook
exports, so a suite run from a linked worktree's pre-commit can no longer
commit into the real repository or set core.bare.

Docs: ARCHITECTURE, DATABASE, API, DEPLOYMENT, client README,
docs/plans/perf/README.md (audit, checklist, results).

server/routes/analytics.js

@@ -14,6 +14,7 @@ const {
   BAD_RANGE,
 } = require("../lib/source-filter");
 const scoped = require("../lib/scoped-stats");
+const { runRead } = require("../lib/read-pool");
 
 const { calculateCost, dailyTokenRows, costWhere } = require("./pricing");
 
@@ -34,12 +35,12 @@ const USAGE_TOKEN_COLS = {
  * With a range, counts follow it and tokens/cost come from the cost rows of the
  * days in it (`token_usage` has no date); the daily charts keep 365 days.
  */
-function computeAnalytics({ scope = null, range = null, tzModifier = "+0 minutes" } = {}) {
+function computeAnalytics(
+  { scope = null, range = null, tzModifier = "+0 minutes" } = {},
+  events = scoped.eventAggregates(db, scope || (range ? ALL : null), range, tzModifier)
+) {
   const sc = scope || (range ? ALL : null);
-  const toolUsage = sc ? scoped.toolUsageCounts(db, sc, range) : stmts.toolUsageCounts.all();
-  const dailyEvents = sc
-    ? scoped.dailyEventCounts(db, sc, tzModifier)
-    : stmts.dailyEventCounts.all(tzModifier);
+  const { toolUsage, dailyEvents, eventTypes, avgEvents } = events;
   const dailySessions = sc
     ? scoped.dailySessionCounts(db, sc, tzModifier)
     : stmts.dailySessionCounts.all(tzModifier);
@@ -56,10 +57,6 @@ function computeAnalytics({ scope = null, range = null, tzModifier = "+0 minutes
   const totalSubagents = sc
     ? scoped.totalSubagentCount(db, sc, range)
     : stmts.totalSubagentCount.get();
-  const eventTypes = sc ? scoped.eventTypeCounts(db, sc, range) : stmts.eventTypeCounts.all();
-  const avgEvents = sc
-    ? scoped.avgEventsPerSession(db, sc, range)
-    : stmts.avgEventsPerSession.get();
 
   // Total cost exactly as GET /api/pricing/cost computes it (baselines, the
   // per-day rate, the same scope and range), so the two numbers always agree.
@@ -108,7 +105,20 @@ router.get("/", (req, res) => {
   if (parseTool(req) === false) return res.status(400).json(BAD_TOOL);
   const range = parseRange(req);
   if (range === false) return res.status(400).json(BAD_RANGE);
-  res.json(computeAnalytics({ scope: parseScope(req), range, tzModifier }));
+  const scope = parseScope(req);
+  // The events scans run in the read worker (a 365-day daily count is ~0.5 s
+  // on a large DB), and a 10 s memo lets every open dashboard share one run.
+  runRead(
+    "analyticsEvents",
+    { scope: scope || (range ? ALL : null), range, tzModifier },
+    { maxAgeMs: 10_000 }
+  )
+    .then((events) => res.json(computeAnalytics({ scope, range, tzModifier }, events)))
+    .catch((err) =>
+      res
+        .status(err.code === "EREADTIMEOUT" ? 503 : 500)
+        .json({ error: { code: err.code, message: err.message } })
+    );
 });
 
 module.exports = router;