eklavya 1.66.1 → 1.67.1

package/dist/dashboard.js

@@ -28,9 +28,9 @@ import { fileURLToPath } from 'node:url';
 import { decayedScore, isKnown, isOwed, MS_PER_DAY } from './srs.js';
 import { correctionStates, correctionTarget, CorrectionError, GLOBAL_PROJECT, levelStanding, PASSING_GRADE, projectKey, promoteIfEarned, recordRetry, } from './store.js';
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-import { loadConfig, loadGlobalConfig, loadProjectConfig, configFileProblem, isGlobalOnlyKey, mainRepoRoot, readConfigFile, normalizeLegacyKeys, } from './config.js';
+import { findRepoConfig, LEGACY_REPO_CONFIG_FILE, loadConfig, loadGlobalConfig, loadProjectConfig, configFileProblem, isGlobalOnlyKey, mainRepoRoot, readConfigFile, normalizeLegacyKeys, } from './config.js';
 import { applySetting, knownKeys, SETTING_RULES, valueAt } from './config-path.js';
-import { dashboardPort, dbPath, DEFAULT_PORT, eklavyaHome, globalConfigPath, projectConfigPath } from './paths.js';
+import { artifactsDir, dashboardPort, dbPath, DEFAULT_PORT, eklavyaHome, globalConfigPath, projectConfigPath, projectsDir, } from './paths.js';
 import { ownVersion } from './dashboard-daemon.js';
 import { countUse } from './telemetry.js';
 import { acknowledgeFeedback, deleteFeedback, feedbackSummary, getFeedback, feedbackPending, listAcknowledged } from './feedback.js';
@@ -50,11 +50,38 @@ export { DEFAULT_PORT };
  */
 const TIMELINE_DAYS = 365;
 /**
- * Cap on the attempt rows shipped for drill-down. Counts and per-day totals are
- * aggregated in SQL over the whole table, so the cap can only ever shorten a
- * history list, never make a number wrong.
+ * Cap on the attempt rows shipped for drill-down, newest first. Counts and
+ * per-day totals are aggregated in SQL over the whole table, so the cap can only
+ * ever shorten a history list, never make a number wrong: anything the page
+ * counts, or narrows a project to, it takes from those aggregates and not from
+ * these rows (`totals`, `concepts`, `daily`, and `projectInventory`'s per-project
+ * counts, `totals` and `concept_slugs`).
+ *
+ * One number with `LOGGED_LIMIT`, and the one that sets the size of `/api/state`:
+ * a row is about 0.85 KB (a question, its options, the answer and the tutor's
+ * feedback), so these rows are over half of the payload. The budget for the
+ * payload at a year of daily use is 1.5 MB (issue #171), and at 2,000 rows of
+ * each kind it was 2.5 MB however the rest was trimmed: the two lists alone
+ * were more than that. At this size it is 1.15 MB with a 25-character
+ * repository path and 1.44 MB with a 105-character one (every row names its
+ * repository, so the path's length is in the size), which is why the number is
+ * not larger. `scripts/dashboard-perf.mjs medium` prints it.
+ */
+export const ATTEMPT_LIMIT = 800;
+/**
+ * Cap on the logged context lines (`session_concepts` rows) shipped in the
+ * payload, newest first like `attempts` and the same size: one number for how
+ * much history each kind of row brings. Each line carries its context text, so
+ * the list grew without bound and was the largest key at scale; a learner with
+ * fewer lines sees no change. `logged_shown` and `logged_total` say when it is
+ * cut, as `attempts_shown` and `attempts_total` do, and every total stays right
+ * because it is aggregated in SQL: `totals.sessions`, the concept catalogue's
+ * last context, the project inventory (its counts, its `sessions`, its `totals`
+ * across projects and the `concept_slugs` the page narrows a project to). A session whose lines fall
+ * outside the cap is still opened through `/api/memory/sessions`
+ * (`sessionLearning`).
  */
-const ATTEMPT_LIMIT = 2000;
+export const LOGGED_LIMIT = 800;
 /**
  * The memory corpus does not travel in `/api/state`.
  *
@@ -133,19 +160,30 @@ const many = (db, sql, ...args) => db.prepare(sql).all(...args);
  * is not assessment (PRD LRN-02) — `assessed` is the only one of these that
  * required the developer to answer something.
  */
-function memorySummary(db) {
-    const entries = one(db, `SELECT count(*) AS total,
-            COALESCE(SUM(deleted_at IS NULL AND superseded_by IS NULL), 0) AS live,
-            COALESCE(SUM(superseded_by IS NOT NULL), 0) AS superseded,
-            COALESCE(SUM(deleted_at IS NOT NULL), 0) AS deleted,
-            COALESCE(SUM(kind = 'note'), 0) AS notes
-     FROM memory_entries`);
-    const events = one(db, `SELECT count(*) AS captured,
-            COALESCE(SUM(status = 'summarized'), 0) AS processed,
-            COALESCE(SUM(status <> 'summarized'), 0) AS pending,
-            COALESCE(SUM(redacted), 0) AS redacted,
-            max(occurred_at) AS newest
-     FROM evidence_events`);
+function memorySummary(db, events) {
+    // One pass over the entries (each carries its narrative, so a pass reads the most bytes of any
+    // table here) gives the totals and the types: a group per type, summed for the totals.
+    const entries = { total: 0, live: 0, superseded: 0, deleted: 0, notes: 0 };
+    const types = [];
+    for (const g of many(db, `SELECT type, count(*) AS n,
+            SUM(deleted_at IS NULL AND superseded_by IS NULL) AS live,
+            SUM(superseded_by IS NOT NULL) AS superseded,
+            SUM(deleted_at IS NOT NULL) AS deleted,
+            SUM(kind = 'note') AS notes
+     FROM memory_entries GROUP BY type ORDER BY type`)) {
+        entries.total += g.n;
+        entries.live += g.live;
+        entries.superseded += g.superseded;
+        entries.deleted += g.deleted;
+        entries.notes += g.notes;
+        // A type counts what is not deleted (superseded entries stay on the timeline, marked), so a type
+        // with nothing left is not listed, and an entry with no type is `untyped`.
+        if (g.n > g.deleted)
+            types.push({ type: g.type ?? 'untyped', n: g.n - g.deleted });
+    }
+    // Largest first; equal counts keep the types' order. (The statement this replaced left equal counts
+    // in whatever order its plan gave them, which was the opposite one until an index served it.)
+    types.sort((a, b) => b.n - a.n);
     const candidates = many(db, 'SELECT status, count(*) AS n FROM learning_sources GROUP BY status');
     return {
         // What the hooks accepted from the host.
@@ -173,11 +211,14 @@ function memorySummary(db) {
        JOIN attempts a ON a.concept_id = ls.concept_id
        WHERE ls.concept_id IS NOT NULL`).n,
         candidates: Object.fromEntries(candidates.map((c) => [c.status, c.n])),
-        types: many(db, `SELECT COALESCE(type, 'untyped') AS type, count(*) AS n FROM memory_entries
-                     WHERE deleted_at IS NULL GROUP BY type ORDER BY n DESC`),
-        tags: many(db, `SELECT t.tag, count(*) AS n FROM memory_entry_tags t
-                    JOIN memory_entries e ON e.id = t.entry_id AND e.deleted_at IS NULL
-                    GROUP BY t.tag ORDER BY n DESC, t.tag LIMIT 60`),
+        types,
+        // A tag row always names an entry (a foreign key), so while none is deleted every tag counts and
+        // the entries need not be read again; once one is, only the live entries' tags do.
+        tags: entries.deleted === 0
+            ? many(db, `SELECT tag, count(*) AS n FROM memory_entry_tags GROUP BY tag ORDER BY n DESC, tag LIMIT 60`)
+            : many(db, `SELECT t.tag, count(*) AS n FROM memory_entry_tags t
+                  JOIN memory_entries e ON e.id = t.entry_id AND e.deleted_at IS NULL
+                  GROUP BY t.tag ORDER BY n DESC, t.tag LIMIT 60`),
         projects: many(db, `SELECT project, count(*) AS n FROM memory_entries GROUP BY project ORDER BY n DESC`),
         per_page: MEMORY_PER,
     };
@@ -228,14 +269,13 @@ function reuseSummary(db) {
  * `last_error`, never a key, never a log dump (PRD DASH-03). A class is what
  * tells the reader whether to re-authenticate or wait.
  */
-function healthSummary(db, config) {
-    const beat = one(db, 'SELECT max(occurred_at) AS newest, max(received_at) AS received FROM evidence_events');
+function healthSummary(db, config, events) {
     return {
         capture: {
             enabled: config.memory.enabled,
             mode: config.memory.capture,
-            newest_event: beat.newest,
-            newest_received: beat.received,
+            newest_event: events.newest,
+            newest_received: events.received,
             retention_days: config.memory.retention_days,
             // Each project stamps its own sweep; the page shows the latest of them
             // (the bare key is the stamp versions before per-project retention wrote).
@@ -261,17 +301,86 @@ function healthSummary(db, config) {
         },
     };
 }
-/** One row per session that captured evidence, so a session page can link the two halves. */
-function memorySessions(db) {
-    return many(db, `SELECT e.session_id, e.project, count(*) AS events,
-            COALESCE(SUM(e.redacted), 0) AS redacted,
-            min(e.occurred_at) AS first, max(e.occurred_at) AS last,
-            (SELECT count(*) FROM memory_entries m WHERE m.session_id = e.session_id) AS entries,
-            (SELECT count(*) FROM learning_sources ls JOIN memory_entries m ON m.id = ls.entry_id
-              WHERE m.session_id = e.session_id) AS candidates
-     FROM evidence_events e
-     GROUP BY e.session_id, e.project
-     ORDER BY last DESC LIMIT ?`, MEMORY_SESSION_LIMIT);
+/**
+ * Every group, in `(project, session_id, checkout)` order: the order `GROUP BY`
+ * already yields, spelled out because the inventory's rows are created in it.
+ */
+function evidenceGroups(db) {
+    // Every aggregate here is paid once per event (about 0.1 ms per thousand events
+    // each), so a sum that follows from the others is taken from them once per
+    // group: `status` is never null, so what is not processed is pending. A group
+    // has rows, so its sums are numbers and need no default.
+    return many(db, `SELECT project, session_id, checkout, count(*) AS events,
+            SUM(status = 'summarized') AS processed,
+            count(*) - SUM(status = 'summarized') AS pending,
+            SUM(redacted) AS redacted,
+            min(occurred_at) AS first, max(occurred_at) AS last, max(received_at) AS received
+     FROM evidence_events
+     GROUP BY project, session_id, checkout
+     ORDER BY project, session_id, checkout`);
+}
+/** The larger of two timestamps; `null` is no timestamp. They are ISO text, so text order is time order. */
+const laterOf = (a, b) => (a === null || b > a ? b : a);
+function evidenceTotals(groups) {
+    const t = { captured: 0, processed: 0, pending: 0, redacted: 0, newest: null, received: null };
+    for (const g of groups) {
+        t.captured += g.events;
+        t.processed += g.processed;
+        t.pending += g.pending;
+        t.redacted += g.redacted;
+        t.newest = laterOf(t.newest, g.last);
+        t.received = laterOf(t.received, g.received);
+    }
+    return t;
+}
+/**
+ * Text in the order SQLite sorts it (bytes of the UTF-8 form), which is not JavaScript's (UTF-16 units) for every string.
+ * The two agree wherever the first difference is between characters below the surrogates (which is
+ * every id and path people use), and the bytes are compared only where it is not.
+ */
+const binaryOrder = (a, b) => {
+    if (a === b)
+        return 0;
+    const shared = Math.min(a.length, b.length);
+    for (let i = 0; i < shared; i++) {
+        const x = a.charCodeAt(i);
+        const y = b.charCodeAt(i);
+        if (x !== y)
+            return x < 0xd800 && y < 0xd800 ? x - y : Buffer.compare(Buffer.from(a), Buffer.from(b));
+    }
+    return a.length - b.length;
+};
+/**
+ * One row per session that captured evidence, newest first, so a session page can
+ * link the two halves. A session that two projects both captured is two rows.
+ * Equal newest events keep the order `GROUP BY session_id, project` gave them.
+ */
+function memorySessions(db, groups) {
+    const merged = new Map();
+    for (const g of groups) {
+        const key = `${g.session_id}\u0000${g.project}`;
+        const row = merged.get(key);
+        if (!row) {
+            merged.set(key, { session_id: g.session_id, project: g.project, events: g.events, redacted: g.redacted, first: g.first, last: g.last });
+        }
+        else {
+            row.events += g.events;
+            row.redacted += g.redacted;
+            if (g.first < row.first)
+                row.first = g.first;
+            if (g.last > row.last)
+                row.last = g.last;
+        }
+    }
+    const newest = [...merged.values()]
+        .sort((a, b) => binaryOrder(b.last, a.last) || binaryOrder(a.session_id, b.session_id) || binaryOrder(a.project, b.project))
+        .slice(0, MEMORY_SESSION_LIMIT);
+    // Counted by session alone, not by project, as this list always has. One pass
+    // over each table rather than a lookup per row (the candidates one scans).
+    const entries = new Map(many(db, 'SELECT session_id, count(*) AS n FROM memory_entries WHERE session_id IS NOT NULL GROUP BY session_id').map((r) => [r.session_id, r.n]));
+    const candidates = new Map(many(db, `SELECT m.session_id, count(*) AS n FROM learning_sources ls JOIN memory_entries m ON m.id = ls.entry_id
+       WHERE m.session_id IS NOT NULL GROUP BY m.session_id`).map((r) => [r.session_id, r.n]));
+    return newest.map((r) => ({ ...r, entries: entries.get(r.session_id) ?? 0, candidates: candidates.get(r.session_id) ?? 0 }));
 }
 /**
  * One page of the memory timeline (PRD DASH-02).
@@ -344,8 +453,28 @@ export function memoryPage(db, q = {}) {
  * real total, so the Memory workflow's Sessions list never stops at the cap.
  * A session can exist in `memory_entries` alone — an import carries entries
  * and no evidence — so both tables contribute.
+ *
+ * Two steps, so the cost follows the page and not the database: the key set
+ * (which sessions there are, newest first, which is the total and the order),
+ * then the counts for the page's own rows. Equal newest times keep the order
+ * `GROUP BY session_id, project` gives them: session id, then project.
+ *
+ * Asking for one session (`session`) also answers for the learning half, which
+ * is in neither table above: see `sessionLearning`. That is how the page opens
+ * a session whose rows were cut from `logged` and `attempts`.
+ *
+ * One read transaction, so the key set and the counts under it are one snapshot
+ * of the database. They were one statement before they were two, and another
+ * process (a retention sweep, a purge) may delete rows at any moment: without
+ * the snapshot a session's last row could go between the two reads, leaving a
+ * key with nothing to count, and the page's first and last time would have no
+ * time to take (an HTTP 500). A deferred transaction that only reads takes no
+ * write lock and, in WAL, never blocks the writer it is a snapshot against.
  */
 export function memorySessionPage(db, q = {}) {
+    return db.transaction(() => sessionPageRows(db, q))();
+}
+function sessionPageRows(db, q) {
     const per = Math.min(MEMORY_PER_MAX, Math.max(1, Math.floor(q.per || MEMORY_PER)));
     const where = [];
     const args = [];
@@ -358,25 +487,54 @@ export function memorySessionPage(db, q = {}) {
         args.push(q.session);
     }
     const clause = where.length ? `WHERE ${where.join(' AND ')}` : '';
-    const union = `
-    SELECT session_id, project, count(*) AS events, COALESCE(SUM(redacted), 0) AS redacted,
-           COALESCE(SUM(status <> 'summarized'), 0) AS pending, min(occurred_at) AS first, max(occurred_at) AS last
-    FROM evidence_events GROUP BY session_id, project
-    UNION ALL
-    SELECT session_id, project, 0, 0, 0, min(occurred_at), max(occurred_at)
-    FROM memory_entries WHERE session_id IS NOT NULL GROUP BY session_id, project`;
-    const total = one(db, `SELECT count(*) AS n FROM (SELECT session_id, project FROM (${union}) ${clause} GROUP BY session_id, project)`, ...args).n;
+    // The entries half never names a session that is NULL; an import can leave one.
+    const entryClause = clause ? `${clause} AND session_id IS NOT NULL` : 'WHERE session_id IS NOT NULL';
+    const keys = many(db, `SELECT session_id, project FROM (
+       SELECT session_id, project, max(occurred_at) AS last FROM evidence_events ${clause} GROUP BY session_id, project
+       UNION ALL
+       SELECT session_id, project, max(occurred_at) FROM memory_entries ${entryClause} GROUP BY session_id, project)
+     GROUP BY session_id, project ORDER BY max(last) DESC, session_id, project`, ...args, ...args);
+    const total = keys.length;
     const pages = Math.max(1, Math.ceil(total / per));
     const p = Math.min(Math.max(1, Math.floor(q.page || 1)), pages);
-    const rows = many(db, `SELECT s.session_id, s.project, SUM(s.events) AS events, SUM(s.redacted) AS redacted, SUM(s.pending) AS pending,
-            min(s.first) AS first, max(s.last) AS last,
-            (SELECT count(*) FROM memory_entries m WHERE m.session_id = s.session_id AND m.project = s.project
-              AND m.deleted_at IS NULL AND m.superseded_by IS NULL) AS entries,
-            (SELECT count(*) FROM learning_sources ls JOIN memory_entries m ON m.id = ls.entry_id
-              WHERE m.session_id = s.session_id AND m.project = s.project) AS candidates
-     FROM (${union}) s ${clause}
-     GROUP BY s.session_id, s.project ORDER BY last DESC LIMIT ? OFFSET ?`, ...args, per, (p - 1) * per);
-    return { total, page: p, pages, per, rows };
+    const evidence = db.prepare(`SELECT count(*) AS events, COALESCE(SUM(redacted), 0) AS redacted, COALESCE(SUM(status <> 'summarized'), 0) AS pending,
+            min(occurred_at) AS first, max(occurred_at) AS last
+     FROM evidence_events WHERE session_id = ? AND project = ?`);
+    const entries = db.prepare(`SELECT COALESCE(SUM(deleted_at IS NULL AND superseded_by IS NULL), 0) AS live, min(occurred_at) AS first, max(occurred_at) AS last
+     FROM memory_entries WHERE session_id = ? AND project = ?`);
+    const candidates = db.prepare(`SELECT count(*) AS n FROM learning_sources ls JOIN memory_entries m ON m.id = ls.entry_id
+     WHERE m.session_id = ? AND m.project = ?`);
+    const rows = keys.slice((p - 1) * per, p * per).map(({ session_id, project }) => {
+        const e = evidence.get(session_id, project);
+        const m = entries.get(session_id, project);
+        const c = candidates.get(session_id, project);
+        // The key is in at least one table, so at least one side has times.
+        const first = [e.first, m.first].filter((t) => t !== null).reduce((a, b) => (b < a ? b : a));
+        const last = [e.last, m.last].filter((t) => t !== null).reduce((a, b) => (b > a ? b : a));
+        return { session_id, project, events: e.events, redacted: e.redacted, pending: e.pending, first, last, entries: m.live, candidates: c.n };
+    });
+    return { total, page: p, pages, per, rows, ...(q.session ? { learning: sessionLearning(db, q.session) } : {}) };
+}
+/**
+ * Everything one session logged and was asked, however old: the rows the state
+ * payload cut (`LOGGED_LIMIT`, `ATTEMPT_LIMIT`) and the ones it never had to cut
+ * because the session has no memory to list it under. Same row shapes as the
+ * payload's `logged` and `attempts` (one query each, shared), so the page draws
+ * a looked-up session exactly as one it already holds.
+ *
+ * Whole, and not narrowed by the page's project scope: which project a row
+ * belongs to is the page's `pid()`, which folds worktrees and recorded
+ * checkouts the way `projectInventory` does, and a second reading of that here
+ * would be a second opinion. The session's attempts are capped at
+ * `ATTEMPT_LIMIT` like every attempts list, with `attempts_total` to say so;
+ * its logged lines are at most one per concept.
+ */
+function sessionLearning(db, session) {
+    return {
+        logged: loggedRows(db, projectFolder(), -1, session),
+        attempts: attemptRows(db, ATTEMPT_LIMIT, session),
+        attempts_total: one(db, `SELECT count(*) AS n FROM attempts a WHERE a.session_id = ? AND a.${NOT_CORRECTION}`, session).n,
+    };
 }
 /** The id of a project whose rows carry no repository at all: recorded before projects were tracked. */
 export const UNATTRIBUTED = '~';
@@ -406,9 +564,12 @@ export const UNATTRIBUTED = '~';
  *   stored tells the two apart.
  */
 export function projectInventory(db) {
+    const evidence = evidenceGroups(db);
     const recorded = new Map();
-    for (const r of many(db, `SELECT DISTINCT checkout, project FROM evidence_events WHERE checkout IS NOT NULL AND checkout <> project`)) {
-        recorded.set(r.checkout, (recorded.get(r.checkout) ?? new Set()).add(r.project));
+    for (const g of evidence) {
+        if (g.checkout !== null && g.checkout !== g.project) {
+            recorded.set(g.checkout, (recorded.get(g.checkout) ?? new Set()).add(g.project));
+        }
     }
     const folded = new Map();
     const canonical = (raw) => {
@@ -436,10 +597,14 @@ export function projectInventory(db) {
             p = {
                 id, kind, path: kind === 'repo' ? id : null, name: '', available: kind === 'repo' ? fs.existsSync(id) : null,
                 sources: [], aliases: [],
-                learning: { answers: 0, passed: 0, skipped: 0, assessed_concepts: 0, logged_concepts: 0, sessions: 0, first: null, last: null },
+                learning: {
+                    answers: 0, passed: 0, skipped: 0, assessed_concepts: 0, logged_concepts: 0, logged_assessed_concepts: 0,
+                    sessions: 0, first: null, last: null, concept_slugs: [],
+                },
                 memory: { events: 0, pending: 0, entries: 0, sessions: 0, receipts: 0, first: null, last: null },
                 first_active: null, last_active: null,
-                _assessed: new Set(), _logged: new Set(), _lsess: new Set(), _msess: new Set(),
+                _assessed: new Set(), _logged: new Set(), _touched: new Set(), _lsess: new Set(), _msess: new Set(),
+                _lspan: { min: null, max: null }, _mspan: { min: null, max: null },
             };
             byId.set(id, p);
         }
@@ -450,26 +615,34 @@ export function projectInventory(db) {
             p.aliases.push(v);
         return p;
     };
+    // Across every project: the sets whose union is not the sum of the cards.
+    const every = { sessions: new Set(), logged: new Set(), assessed: new Set() };
     const sessionIds = new Map();
     const note = (sid, id) => sessionIds.set(sid, (sessionIds.get(sid) ?? new Set()).add(id));
-    // Both timestamp shapes, flattened to ISO so min/max compare as instants.
-    const iso = (ts) => {
+    // Both timestamp shapes, read as instants (epoch milliseconds) so min/max compare as instants. A
+    // group of one row has the same time at both ends and is read once; the instant becomes ISO
+    // text once per project at the end, not once per row (it was most of this function's time).
+    const epoch = (ts) => {
         if (!ts)
             return null;
         const t = parseTs(ts);
-        return Number.isFinite(t) ? new Date(t).toISOString() : null;
+        return Number.isFinite(t) ? t : null;
     };
     const span = (o, first, last) => {
-        const f = iso(first), l = iso(last);
-        if (f && (!o.first || f < o.first))
-            o.first = f;
-        if (l && (!o.last || l > o.last))
-            o.last = l;
+        const f = epoch(first);
+        const l = last === first ? f : epoch(last);
+        if (f !== null && (o.min === null || f < o.min))
+            o.min = f;
+        if (l !== null && (o.max === null || l > o.max))
+            o.max = l;
     };
+    const isoOf = (t) => (t === null ? null : new Date(t).toISOString());
+    // Answers that name no repository: the project they count toward for the concept list is
+    // settled below, once the sessions that prove one are known (as the page's `pid()` does).
+    const blankAsked = [];
     for (const r of many(db, `SELECT repo, session_id, concept_id, count(*) AS n,
-            -- A miss corrected from its explainer counts as right, as on the Accuracy tile.
-            COALESCE(SUM(grade >= ${PASSING_GRADE} OR EXISTS (SELECT 1 FROM attempts fix WHERE fix.retry_of = attempts.id)), 0) AS passed,
-            COALESCE(SUM(outcome IN ('declined','dont_know')), 0) AS skipped,
+            SUM(grade >= ${PASSING_GRADE}) AS passed,
+            SUM(outcome IN ('declined','dont_know')) AS skipped,
             min(ts) AS first, max(ts) AS last
      FROM attempts WHERE ${NOT_CORRECTION} GROUP BY repo, session_id, concept_id`)) {
         const p = at(r.repo, 'attempts');
@@ -477,22 +650,34 @@ export function projectInventory(db) {
         p.learning.passed += r.passed;
         p.learning.skipped += r.skipped;
         p._assessed.add(r.concept_id);
+        every.assessed.add(r.concept_id);
+        if (r.repo?.trim())
+            p._touched.add(r.concept_id);
+        else
+            blankAsked.push([r.session_id, r.concept_id]);
         if (r.session_id) {
             p._lsess.add(r.session_id);
+            every.sessions.add(r.session_id);
             if (r.repo?.trim())
                 note(r.session_id, p.id);
         }
-        span(p.learning, r.first, r.last);
+        span(p._lspan, r.first, r.last);
     }
-    for (const r of many(db, `SELECT project, session_id, count(*) AS n, COALESCE(SUM(status <> 'summarized'), 0) AS pending,
-            min(occurred_at) AS first, max(occurred_at) AS last
-     FROM evidence_events GROUP BY project, session_id`)) {
-        const p = at(r.project, 'evidence');
-        p.memory.events += r.n;
-        p.memory.pending += r.pending;
-        p._msess.add(r.session_id);
-        note(r.session_id, p.id);
-        span(p.memory, r.first, r.last);
+    // A miss corrected from its explainer counts as right, as on the Accuracy tile. They are the answers
+    // that have a correction and did not pass (a handful), counted here by repository rather than by
+    // a lookup made for every answer above; each one's project is already there.
+    for (const r of many(db, `SELECT a.repo, count(*) AS n FROM attempts a JOIN attempts fix ON fix.retry_of = a.id
+     WHERE a.${NOT_CORRECTION} AND a.grade < ${PASSING_GRADE} GROUP BY a.repo`)) {
+        byId.get(canonical(r.repo)).learning.passed += r.n;
+    }
+    // One row per project and session, whichever checkouts the events came from.
+    for (const g of evidence) {
+        const p = at(g.project, 'evidence');
+        p.memory.events += g.events;
+        p.memory.pending += g.pending;
+        p._msess.add(g.session_id);
+        note(g.session_id, p.id);
+        span(p._mspan, g.first, g.last);
     }
     // A gate row with no repository names no project, but the same session's
     // own answers and evidence may. Where they agree on exactly one project, the
@@ -512,11 +697,19 @@ export function projectInventory(db) {
         // Only work the agent logged. `record_attempt` writes a `review` row for
         // every concept it grades, and counting those would call every answered
         // concept "recorded from your work".
-        if ((r.origin ?? 'work') === 'work')
+        if ((r.origin ?? 'work') === 'work') {
             p._logged.add(r.concept_id);
+            every.logged.add(r.concept_id);
+        }
+        // Any origin: a concept a question was asked about is as much in the project as one its work touched.
+        p._touched.add(r.concept_id);
         p._lsess.add(r.session_id);
-        span(p.learning, r.first, r.last);
+        every.sessions.add(r.session_id);
+        span(p._lspan, r.first, r.last);
     }
+    // An answer with no repository belongs where its session was proven to belong, else nowhere.
+    for (const [sid, concept] of blankAsked)
+        byId.get((sid && sessionProjects[sid]) || UNATTRIBUTED)._touched.add(concept);
     for (const r of many(db, `SELECT project, session_id, COALESCE(SUM(deleted_at IS NULL AND superseded_by IS NULL), 0) AS live,
             min(occurred_at) AS first, max(occurred_at) AS last
      FROM memory_entries GROUP BY project, session_id`)) {
@@ -524,18 +717,26 @@ export function projectInventory(db) {
         p.memory.entries += r.live;
         if (r.session_id)
             p._msess.add(r.session_id);
-        span(p.memory, r.first, r.last);
+        span(p._mspan, r.first, r.last);
     }
     for (const r of many(db, 'SELECT project, count(*) AS n FROM context_receipts GROUP BY project')) {
         at(r.project, 'receipts').memory.receipts += r.n;
     }
     for (const r of many(db, 'SELECT repo FROM project_levels'))
         at(r.repo, 'levels');
-    const projects = [...byId.values()].map(({ _assessed, _logged, _lsess, _msess, ...p }) => {
+    const slugs = new Map(many(db, 'SELECT id, slug FROM concepts').map((c) => [c.id, c.slug]));
+    const projects = [...byId.values()].map(({ _assessed, _logged, _touched, _lsess, _msess, _lspan, _mspan, ...p }) => {
         p.learning.assessed_concepts = _assessed.size;
         p.learning.logged_concepts = _logged.size;
+        p.learning.logged_assessed_concepts = [..._logged].filter((id) => _assessed.has(id)).length;
+        // Concepts exist for every row that names one (a foreign key), so every id has its slug.
+        p.learning.concept_slugs = [..._touched].map((id) => slugs.get(id)).sort();
         p.learning.sessions = _lsess.size;
         p.memory.sessions = _msess.size;
+        p.learning.first = isoOf(_lspan.min);
+        p.learning.last = isoOf(_lspan.max);
+        p.memory.first = isoOf(_mspan.min);
+        p.memory.last = isoOf(_mspan.max);
         const firsts = [p.learning.first, p.memory.first].filter(Boolean);
         const lasts = [p.learning.last, p.memory.last].filter(Boolean);
         p.first_active = firsts.sort()[0] ?? null;
@@ -562,11 +763,18 @@ export function projectInventory(db) {
     const aliases = {};
     for (const [raw, id] of folded)
         aliases[raw] = id;
-    return { projects, aliases, sessions: sessionProjects };
+    const totals = {
+        sessions: every.sessions.size,
+        logged_concepts: every.logged.size,
+        logged_assessed_concepts: [...every.logged].filter((id) => every.assessed.has(id)).length,
+    };
+    return { projects, aliases, sessions: sessionProjects, totals };
 }
 /**
- * What an open page polls to notice that work landed while it was reading it
- * (PRD DASH-01), served alone at `/api/cursor` so a poll builds no payload.
+ * What an open page is told about, to notice that work landed while it was
+ * reading it (PRD DASH-01): `/api/events` streams it (`createLive`, which reads
+ * it for as long as a page is listening) and `/api/cursor` returns it alone,
+ * building no payload.
  *
  * Three parts, one per place the page's content comes from:
  * - `change_version` (migration 021), which triggers move on every write to a
@@ -577,9 +785,9 @@ export function projectInventory(db) {
  * - The artifact files' count, total size and newest mtime (`artifactsStamp`).
  *
  * Deliberately not `generated_at`, and not a hash of the payload: both change
- * on every call -- scores are decayed against the clock -- and a page that
- * announces new activity every minute is a page whose banner is ignored inside
- * a day. Not watched: the prune stamp and spool drop count in the health panel.
+ * on every call -- scores are decayed against the clock -- and a cursor that
+ * moves on every call would redraw the page every second. Not watched: the
+ * prune stamp and spool drop count in the health panel.
  */
 export function changeCursor(db, configs = readConfigs(db)) {
     const version = one(db, 'SELECT n FROM change_version WHERE id = 1').n;
@@ -589,6 +797,154 @@ export function changeCursor(db, configs = readConfigs(db)) {
         .slice(0, 12);
     return `${version}:${dials}:${artifactsStamp()}`;
 }
+/*
+ * Serving a build once per cursor.
+ *
+ * A build is the expensive part of opening the page (the state alone is 20 ms
+ * to a second, by the size of the database) and almost always rebuilds what the
+ * last one said: the page reads the whole payload on every load and the server
+ * is one thread. `changeCursor` is the version of everything the page shows and
+ * costs a few milliseconds, so every read asks it first and rebuilds only when
+ * it moved.
+ *
+ * One memo per database handle, in a WeakMap, never a global: tests and the
+ * daemon hold several databases in one process, and each answers for its own.
+ * The exported `settingsState` and `configurableProjects` read the same memo
+ * as the server does, so a build is paid for once whoever asks first.
+ *
+ * Two inputs are not in the cursor, and both expire the build by time instead:
+ * the clock (scores decay at read time, so `due` and `overdue_days` move
+ * without a write) and the filesystem (a project's `available` flag, whether a
+ * checkout still has its `.git`, what `listArtifacts` reads from the files).
+ * The health panel's prune stamp and the spool's drop count are not in the
+ * cursor either (see its comment) and ride the same minute: they show on the
+ * next build, not the next request. One more input is left out of the cursor on
+ * purpose and is too visible to wait a minute: `reviewFailed`.
+ */
+/** How long a build that reads the clock or the filesystem is served without being rebuilt. */
+export const MEMO_TTL_MS = 60_000;
+/** Serialised responses kept per database; the least recently used goes first. */
+export const PAGE_CACHE_ENTRIES = 64;
+/** A response larger than this many bytes is served but not kept, so one huge entry cannot pin megabytes. */
+const PAGE_MAX_BYTES = 1024 * 1024;
+const memos = new WeakMap();
+/** The one route whose response a settings write changes. */
+const SETTINGS_PATH = '/api/settings';
+/**
+ * Whether the last session Eklavya looked at for feedback could not be reviewed.
+ *
+ * `feedback_reviewed` has no change triggers, deliberately (migration 026, and
+ * `migrate.test.ts` pins it): a session looked at and found quiet is not news
+ * for an open page. But the state says "couldn't review the last session" from
+ * it, and a page loaded a moment after that row landed has to say so, as it
+ * did when every load was a build. So the memo asks, alongside the cursor.
+ * An older schema without the table reads as not failed, as `feedbackSummary` does.
+ */
+function reviewFailed(db) {
+    try {
+        const last = one(db, 'SELECT outcome FROM feedback_reviewed ORDER BY reviewed_at DESC, rowid DESC LIMIT 1');
+        return last?.outcome === 'failed';
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether a build made at `at` may still be served at `now`. A clock that stepped back expires it too. */
+const served = (at, now) => now >= at && now - at < MEMO_TTL_MS;
+/**
+ * The memo for this database, valid for the cursor as it is right now (and for
+ * `reviewFailed`, the one thing beside it that the state reads and the cursor does not).
+ *
+ * The cursor is read here, before any build that is stored in the memo, and
+ * stays with it: a write that lands during a build makes the next read see a
+ * newer cursor and rebuild, where reading it after would label a build with a
+ * cursor newer than the rows it read. A change to the config or to an artifact
+ * keeps the inventory, which reads neither: only the database's counter, the
+ * first part of the cursor, drops it.
+ */
+function memoFor(db) {
+    const cursor = changeCursor(db);
+    const version = cursor.slice(0, cursor.indexOf(':'));
+    const valid = `${cursor}|${reviewFailed(db)}`;
+    let memo = memos.get(db);
+    if (memo?.cursor !== valid) {
+        memo = { cursor: valid, version, state: null, inventory: memo?.version === version ? memo.inventory : null, pages: new Map() };
+        memos.set(db, memo);
+    }
+    return memo;
+}
+/** `/api/state` as the bytes it is sent as. Built at most once per cursor and minute. */
+function stateBody(memo, db) {
+    const now = Date.now();
+    if (memo.state && served(memo.state.at, now))
+        return memo.state.body;
+    const body = Buffer.from(JSON.stringify(dashboardState(db)));
+    memo.state = { at: now, body };
+    return body;
+}
+/** The project inventory, rebuilt when the database moved, a minute passed, or the caller must not trust a memo. */
+function inventoryOf(memo, db, rebuild = false) {
+    const now = Date.now();
+    if (rebuild || !memo.inventory || !served(memo.inventory.at, now)) {
+        memo.inventory = { at: now, value: projectInventory(db), configurable: null };
+    }
+    return memo.inventory;
+}
+/**
+ * One response by its full URL (path and query), most recently used last.
+ *
+ * `build` returns null for a response that is not a page worth keeping (an
+ * entry that does not exist); it is not stored. `expires` is for a response
+ * that reads the filesystem, and `stamp` for one whose inputs are files the
+ * cursor does not cover: an entry made under another stamp is not served.
+ */
+function pageBody(memo, key, build, opts = {}) {
+    const now = Date.now();
+    const stamp = opts.stamp ? opts.stamp() : '';
+    const hit = memo.pages.get(key);
+    if (hit && hit.stamp === stamp && (!opts.expires || served(hit.at, now))) {
+        memo.pages.delete(key);
+        memo.pages.set(key, hit);
+        return hit.body;
+    }
+    const json = build();
+    // Replacing an entry must also move it: `Map.set` on a present key keeps its place.
+    memo.pages.delete(key);
+    if (json === null)
+        return null;
+    const body = Buffer.from(json);
+    if (body.length <= PAGE_MAX_BYTES) {
+        memo.pages.set(key, { at: now, stamp, body });
+        while (memo.pages.size > PAGE_CACHE_ENTRIES)
+            memo.pages.delete(memo.pages.keys().next().value);
+    }
+    return body;
+}
+/** The state and the inventory, built now so the first request finds them. Throws as the builders do. */
+function warmMemo(db) {
+    const memo = memoFor(db);
+    stateBody(memo, db);
+    inventoryOf(memo, db);
+}
+/** What a settings write changed is on disk before any cursor or clock can say so: drop the pages that show it. */
+function forgetSettings(db) {
+    const pages = memos.get(db)?.pages;
+    if (!pages)
+        return;
+    for (const key of pages.keys())
+        if (key.startsWith(SETTINGS_PATH))
+            pages.delete(key);
+}
+/** One file's identity and version, or `-` when there is none. Inode, size and nanosecond mtime: an atomic rewrite changes at least one. */
+function fileStamp(file) {
+    try {
+        const s = fs.statSync(file, { bigint: true });
+        return `${s.ino}.${s.size}.${s.mtimeNs}`;
+    }
+    catch {
+        return '-';
+    }
+}
 /** One entry with its tags, its raw evidence and the candidates it proposed. */
 export function memoryEntry(db, id) {
     const entry = one(db, 'SELECT * FROM memory_entries WHERE id = ?', id);
@@ -619,6 +975,187 @@ export function memoryEntry(db, id) {
        WHERE i.entry_id = ? ORDER BY r.id DESC LIMIT 20`, id),
     };
 }
+/**
+ * `projectKey`, once per distinct path in one build. It looks at the checkout's
+ * `.git` on disk (a worktree folds into its main checkout), and a context line
+ * carries the path of every session's repository: a statement per row is
+ * thousands of statements for a few hundred distinct answers.
+ */
+function projectFolder() {
+    const keys = new Map();
+    return (repo) => {
+        let key = keys.get(repo);
+        if (key === undefined) {
+            key = projectKey(repo);
+            keys.set(repo, key);
+        }
+        return key;
+    };
+}
+/**
+ * Graded answers, newest first, as the page reads them: the payload's capped
+ * history (`attempts`) and one session's own rows (`sessionLearning`) come from
+ * this one statement, so they cannot drift apart. A correction row is a pick on
+ * the explainer, not a question asked (`NOT_CORRECTION`), and rides on the row
+ * it corrected.
+ */
+function attemptRows(db, limit, session) {
+    return many(db, `SELECT a.id, c.slug, c.name, c.domain, a.session_id, a.question, a.answer, a.feedback,
+            a.grade, a.difficulty AS tier, a.outcome, a.format, a.options, a.ts,
+            NULLIF(trim(COALESCE(a.repo, '')), '') AS repo, a.level,
+            -- A miss corrected from its explainer: when, and on which try.
+            fix.ts AS corrected_at,
+            CASE WHEN fix.id IS NULL THEN NULL
+                 ELSE (SELECT count(*) FROM attempt_retries r WHERE r.attempt_id = a.id) END AS corrected_try
+     FROM attempts a JOIN concepts c ON c.id = a.concept_id
+     LEFT JOIN attempts fix ON fix.retry_of = a.id
+     WHERE a.${NOT_CORRECTION}${session === undefined ? '' : ' AND a.session_id = ?'}
+     ORDER BY a.id DESC
+     LIMIT ?`, ...(session === undefined ? [] : [session]), limit);
+}
+/**
+ * The context lines the agent logged, newest first, as the page reads them: the
+ * payload's capped list and one session's lines (`sessionLearning`, a `limit`
+ * of -1, which SQLite reads as none). Equal times keep the order the rows were
+ * written in, which is the order they have always had.
+ *
+ * `gates.repo` stays the worktree path -- the POSIX gate matches it against
+ * `git rev-parse --show-toplevel`. Every other repo on this page comes from
+ * `attempts`, already folded, so fold this one too or a project filter drops
+ * every context line a worktree session logged.
+ */
+function loggedRows(db, fold, limit, session) {
+    const rows = many(db, `SELECT sc.session_id, c.slug, c.name, c.domain, sc.context, sc.ts, sc.origin,
+            NULLIF(trim(COALESCE(g.repo, '')), '') AS repo
+     FROM session_concepts sc
+     JOIN concepts c ON c.id = sc.concept_id
+     LEFT JOIN gates g ON g.session_id = sc.session_id
+     ${session === undefined ? '' : 'WHERE sc.session_id = ?'}
+     ORDER BY sc.ts DESC, sc.rowid
+     LIMIT ?`, ...(session === undefined ? [] : [session]), limit);
+    for (const row of rows)
+        row.repo = row.repo ? fold(row.repo) : null;
+    return rows;
+}
+/**
+ * Every number the page takes from `attempts` that is not a list of rows: the
+ * per-day split, the per-project totals, the all-time totals and each concept's
+ * counts. They were five statements, each reading the whole table and the
+ * first two converting every timestamp to the learner's day (2 microseconds a
+ * row, 19 ms at 10,000 answers); they are two statements now, one grouped by
+ * day and repository and one by repository and concept, and a few sums in JS.
+ *
+ * Each figure is the one the statement it replaced gave, value for value: a
+ * correction row is no answer (`NOT_CORRECTION`) but is counted as one
+ * `corrected` against the miss it fixes, and an answer that was corrected is
+ * neither missed nor skipped. That last exclusion is taken from the answers
+ * that were corrected (a handful) instead of a join over every answer.
+ */
+function answerRollups(db) {
+    const dayGroups = many(db, `SELECT date(a.ts, 'localtime') AS day, NULLIF(trim(COALESCE(a.repo, '')), '') AS repo, a.ts >= date('now', ?) AS recent,
+            count(*) AS answers,
+            sum(CASE WHEN a.grade >= ${PASSING_GRADE} THEN 1 ELSE 0 END) AS passed,
+            sum(CASE WHEN a.grade < ${PASSING_GRADE} AND (a.outcome IS NULL OR a.outcome = 'answered') THEN 1 ELSE 0 END) AS missed,
+            sum(CASE WHEN a.outcome IN ('declined','dont_know') THEN 1 ELSE 0 END) AS skipped,
+            min(a.ts) AS first
+     FROM attempts a
+     WHERE a.${NOT_CORRECTION}
+     GROUP BY 1, 2, 3
+     ORDER BY 1, 2, 3`, `-${TIMELINE_DAYS} days`);
+    // The same groups, over the answers that were corrected (a handful): what to take back out of
+    // missed and skipped.
+    const groupKey = (g) => `${g.day ?? ''}\u0000${g.repo ?? ''}\u0000${g.recent}`;
+    const fixed = new Map();
+    for (const f of many(db, `SELECT date(a.ts, 'localtime') AS day, NULLIF(trim(COALESCE(a.repo, '')), '') AS repo, a.ts >= date('now', ?) AS recent,
+            count(*) AS fixed,
+            sum(CASE WHEN a.grade < ${PASSING_GRADE} AND (a.outcome IS NULL OR a.outcome = 'answered') THEN 1 ELSE 0 END) AS missed,
+            sum(CASE WHEN a.outcome IN ('declined','dont_know') THEN 1 ELSE 0 END) AS skipped
+     FROM attempts a JOIN attempts fix ON fix.retry_of = a.id
+     WHERE a.${NOT_CORRECTION}
+     GROUP BY 1, 2, 3`, `-${TIMELINE_DAYS} days`)) {
+        fixed.set(groupKey(f), f);
+    }
+    const none = { fixed: 0, missed: 0, skipped: 0 };
+    const daily = [];
+    const allTime = { answers: 0, passed: 0, missed: 0, skipped: 0, corrected: 0, active_days: 0, first_answer: null };
+    const activeDays = new Set();
+    for (const g of dayGroups) {
+        // Every corrected answer is an answer, so its group is among these.
+        const f = fixed.size === 0 ? none : fixed.get(groupKey(g)) ?? none;
+        const missed = g.missed - f.missed;
+        const skipped = g.skipped - f.skipped;
+        allTime.answers += g.answers;
+        allTime.passed += g.passed;
+        allTime.missed += missed;
+        allTime.skipped += skipped;
+        allTime.corrected += f.fixed;
+        if (g.day !== null)
+            activeDays.add(g.day);
+        if (allTime.first_answer === null || g.first < allTime.first_answer)
+            allTime.first_answer = g.first;
+        // The groups come in the order `GROUP BY day, repo` gave the rows they replace.
+        if (g.recent)
+            daily.push({ day: g.day, repo: g.repo, passed: g.passed, missed, skipped, corrected: f.fixed });
+    }
+    allTime.active_days = activeDays.size;
+    // One group per repository and concept over the answers, which give the project rows and the
+    // catalogue's counts, and the same over the corrections (an index finds them), which the
+    // catalogue counts as `corrected` and which may be the newest row naming a repository.
+    const asked = new Map();
+    const byRepo = new Map();
+    const concept = (id) => {
+        let c = asked.get(id);
+        if (c === undefined) {
+            c = { attempts: 0, passed: 0, skipped: 0, corrected: 0, first_asked: null, last_id: null, last_repo_id: null };
+            asked.set(id, c);
+        }
+        return c;
+    };
+    // Grouped by the repo column as written, which is how the project rows have always been grouped:
+    // a project row is one per spelling (an empty repo, a blank one and an unset one are three rows,
+    // each reading as no repository), and a catalogue row cannot tell them apart.
+    for (const g of many(db, `SELECT a.repo AS raw, NULLIF(trim(COALESCE(a.repo, '')), '') AS repo, a.concept_id,
+            count(*) AS attempts,
+            sum(a.grade >= ${PASSING_GRADE}) AS passed,
+            sum(a.outcome IN ('declined','dont_know')) AS skipped,
+            min(a.ts) AS first, max(a.ts) AS last, max(a.id) AS last_id
+     FROM attempts a
+     WHERE a.${NOT_CORRECTION}
+     GROUP BY a.repo, a.concept_id`)) {
+        const c = concept(g.concept_id);
+        c.attempts += g.attempts;
+        c.passed += g.passed;
+        c.skipped += g.skipped;
+        if (c.first_asked === null || g.first < c.first_asked)
+            c.first_asked = g.first;
+        if (c.last_id === null || g.last_id > c.last_id)
+            c.last_id = g.last_id;
+        if (g.repo !== null && (c.last_repo_id === null || g.last_id > c.last_repo_id))
+            c.last_repo_id = g.last_id;
+        const p = byRepo.get(g.raw) ?? { repo: g.repo, answers: 0, passed: 0, skipped: 0, concepts: 0, first_active: g.first, last_active: g.last };
+        byRepo.set(g.raw, p);
+        p.answers += g.attempts;
+        p.passed += g.passed;
+        p.skipped += g.skipped;
+        p.concepts += 1;
+        if (g.first < p.first_active)
+            p.first_active = g.first;
+        if (g.last > p.last_active)
+            p.last_active = g.last;
+    }
+    for (const g of many(db, `SELECT NULLIF(trim(COALESCE(a.repo, '')), '') AS repo, a.concept_id, count(*) AS corrections, max(a.id) AS last_id
+     FROM attempts a
+     WHERE a.retry_of IS NOT NULL
+     GROUP BY 1, 2`)) {
+        const c = concept(g.concept_id);
+        c.corrected += g.corrections;
+        if (g.repo !== null && (c.last_repo_id === null || g.last_id > c.last_repo_id))
+            c.last_repo_id = g.last_id;
+    }
+    // Repositories came out in order, so equal last-active times keep it.
+    const projects = [...byRepo.values()].sort((a, b) => (a.last_active === b.last_active ? 0 : a.last_active < b.last_active ? 1 : -1));
+    return { daily, projects, allTime, asked };
+}
 export function dashboardState(db) {
     const now = new Date();
     const configs = readConfigs(db);
@@ -626,58 +1163,44 @@ export function dashboardState(db) {
     // speak for every project, and the server's cwd is not any project's choice.
     const config = configs.user;
     // First, before any of the payload is read: a write that lands while it is
-    // being built then shows as a notice on the next poll, never as a miss.
+    // being built moves the next cursor, so the page reads again and never misses it.
     const cursor = changeCursor(db, configs);
-    // One row per calendar day per project, split three ways. `grade >= 3` is the
-    // same pass line the level ladder uses, so the chart and the promotion agree.
-    const daily = db
-        .prepare(`SELECT date(a.ts, 'localtime') AS day,
-              NULLIF(trim(COALESCE(a.repo, '')), '') AS repo,
-              sum(CASE WHEN a.grade >= ? THEN 1 ELSE 0 END) AS passed,
-              sum(CASE WHEN a.grade < ? AND (a.outcome IS NULL OR a.outcome = 'answered') AND fix.id IS NULL THEN 1 ELSE 0 END) AS missed,
-              sum(CASE WHEN a.outcome IN ('declined','dont_know') AND fix.id IS NULL THEN 1 ELSE 0 END) AS skipped,
-              count(fix.id) AS corrected
-       FROM attempts a LEFT JOIN attempts fix ON fix.retry_of = a.id
-       WHERE a.${NOT_CORRECTION} AND a.ts >= date('now', ?)
-       GROUP BY 1, 2
-       ORDER BY day`)
-        .all(PASSING_GRADE, PASSING_GRADE, `-${TIMELINE_DAYS} days`);
-    // A null repo is the pre-migration-003 bucket. It is kept, not dropped:
+    // The numbers taken from `attempts` that are not lists of rows: one row per calendar day per
+    // project (split three ways: `grade >= PASSING_GRADE` is the pass line the level ladder uses, so
+    // the chart and the promotion agree), the per-project totals, the all-time totals and each
+    // concept's counts. A null repo is the pre-migration-003 bucket. It is kept, not dropped:
     // hiding those rows would silently shrink every total on the page.
-    const projects = db
-        .prepare(`SELECT NULLIF(trim(COALESCE(a.repo, '')), '') AS repo,
-              count(*) AS answers,
-              sum(CASE WHEN a.grade >= ? THEN 1 ELSE 0 END) AS passed,
-              sum(CASE WHEN a.outcome IN ('declined','dont_know') THEN 1 ELSE 0 END) AS skipped,
-              count(DISTINCT a.concept_id) AS concepts,
-              min(a.ts) AS first_active,
-              max(a.ts) AS last_active
-       FROM attempts a
-       WHERE a.${NOT_CORRECTION}
-       GROUP BY repo
-       ORDER BY last_active DESC`)
-        .all(PASSING_GRADE);
+    const { daily, projects, allTime, asked } = answerRollups(db);
+    // The catalogue with each concept's last context. The newest answer of a concept and its counts
+    // come from the rollup above; the last context is one index lookup per concept
+    // (migration 031), where this used to be eight correlated subqueries per concept over
+    // `attempts` and `session_concepts`, the last of them reading every logged line.
+    const lastGrade = db.prepare('SELECT grade FROM attempts WHERE id = ?').pluck();
+    const lastRepo = db.prepare('SELECT repo FROM attempts WHERE id = ?').pluck();
     const conceptRows = db
         .prepare(`SELECT c.id, c.slug, c.name, c.domain, c.description, c.tier, c.source,
-              m.score, m.ease, m.interval_d, m.reps, m.next_review, m.last_seen,
-              (SELECT count(*) FROM attempts a WHERE a.concept_id = c.id AND a.${NOT_CORRECTION}) AS attempts,
-              (SELECT count(*) FROM attempts a WHERE a.concept_id = c.id AND a.${NOT_CORRECTION} AND a.grade >= ${PASSING_GRADE}) AS passed,
-              (SELECT count(*) FROM attempts a WHERE a.concept_id = c.id AND a.${NOT_CORRECTION}
-                AND a.outcome IN ('declined','dont_know')) AS skipped,
-              (SELECT count(*) FROM attempts a WHERE a.concept_id = c.id AND a.retry_of IS NOT NULL) AS corrected,
-              (SELECT min(a.ts) FROM attempts a WHERE a.concept_id = c.id AND a.${NOT_CORRECTION}) AS first_asked,
-              -- The backlog rule's grade (OWED_SQL in store.ts): a correction does not clear it.
-              (SELECT a.grade FROM attempts a WHERE a.concept_id = c.id AND a.${NOT_CORRECTION} ORDER BY a.id DESC LIMIT 1) AS last_grade,
-              (SELECT sc.context FROM session_concepts sc
-                WHERE sc.concept_id = c.id AND sc.context IS NOT NULL
-                ORDER BY sc.ts DESC LIMIT 1) AS last_context,
-              (SELECT a.repo FROM attempts a
-                WHERE a.concept_id = c.id AND a.repo IS NOT NULL AND trim(a.repo) <> ''
-                ORDER BY a.id DESC LIMIT 1) AS last_repo
-       FROM concepts c
-       LEFT JOIN mastery m ON m.concept_id = c.id
-       ORDER BY c.domain, c.tier, c.name`)
-        .all();
+                m.score, m.ease, m.interval_d, m.reps, m.next_review, m.last_seen,
+                -- The latest context a session logged for the concept; equal times go to the row written first.
+                (SELECT sc.context FROM session_concepts sc
+                  WHERE sc.concept_id = c.id AND sc.context IS NOT NULL
+                  ORDER BY sc.ts DESC, sc.rowid LIMIT 1) AS last_context
+         FROM concepts c
+         LEFT JOIN mastery m ON m.concept_id = c.id
+         ORDER BY c.domain, c.tier, c.name, c.id`)
+        .all().map((c) => {
+        const a = asked.get(c.id);
+        return {
+            ...c,
+            attempts: a?.attempts ?? 0,
+            passed: a?.passed ?? 0,
+            skipped: a?.skipped ?? 0,
+            corrected: a?.corrected ?? 0,
+            first_asked: a?.first_asked ?? null,
+            // The backlog rule's grade (OWED_SQL in store.ts): a correction does not clear it.
+            last_grade: a?.last_id != null ? lastGrade.get(a.last_id) : null,
+            last_repo: a?.last_repo_id != null ? lastRepo.get(a.last_repo_id) : null,
+        };
+    });
     const byId = new Map(conceptRows.map((r) => [r.id, r.slug]));
     // Edges travel as slugs so the page can link one concept card to another
     // without carrying the id space around with it.
@@ -771,51 +1294,19 @@ export function dashboardState(db) {
     // Every graded response, newest first, with its question and the tutor's
     // explanation. This is what makes a concept page a record of what you were
     // actually asked rather than a score.
-    const attempts = db
-        .prepare(`SELECT a.id, c.slug, c.name, c.domain, a.session_id, a.question, a.answer, a.feedback,
-              a.grade, a.difficulty AS tier, a.outcome, a.format, a.options, a.ts,
-              NULLIF(trim(COALESCE(a.repo, '')), '') AS repo, a.level,
-              -- A miss corrected from its explainer: when, and on which try.
-              fix.ts AS corrected_at,
-              CASE WHEN fix.id IS NULL THEN NULL
-                   ELSE (SELECT count(*) FROM attempt_retries r WHERE r.attempt_id = a.id) END AS corrected_try
-       FROM attempts a JOIN concepts c ON c.id = a.concept_id
-       LEFT JOIN attempts fix ON fix.retry_of = a.id
-       WHERE a.${NOT_CORRECTION}
-       ORDER BY a.id DESC
-       LIMIT ?`)
-        .all(ATTEMPT_LIMIT);
+    const attempts = attemptRows(db, ATTEMPT_LIMIT);
     // The context lines, which are what a concept means to *this* learner: the
-    // code that taught it. Grouped by session on the page.
-    const logged = db
-        .prepare(`SELECT sc.session_id, c.slug, c.name, c.domain, sc.context, sc.ts, sc.origin,
-              NULLIF(trim(COALESCE(g.repo, '')), '') AS repo
-       FROM session_concepts sc
-       JOIN concepts c ON c.id = sc.concept_id
-       LEFT JOIN gates g ON g.session_id = sc.session_id
-       ORDER BY sc.ts DESC`)
-        .all()
-        // `gates.repo` stays the worktree path -- the POSIX gate matches it against
-        // `git rev-parse --show-toplevel`. Every other repo on this page comes from
-        // `attempts`, already folded, so fold this one too or a project filter drops
-        // every context line a worktree session logged.
-        .map((r) => {
-        const row = r;
-        return { ...row, repo: row.repo ? projectKey(row.repo) : null };
-    });
-    const allTime = db
-        .prepare(`SELECT count(*) AS answers,
-              sum(CASE WHEN a.grade >= ? THEN 1 ELSE 0 END) AS passed,
-              sum(CASE WHEN a.grade < ? AND (a.outcome IS NULL OR a.outcome = 'answered') AND fix.id IS NULL THEN 1 ELSE 0 END) AS missed,
-              sum(CASE WHEN a.outcome IN ('declined','dont_know') AND fix.id IS NULL THEN 1 ELSE 0 END) AS skipped,
-              count(fix.id) AS corrected,
-              count(DISTINCT date(a.ts, 'localtime')) AS active_days,
-              min(a.ts) AS first_answer
-       FROM attempts a LEFT JOIN attempts fix ON fix.retry_of = a.id
-       WHERE a.${NOT_CORRECTION}`)
-        .get(PASSING_GRADE, PASSING_GRADE);
+    // code that taught it. Grouped by session on the page. Newest first and cut at
+    // `LOGGED_LIMIT`, with the total beside it.
+    const logged = loggedRows(db, projectFolder(), LOGGED_LIMIT);
+    const loggedTotal = logged.length < LOGGED_LIMIT
+        ? logged.length
+        : one(db, 'SELECT count(*) AS n FROM session_concepts sc JOIN concepts c ON c.id = sc.concept_id').n;
     const sessionCount = db.prepare('SELECT count(DISTINCT session_id) AS n FROM session_concepts').get().n;
-    const memory = memorySummary(db);
+    // The one read of evidence_events: the counts, the heartbeat and the session list all come from it.
+    const evidence = evidenceGroups(db);
+    const evidenceSummary = evidenceTotals(evidence);
+    const memory = memorySummary(db, evidenceSummary);
     const reuse = reuseSummary(db);
     return {
         generated_at: now.toISOString(),
@@ -824,6 +1315,10 @@ export function dashboardState(db) {
         timeline_days: TIMELINE_DAYS,
         attempts_shown: attempts.length,
         attempts_total: allTime.answers,
+        // The same disclosure for the context lines: shown is what travelled, total
+        // is every row, so a cut list cannot pass for the whole one.
+        logged_shown: logged.length,
+        logged_total: loggedTotal,
         // The user file's dials, before any project's overrides. Each project row
         // below carries the level and runway its own settings resolve to.
         config_scope: 'user',
@@ -841,9 +1336,9 @@ export function dashboardState(db) {
         },
         totals: {
             answers: allTime.answers,
-            passed: allTime.passed ?? 0,
-            missed: allTime.missed ?? 0,
-            skipped: allTime.skipped ?? 0,
+            passed: allTime.passed,
+            missed: allTime.missed,
+            skipped: allTime.skipped,
             corrected: allTime.corrected,
             mastered: concepts.filter((c) => c.mastered).length,
             due: concepts.filter((c) => c.due).length,
@@ -880,8 +1375,8 @@ export function dashboardState(db) {
         // because `/api/state` is a contract an older page still reads.
         memory,
         reuse,
-        health: healthSummary(db, config),
-        memory_sessions: memorySessions(db),
+        health: healthSummary(db, config, evidenceSummary),
+        memory_sessions: memorySessions(db, evidence),
         // The third workflow. Read from the files themselves on every load
         // (`artifacts.ts`): there is no table to fall out of step with the disk.
         artifacts: artifactRows(db),
@@ -1045,14 +1540,10 @@ export const CLI_ONLY = [
     { key: 'sync.target', why: 'writes memory to a shared folder' },
     { key: 'sync.device_id', why: 'pins this device\'s sync identity' },
 ];
-/**
- * Projects the Settings pages may write for: an inventory project whose
- * checkout still exists. The POST checks against this list, so the page can
- * never name an arbitrary path to write settings for.
- */
-export function configurableProjects(db) {
+/** The Settings pages' projects, from an inventory: a checkout that still has its `.git`. */
+function configurableFrom(inventory) {
     const out = new Map();
-    for (const p of projectInventory(db).projects) {
+    for (const p of inventory.projects) {
         // A checkout, not just a directory: `loadConfig` finds the project file
         // through the repository, so a folder without `.git` would show the user
         // settings as if they were this project's.
@@ -1064,6 +1555,59 @@ export function configurableProjects(db) {
     }
     return [...out.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
+/** The memoized list for a memo already in hand; derived with the inventory, so it expires with it. */
+const configurableOf = (memo, db, rebuild = false) => {
+    const slot = inventoryOf(memo, db, rebuild);
+    return (slot.configurable ??= configurableFrom(slot.value));
+};
+/**
+ * Projects the Settings pages may write for: an inventory project whose
+ * checkout still exists. The POST checks against this list, so the page can
+ * never name an arbitrary path to write settings for.
+ *
+ * Read from the per-cursor memo: the inventory behind it is six full-table
+ * scans. A caller that is about to write passes `fresh` and gets a rebuild, so
+ * a write is never validated against a minute-old picture of the filesystem;
+ * that rebuild becomes the memo's.
+ */
+export function configurableProjects(db, opts = {}) {
+    return configurableOf(memoFor(db), db, opts.fresh);
+}
+/** The project a `?project=` names, by its checkout or its inventory id. */
+const pickProject = (projects, root) => root ? projects.find((p) => p.id === root || p.inventory === root) ?? null : null;
+/**
+ * What `/api/settings` reads that the cursor does not cover, as a string that
+ * changes when any of it does.
+ *
+ * Files, by their stat and never by their content: the user file, and the named
+ * project's. A project the inventory knows from memory alone has no answers, so
+ * its settings file is in no cursor; a save from the terminal must still show on
+ * the next read. Beside them, the legacy `<checkout>/.eklavya.json`, because
+ * `loadConfig` still falls back to it for a project that has no settings file
+ * outside the checkout (until a session moves it), and the page shows the
+ * resolved values. It is a file a `git clone` may have brought, so it is
+ * statted from the place `loadConfig` finds it and its bytes go nowhere near a
+ * stamp.
+ *
+ * And when the project list inside the page was built. The list is the
+ * inventory's, which expires on its own clock: a page built late in the
+ * inventory's minute would otherwise carry that list a minute past the
+ * inventory's expiry, and offer (and refuse a write to) a project the next
+ * build would drop. With the build time in the stamp the page lives exactly as
+ * long as the older of its two sources.
+ */
+function settingsStamp(memo, db, root) {
+    const projects = configurableOf(memo, db);
+    // Served or rebuilt by the line above, so the slot is there.
+    const stamps = [String(memo.inventory.at), fileStamp(globalConfigPath())];
+    const project = pickProject(projects, root);
+    if (project) {
+        stamps.push(fileStamp(projectConfigPath(project.id)));
+        const checkout = findRepoConfig(project.id).repoRoot;
+        stamps.push(checkout ? fileStamp(path.join(checkout, LEGACY_REPO_CONFIG_FILE)) : '-');
+    }
+    return stamps.join('|');
+}
 const settingKeys = () => [...SETTINGS.map((f) => f.key), ...CLI_ONLY.map((c) => c.key)];
 /** What one file sets, key by key, in today's spelling: a key absent here inherits. */
 const setIn = (file) => {
@@ -1077,7 +1621,7 @@ const effectiveOf = (c) => Object.fromEntries(settingKeys().map((k) => [k, value
 /** `GET /api/settings?project=<checkout>`: both files and what they resolve to. */
 export function settingsState(db, root) {
     const projects = configurableProjects(db);
-    const project = root ? projects.find((p) => p.id === root || p.inventory === root) ?? null : null;
+    const project = pickProject(projects, root);
     return {
         fields: SETTINGS,
         cli_only: CLI_ONLY,
@@ -1114,7 +1658,8 @@ export function updateSetting(db, body) {
     }
     let root = null;
     if (b.scope === 'project') {
-        const p = configurableProjects(db).find((x) => x.id === b.project);
+        // A write is checked against the filesystem as it is, not as a minute ago.
+        const p = configurableProjects(db, { fresh: true }).find((x) => x.id === b.project);
         if (!p)
             return bad('That project is not one this dashboard can configure.');
         if (isGlobalOnlyKey(f.key))
@@ -1128,6 +1673,7 @@ export function updateSetting(db, body) {
     // so this refuses exactly what `eklavya config set` refuses, in its words.
     try {
         const { target } = applySetting(f.key, unset ? undefined : b.value, root);
+        forgetSettings(db);
         return { status: 200, body: { ok: true, key: f.key, target, unset } };
     }
     catch (err) {
@@ -1406,15 +1952,42 @@ const MASCOT_ASSETS = new Map([
 ]);
 /** The tips library, copied from node_modules at build by `copy-assets.mjs`. */
 const VENDOR = { '/vendor/driver-hints.js': 'text/javascript', '/vendor/driver-hints.css': 'text/css' };
+/** What a file that only changes with a release may be kept for: this browser, an hour. */
+const CACHE_HOUR = 'private, max-age=3600';
+/**
+ * Whether an `If-None-Match` header names `etag`. A comparison for a GET is
+ * weak (RFC 9110 §13.1.2), so `W/"x"` names `"x"`; the header may be a list,
+ * with any spacing, or `*` for any version at all. Anything that is not a
+ * quoted tag is ignored, never matched.
+ */
+export function etagMatches(header, etag) {
+    if (header === undefined)
+        return false;
+    if (header.trim() === '*')
+        return true;
+    return (header.match(/(?:W\/)?"[^"]*"/g) ?? []).some((tag) => tag.replace(/^W\//, '') === etag);
+}
+/** What every response carries: its type, `no-store`, `SECURITY_HEADERS`, then whatever the route overrides. The event stream, which is not sent in one piece, shares it. */
+const headersFor = (type, extra = {}) => ({
+    'content-type': type,
+    'cache-control': 'no-store',
+    ...SECURITY_HEADERS,
+    ...extra,
+});
+/**
+ * Every response goes out here, so every one carries `SECURITY_HEADERS`.
+ *
+ * JSON is never cached (`no-store`, the default): a dashboard read from a stale
+ * cache is one that lies about progress made ten seconds ago, which is the one
+ * thing it is for, and the server's own memo is what makes a repeat cheap, not
+ * the browser's. A file may be, because nothing about it moves with the
+ * learner: the tokens, the mascot and the tips library stay an hour
+ * (`CACHE_HOUR`); the page itself is `no-cache` with an `ETag`, so the browser
+ * keeps it but asks, in one round trip, whether it is still the one this
+ * server start wrote (the write token is in it). A caller passes `extra` to say so.
+ */
 function send(res, status, type, body, extra = {}) {
-    res.writeHead(status, {
-        'content-type': type,
-        // A dashboard read from a stale cache is a dashboard that lies about
-        // progress made ten seconds ago, which is the one thing it is for.
-        'cache-control': 'no-store',
-        ...SECURITY_HEADERS,
-        ...extra,
-    });
+    res.writeHead(status, headersFor(type, extra));
     res.end(body);
 }
 /**
@@ -1444,10 +2017,312 @@ export function fromLoopback(hostHeader, originHeader) {
     }
     return true;
 }
+/*
+ * Live updates: `GET /api/events`.
+ *
+ * What an open page needs is to be told that something changed, so it can fetch
+ * what. The stream carries one thing, the change cursor (`changeCursor`, the
+ * string `/api/state` carries in its `cursor`): `event: cursor` and `data:
+ * <cursor>` at once on connect, then one more each time it moves, and a
+ * `: keep-alive` comment every `keepAliveMs` so nothing between here and the
+ * browser closes a quiet stream. The payload stays one source of truth: the
+ * stream says *that*, `/api/state` says *what*. `/api/cursor` is unchanged, for
+ * older pages and for anything that polls.
+ *
+ * The writers are other processes (hooks, the MCP server, the CLI, the
+ * observer), so the server can only learn of a change by reading the database
+ * and the filesystem, which a watcher does for as long as a stream is open and
+ * not a moment longer:
+ *
+ * - The floor: `changeCursor` every `floorMs`. It is 0.5 to 3 ms, and it is
+ *   what keeps the stream correct on a filesystem where `fs.watch` is silent
+ *   (a network mount, an editor that replaces a file instead of writing it).
+ * - The early trigger: `fs.watch` on the database's `-wal` file, the user's
+ *   config file, the project config area and the artifacts folder, debounced by
+ *   `debounceMs` into one check. Every one of those is optional. A directory
+ *   that is not there yet, an `error` event: that watch is skipped or dropped
+ *   and the floor carries on. The `-wal` is watched through its directory,
+ *   filtered by name, because the file may not exist yet and is replaced when
+ *   the database is checkpointed; `-shm` and the database file are never
+ *   watched, because a reader touches them and the watcher's own reads must not
+ *   retrigger it.
+ *   The project config area and the artifacts folder hold their files one level
+ *   down (`<folder>/<file>`), and each folder is watched by itself, not through
+ *   one recursive watch: on Linux Node's recursive watch holds one watch per
+ *   file inode, so the first atomic rewrite of a file (a temporary file renamed
+ *   over it, which is how every config write is made, and how most editors save)
+ *   leaves the new file unwatched, and every later change to it went unseen. A
+ *   watch on the folder names each entry that is replaced in it, however often.
+ *   The area's own watch tells of a new or removed folder, and a watch is made
+ *   or dropped for it then.
+ * - On a change the memo is refreshed first (the state and the inventory, so
+ *   the fetch the event provokes is a repeat), then every stream is written.
+ *   Between changes the watcher costs a cursor read a second and no read route
+ *   waits on it; on a change it pays, once, for the rebuild the next read would
+ *   have made anyway, and that rebuild is the single thread's for as long as it
+ *   takes (the builders' cost, unchanged).
+ * - A write the dashboard itself accepted checks at once (`bump`) instead of
+ *   waiting for the floor, and does nothing when no stream is open.
+ *
+ * A stream that will not take a write (its buffer is full: the reader has not
+ * read for a long time) is cut, not buffered for; the browser reconnects and
+ * the connect event is the current cursor, so it loses nothing.
+ */
+/** How often the watcher reads `changeCursor` while a stream is open. The floor: correct even where `fs.watch` is not. */
+export const EVENTS_FLOOR_MS = 1000;
+/** How long after the last filesystem event the early check waits, so a burst of writes (a hook logging eight concepts) is one check. */
+export const EVENTS_DEBOUNCE_MS = 150;
+/** An open stream is written to this often when nothing changed, so a proxy or a browser does not close it for silence. */
+export const EVENTS_KEEPALIVE_MS = 25_000;
+/**
+ * Open streams at once; the next gets a 503. A browser allows six HTTP/1.1
+ * connections to one origin and every stream holds one for as long as it is
+ * open, so one tab uses one of its six and leaves the page five for its own
+ * fetches; the page closes its stream while its tab is hidden, which keeps the
+ * count at the tabs being read. Thirty-two is several browsers with several
+ * tabs each plus the odd `curl`, with room to spare, and still bounds what a
+ * client that opens streams in a loop can cost: a socket and a few bytes of
+ * writes each per change.
+ */
+export const EVENTS_MAX_STREAMS = 32;
+export const LIVE_DEFAULTS = {
+    floorMs: EVENTS_FLOOR_MS,
+    debounceMs: EVENTS_DEBOUNCE_MS,
+    keepAliveMs: EVENTS_KEEPALIVE_MS,
+    maxStreams: EVENTS_MAX_STREAMS,
+};
+const EVENTS_PATH = '/api/events';
+/** One watcher and its streams, for one server: nothing runs until the first stream opens and nothing outlives the last. */
+function createLive(db, opts) {
+    const { floorMs, debounceMs, keepAliveMs, maxStreams } = { ...LIVE_DEFAULTS, ...opts };
+    const streams = new Set();
+    /** The cursor the open streams have been sent last. */
+    let last = '';
+    let floor;
+    let keepAlive;
+    let debounce;
+    /** Set by `shutdown` and never cleared: the server it belongs to is closing and does not open again. */
+    let closed = false;
+    /** Every watch that is open, so `stop` can close each one and one that failed is not closed twice. */
+    const watchers = new Set();
+    const push = (res, chunk) => {
+        if (!res.write(chunk))
+            res.destroy();
+    };
+    const emit = (cursor) => {
+        for (const res of streams)
+            push(res, `event: cursor\ndata: ${cursor}\n\n`);
+    };
+    /**
+     * Reads the cursor; when it moved and someone is listening, refreshes the memo
+     * and tells them. Returns the cursor as read. Throws as `changeCursor` does.
+     */
+    const check = () => {
+        const cursor = changeCursor(db);
+        if (cursor === last)
+            return cursor;
+        last = cursor;
+        if (streams.size > 0) {
+            try {
+                warmMemo(db);
+            }
+            catch {
+                /* the fetch the event provokes builds it instead, and reports the error if it still fails */
+            }
+            emit(cursor);
+        }
+        return cursor;
+    };
+    /** A check from a timer, a file event or a write: nothing waits on it, so a failure (a busy or closed database) is only the next check's to retry. */
+    const run = () => {
+        try {
+            check();
+        }
+        catch {
+            /* the next check asks again */
+        }
+    };
+    /** A file event: check once `debounceMs` after the last of a burst. */
+    const early = () => {
+        clearTimeout(debounce);
+        debounce = setTimeout(run, debounceMs).unref();
+    };
+    const targets = () => {
+        const out = [];
+        if (!db.memory) {
+            const file = path.resolve(db.name);
+            out.push({ dir: path.dirname(file), match: (name) => name === `${path.basename(file)}-wal` });
+        }
+        const config = globalConfigPath();
+        out.push({ dir: path.dirname(config), match: (name) => name === path.basename(config) });
+        return out;
+    };
+    const trees = () => [
+        { root: projectsDir(), match: (file) => file === 'config.json' },
+        { root: artifactsDir(), match: () => true },
+    ];
+    /** One watch on one directory, not its subdirectories, or null when it cannot be made: optional, and the floor covers it. */
+    const watchDir = (dir, onName) => {
+        try {
+            const watcher = fs.watch(dir, { persistent: false, recursive: false }, (_event, name) => onName(name));
+            // A watch that fails is closed and forgotten, once; the floor carries on.
+            watcher.on('error', () => release(watcher));
+            watchers.add(watcher);
+            return watcher;
+        }
+        catch {
+            return null;
+        }
+    };
+    const release = (watcher) => {
+        watchers.delete(watcher);
+        watcher.close();
+    };
+    /**
+     * Which folder this is, not only what it is called: the inode and the time it was made. A watch is on a
+     * folder, so one removed and made again under the same name (before the area's event is read) is a
+     * folder the old watch will never hear from, and the filesystem may hand the new one the old inode: the
+     * time it was made is what tells them apart. `-` when it cannot be read.
+     */
+    const identity = (dir) => {
+        try {
+            const s = fs.statSync(dir, { bigint: true });
+            return `${s.ino}.${s.birthtimeNs}`;
+        }
+        catch {
+            return '-';
+        }
+    };
+    /**
+     * A watch on `root` for its folders, and one on each folder for its files. The
+     * root's own events (a folder made, renamed or removed) adopt what is there
+     * now: a watch for each new folder, none for one that has gone, a new one for
+     * one that was made again. The check they also ask for is what sees a file
+     * already written into a folder by the time its watch was made.
+     */
+    const watchTree = ({ root, match }) => {
+        const folders = new Map();
+        const adopt = () => {
+            let present;
+            try {
+                // The folders the cursor lists: no dot-names, no links (`artifactFiles`).
+                present = fs.readdirSync(root, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+                    .map((entry) => entry.name);
+            }
+            catch {
+                present = [];
+            }
+            for (const [name, { watcher, id }] of folders) {
+                // Gone, replaced by another folder of the name, or its watch failed (and was closed): forget it, and the
+                // loop below makes a new one if the folder is there.
+                const open = watchers.has(watcher);
+                if (open && present.includes(name) && identity(path.join(root, name)) === id)
+                    continue;
+                folders.delete(name);
+                if (open)
+                    release(watcher);
+            }
+            for (const name of present) {
+                if (folders.has(name))
+                    continue;
+                const dir = path.join(root, name);
+                // Read before the watch is made: a folder replaced in between is seen as changed by the next event.
+                const id = identity(dir);
+                const watcher = watchDir(dir, (file) => {
+                    if (file !== null && match(file))
+                        early();
+                });
+                if (watcher)
+                    folders.set(name, { watcher, id });
+            }
+        };
+        const rootWatch = watchDir(root, () => {
+            adopt();
+            early();
+        });
+        if (rootWatch)
+            adopt();
+    };
+    const watchFiles = () => {
+        for (const { dir, match } of targets()) {
+            watchDir(dir, (name) => {
+                if (name !== null && match(name))
+                    early();
+            });
+        }
+        for (const tree of trees())
+            watchTree(tree);
+    };
+    const start = () => {
+        floor = setInterval(run, floorMs).unref();
+        keepAlive = setInterval(() => {
+            for (const res of streams)
+                push(res, ': keep-alive\n\n');
+        }, keepAliveMs).unref();
+        watchFiles();
+    };
+    const stop = () => {
+        clearInterval(floor);
+        clearInterval(keepAlive);
+        clearTimeout(debounce);
+        for (const watcher of watchers)
+            watcher.close();
+        watchers.clear();
+    };
+    return {
+        connect(res) {
+            // A request already on a connection when `close()` ran (the next one of a
+            // pipelined pair, or a keep-alive request that was mid-flight) still reaches
+            // the handler: it must not open what `shutdown` just ended. The connection is
+            // told to close too, so this refusal is not what `server.close()` waits on.
+            if (closed)
+                return send(res, 503, 'text/plain', 'The dashboard is shutting down.\n', { connection: 'close' });
+            if (streams.size >= maxStreams)
+                return send(res, 503, 'text/plain', 'Too many open event streams.\n');
+            // Before anything is written, so a database that cannot be read is the
+            // route's ordinary 500. With streams already open, a change since the last
+            // check is sent to them first, so no stream is ever sent the same cursor twice.
+            const cursor = check();
+            res.writeHead(200, headersFor('text/event-stream; charset=utf-8'));
+            push(res, `event: cursor\ndata: ${cursor}\n\n`);
+            streams.add(res);
+            // A write to a dead socket can surface as an 'error' on the response; a
+            // stream that errors is a stream that is gone.
+            res.on('error', () => res.destroy());
+            res.on('close', () => {
+                if (streams.delete(res) && streams.size === 0)
+                    stop();
+            });
+            if (streams.size === 1)
+                start();
+        },
+        bump() {
+            if (streams.size > 0)
+                run();
+        },
+        shutdown() {
+            closed = true;
+            const open = [...streams];
+            streams.clear();
+            stop();
+            // A finished response is what lets `server.close` take its connection, kept alive or not: an
+            // idle one is closed at once, and without this the stream would hold the close open for ever.
+            for (const res of open)
+                res.end();
+        },
+    };
+}
+/**
+ * `opts.live` overrides the event stream's intervals and cap (`LIVE_DEFAULTS`);
+ * only tests have a reason to. `close()` ends the open streams and resolves
+ * once the server has closed.
+ */
 export function startDashboard(db, opts = {}) {
     const host = opts.host ?? '127.0.0.1';
     const wanted = opts.port ?? dashboardPort();
     const assets = path.join(moduleDir, 'assets');
+    const live = createLive(db, opts.live ?? {});
     // Per server start. Every write must carry it (see `acceptWrite`).
     const token = randomBytes(24).toString('hex');
     const json = (res, status, body) => send(res, status, 'application/json', JSON.stringify(body));
@@ -1503,6 +2378,9 @@ export function startDashboard(db, opts = {}) {
             }
             const out = route.handler(db, body);
             json(res, out.status, out.body);
+            // Whatever the handler changed is told to the open streams now, not at the
+            // next check; the answer above is already on its way, so the writer does not wait for it.
+            live.bump();
         });
     };
     const server = http.createServer((req, res) => {
@@ -1535,7 +2413,8 @@ export function startDashboard(db, opts = {}) {
             return acceptWrite(req, res, write);
         if (req.method !== 'GET' && req.method !== 'HEAD') {
             return send(res, 405, 'text/plain', `This route is read-only. Writes: ${Object.keys(WRITES).join(', ')}.\n`, {
-                allow: write ? 'GET, HEAD, POST' : 'GET, HEAD',
+                // A stream has no HEAD: there is nothing to answer without opening one.
+                allow: write ? 'GET, HEAD, POST' : url.pathname === EVENTS_PATH ? 'GET' : 'GET, HEAD',
             });
         }
         try {
@@ -1544,20 +2423,36 @@ export function startDashboard(db, opts = {}) {
             if (url.pathname === '/api/health') {
                 return send(res, 200, 'application/json', JSON.stringify({ app: 'eklavya', version: ownVersion(), pid: process.pid, db: dbPath() }));
             }
-            if (url.pathname === '/api/settings') {
-                return send(res, 200, 'application/json', JSON.stringify(settingsState(db, url.searchParams.get('project'))));
+            // The cursor as a stream (`createLive`). A GET only: a HEAD has no stream to
+            // open and falls through to the 404 it always had.
+            if (url.pathname === EVENTS_PATH && req.method === 'GET')
+                return live.connect(res);
+            // The reads below are served from the per-cursor memo (`memoFor`): the cursor
+            // is asked for first, and a build runs only when it moved or a minute passed.
+            // Not memoized, on purpose: `/api/cursor`, which must always say what the
+            // database says now; `/api/health`, which names the process; one feedback
+            // item, which a POST acknowledges; and a correction, which is graded live.
+            const pageKey = url.pathname + url.search;
+            const reply = (body) => body === null ? send(res, 404, 'application/json', '{"error":"no such entry"}') : send(res, 200, 'application/json', body);
+            if (url.pathname === SETTINGS_PATH) {
+                const memo = memoFor(db);
+                const project = url.searchParams.get('project');
+                return reply(pageBody(memo, pageKey, () => JSON.stringify(settingsState(db, project)), {
+                    expires: true,
+                    stamp: () => settingsStamp(memo, db, project),
+                }));
             }
             if (url.pathname === '/api/cursor') {
                 return send(res, 200, 'application/json', JSON.stringify({ cursor: changeCursor(db) }));
             }
             if (url.pathname === '/api/state') {
-                return send(res, 200, 'application/json', JSON.stringify(dashboardState(db)));
+                return reply(stateBody(memoFor(db), db));
             }
             // The memory timeline is a paged resource rather than part of the state
             // payload: the corpus is the one thing here that grows without bound.
             if (url.pathname === '/api/memory') {
                 const g = (k) => url.searchParams.get(k);
-                return send(res, 200, 'application/json', JSON.stringify(memoryPage(db, {
+                return reply(pageBody(memoFor(db), pageKey, () => JSON.stringify(memoryPage(db, {
                     project: g('project'),
                     session: g('session'),
                     type: g('type'),
@@ -1567,19 +2462,19 @@ export function startDashboard(db, opts = {}) {
                     until: g('until'),
                     page: Number(g('page')) || 1,
                     per: Number(g('per')) || MEMORY_PER,
-                })));
+                }))));
             }
             if (url.pathname === '/api/projects') {
-                return send(res, 200, 'application/json', JSON.stringify(projectInventory(db)));
+                return reply(Buffer.from(JSON.stringify(inventoryOf(memoFor(db), db).value)));
             }
             if (url.pathname === '/api/memory/sessions') {
                 const g = (k) => url.searchParams.get(k);
-                return send(res, 200, 'application/json', JSON.stringify(memorySessionPage(db, {
+                return reply(pageBody(memoFor(db), pageKey, () => JSON.stringify(memorySessionPage(db, {
                     project: g('project'),
                     session: g('session'),
                     page: Number(g('page')) || 1,
                     per: Number(g('per')) || MEMORY_PER,
-                })));
+                }))));
             }
             if (url.pathname === '/api/feedback') {
                 const out = feedbackItem(db, url.searchParams.get('id'));
@@ -1587,17 +2482,17 @@ export function startDashboard(db, opts = {}) {
             }
             if (url.pathname === '/api/feedback/list') {
                 const g = (k) => url.searchParams.get(k);
-                return send(res, 200, 'application/json', JSON.stringify(listAcknowledged(db, { project: g('project'), page: Number(g('page')) || 1, per: Number(g('per')) || 20 })));
+                return reply(pageBody(memoFor(db), pageKey, () => JSON.stringify(listAcknowledged(db, { project: g('project'), page: Number(g('page')) || 1, per: Number(g('per')) || 20 }))));
             }
             if (url.pathname === '/api/attempts/correction') {
                 const out = correctionState(db, Number(url.searchParams.get('id')));
                 return send(res, out.status, 'application/json', JSON.stringify(out.body));
             }
             if (url.pathname === '/api/memory/entry') {
-                const entry = memoryEntry(db, Number(url.searchParams.get('id')));
-                if (!entry)
-                    return send(res, 404, 'application/json', '{"error":"no such entry"}');
-                return send(res, 200, 'application/json', JSON.stringify(entry));
+                return reply(pageBody(memoFor(db), pageKey, () => {
+                    const entry = memoryEntry(db, Number(url.searchParams.get('id')));
+                    return entry ? JSON.stringify(entry) : null;
+                }));
             }
             if (url.pathname.startsWith('/artifacts/')) {
                 let id;
@@ -1618,7 +2513,7 @@ export function startDashboard(db, opts = {}) {
                         return send(res, 400, 'text/plain', 'thumb is ink or paper');
                     return send(res, 200, 'image/svg+xml; charset=utf-8', artifactThumb(file, thumb), {
                         'content-security-policy': ARTIFACT_CSP,
-                        'cache-control': 'private, max-age=3600',
+                        'cache-control': CACHE_HOUR,
                     });
                 }
                 const embed = url.searchParams.has('embed');
@@ -1641,17 +2536,26 @@ export function startDashboard(db, opts = {}) {
             }
             const mascotAsset = MASCOT_ASSETS.get(url.pathname);
             if (mascotAsset) {
-                return send(res, 200, mascotAsset[1], fs.readFileSync(path.join(assets, mascotAsset[0])));
+                return send(res, 200, mascotAsset[1], fs.readFileSync(path.join(assets, mascotAsset[0])), { 'cache-control': CACHE_HOUR });
             }
             if (url.pathname === '/tokens.css') {
-                return send(res, 200, 'text/css', localTokens(fs.readFileSync(path.join(assets, 'tokens.css'), 'utf8')));
+                return send(res, 200, 'text/css', localTokens(fs.readFileSync(path.join(assets, 'tokens.css'), 'utf8')), {
+                    'cache-control': CACHE_HOUR,
+                });
             }
             if (url.pathname === '/' || url.pathname === '/index.html') {
                 // The write token rides in the page itself: a hostile origin cannot read
                 // this response, so it cannot learn the token to send back.
                 const html = fs.readFileSync(path.join(assets, 'dashboard.html'), 'utf8')
                     .replace('<meta name="eklavya-token" content="">', `<meta name="eklavya-token" content="${token}">`);
-                return send(res, 200, 'text/html; charset=utf-8', html);
+                // The tag is a hash of what is sent, so a new server start (a new token)
+                // changes it, and so does an edit to the file on disk, which the page's
+                // own development loop relies on a reload to pick up.
+                const etag = `"${createHash('sha256').update(html).digest('hex').slice(0, 32)}"`;
+                const headers = { etag, 'cache-control': 'no-cache' };
+                if (etagMatches(req.headers['if-none-match'], etag))
+                    return send(res, 304, 'text/html; charset=utf-8', '', headers);
+                return send(res, 200, 'text/html; charset=utf-8', html, headers);
             }
             return send(res, 404, 'text/plain', 'not found');
         }
@@ -1669,7 +2573,32 @@ export function startDashboard(db, opts = {}) {
             const addr = server.address();
             /* c8 ignore next -- a TCP listener's address() is always an object; a string is a pipe */
             const port = typeof addr === 'object' && addr ? addr.port : wanted;
-            resolve({ url: `http://${host}:${port}`, close: () => server.close() });
+            // The daemon starts at SessionStart, long before anyone opens the page, so
+            // the first build is made now rather than by the first request. After
+            // 'listening' and off the current turn, so neither the bind nor a probe of
+            // `/api/health` waits on it; unref'd, so it never holds a process or a test
+            // open; cancelled by `close()`; and a failure of any kind (a database that
+            // is closed, busy or locked) only means the first request builds it instead.
+            const warming = setImmediate(() => {
+                try {
+                    warmMemo(db);
+                }
+                catch {
+                    /* the first request builds it, and reports the error if it still fails */
+                }
+            });
+            warming.unref();
+            resolve({
+                url: `http://${host}:${port}`,
+                // Ends every open stream first: `server.close` waits for every connection,
+                // and an event stream never ends by itself. Resolves once the server has
+                // closed; calling it again is harmless and resolves too.
+                close: () => {
+                    clearImmediate(warming);
+                    live.shutdown();
+                    return new Promise((done) => server.close(() => done()));
+                },
+            });
         });
         server.listen(wanted, host);
     });