@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/db/queries.js

@@ -4,21 +4,27 @@
 // omitted, a query spans every projected session (a single Blacksmith
 // instance is one continuously-running factory, so "no session filter"
 // is the normal case; a session filter is for debugging one run).
-import { and, eq, gte, inArray, lte } from 'drizzle-orm';
+import { and, eq, gte, inArray, isNotNull, lte, max, sql } from 'drizzle-orm';
 import { isOperatorActor } from '../actors.js';
-import { foldAgents, liveAgents as foldLiveAgents, isWorkingAt, REGISTRY_EVENT_TYPES, } from '../agents-registry.js';
+import { DISPATCH_EVENT_TYPE, ERROR_EVENT_TYPE, foldAgents, liveAgents as foldLiveAgents, isWorkingAt, JUDGE_REPORT_EVENT_TYPE, JUDGE_VERDICT_EVENT_TYPE, REGISTRY_EVENT_TYPES, TASK_RESULT_EVENT_TYPE, } from '../agents-registry.js';
+import { isAuditAxisRowId } from '../audit.js';
+import { readTokenUsage } from '../budgetAlarm.js';
+import { SmithError } from '../errors.js';
 import { compareLogOrder, isLaterEvent, parseEventId, ROOT_EVENT_TYPE } from '../events.js';
 import { OPEN_FINDING_STATUSES, WAIVABLE_STATUSES } from '../findings.js';
 import { waveLayers } from '../graph.js';
+import { JUDGE_ROLES } from '../judgeRoles.js';
+import { FACTORY_PROJECT_NAME, normalizeProjectName } from '../projectName.js';
 import { judgeFailureKind } from '../providers/types.js';
 import { severityRank } from '../severity.js';
-import { epicOfTaskId, taskIdsMatch } from '../taskId.js';
-import { TERMINAL_OK_TASK_STATUSES, TERMINAL_TASK_STATUSES } from '../taskStatus.js';
+import { bareTaskId, epicOfTaskId, taskIdsMatch } from '../taskId.js';
+import { CLOSED_TO_FURTHER_WORK, TERMINAL_OK_TASK_STATUSES, TERMINAL_TASK_STATUSES, } from '../taskStatus.js';
 import { loadTaxonomy } from '../taxonomy.js';
 import { WAIVABLE_SEVERITIES } from '../waivers.js';
-import { agents, artifacts, dispatches, edges, epics, errors, eventsRaw, findings, lessons, milestones, prompts, sessions, tasks, waivers, } from './schema.js';
+import { unanimousEpicProjects } from './projector.js';
+import { agents, artifacts, dispatches, edges, epics, errors, eventsRaw, findings, lessons, milestones, operatorFeedback, prompts, sessions, tasks, waivers, } from './schema.js';
 /** Phase 6b default: every event/task/etc. logged before the project dimension existed. */
-export const DEFAULT_PROJECT = 'black-smith';
+export const DEFAULT_PROJECT = FACTORY_PROJECT_NAME;
 /**
  * `null` (never-tagged, pre-Phase-6b) reads as DEFAULT_PROJECT, same as the
  * schema.ts columns' doc comment promises. Project scoping is applied
@@ -31,7 +37,7 @@ export const DEFAULT_PROJECT = 'black-smith';
  * array — one filter step ahead of the aggregation, not a SQL rewrite).
  */
 function projectOf(value) {
-    return value ?? DEFAULT_PROJECT;
+    return normalizeProjectName(value ?? DEFAULT_PROJECT);
 }
 /**
  * The session narrowing for one `session_id` column: `IN (lineage)` when the
@@ -205,11 +211,19 @@ function projectedContinuations(db, sessionId) {
     }
     return out;
 }
+/**
+ * `scope.project`, normalized through `normalizeProjectName` -- the one place
+ * a caller's REQUESTED project value (an old bookmark, a CLI `--project
+ * black-smith`) is read, so every comparison against it sees today's
+ * spelling without every call site having to remember to normalize first.
+ */
+function scopeProject(scope) {
+    return scope.project === undefined ? undefined : normalizeProjectName(scope.project);
+}
 /** Filters an already-fetched row array to `scope.project`; a no-op in global mode (project omitted). */
 function filterByProject(rows, scope) {
-    return scope.project !== undefined
-        ? rows.filter((r) => projectOf(r.project) === scope.project)
-        : rows;
+    const project = scopeProject(scope);
+    return project !== undefined ? rows.filter((r) => projectOf(r.project) === project) : rows;
 }
 /** Rows in the order the log wrote them, oldest first. Never mutates the input. */
 function inLogOrder(rows) {
@@ -328,14 +342,31 @@ function epicTokenMaps(db, scope, taskRows) {
     }
     const epicOf = epicResolver(epicByTask);
     const spentByEpic = new Map();
+    const unmeasuredByEpic = new Map();
     for (const row of taskResultRows(db, scope)) {
         const epicId = epicOf(resultTaskId(row));
         if (!epicId)
             continue;
-        const total = row.payload.token_usage?.total_tokens ?? 0;
-        spentByEpic.set(epicId, (spentByEpic.get(epicId) ?? 0) + total);
+        const usage = readTokenUsage(row.payload.token_usage);
+        if (usage.measured) {
+            spentByEpic.set(epicId, (spentByEpic.get(epicId) ?? 0) + usage.total);
+        }
+        else {
+            spentByEpic.set(epicId, spentByEpic.get(epicId) ?? 0);
+            unmeasuredByEpic.set(epicId, (unmeasuredByEpic.get(epicId) ?? 0) + 1);
+        }
     }
-    return { budgetByEpic, spentByEpic };
+    return { budgetByEpic, spentByEpic, unmeasuredByEpic };
+}
+function epicTokenSpends(maps) {
+    const { budgetByEpic, spentByEpic, unmeasuredByEpic } = maps;
+    const epicIds = new Set([...budgetByEpic.keys(), ...spentByEpic.keys()]);
+    return [...epicIds].sort().map((epicId) => ({
+        epicId,
+        tokensSpent: spentByEpic.get(epicId) ?? 0,
+        tokensBudget: budgetByEpic.get(epicId) ?? null,
+        unmeasured: unmeasuredByEpic.get(epicId) ?? 0,
+    }));
 }
 /**
  * NEXT hides the statuses the plan has nothing left to ask of — every
@@ -404,6 +435,76 @@ function milestoneTaskRefs(milestoneTasks, allTaskRows, edgeRows) {
     }));
     return { recentDone, nextUp };
 }
+/**
+ * DS4 S5b fix round 1 — folds one `task_status` into the same grouping
+ * `ui/src/lib/kanban.ts`'s `COLUMN_FOR_STATUS` already uses for the Kanban
+ * board's columns, condensed from its 5 (+2 hidden) columns to the Roadmap's
+ * 5:
+ *   - Kanban's "Todo" column (todo, ready) -> 'todo'.
+ *   - Kanban's "Reviewing" column (reviewing, merging) -> 'review'.
+ *   - Kanban's "Completed" column (completed, waived) -> 'done': exactly
+ *     `TERMINAL_OK_TASK_STATUSES`, the same set `tasksCompleted` on the same
+ *     payload already uses, so the two numbers never disagree (fix round 1,
+ *     finding 1).
+ *   - `superseded` -> its own bucket, not `done`: a replanned-away task ended
+ *     the diff, not well, and folding it into `done` read an epic that was
+ *     replanned away as fully shipped. Kept out of the switch's `default` on
+ *     purpose, same reason: nobody confuses it with the fail-open case below.
+ *   - Everything else (Kanban's "In progress" and "Blocked" columns, plus
+ *     `failed`) -> 'inProgress': still open work, whether or not somebody is
+ *     actively on it right now. `failed` is terminal to the projector but a
+ *     person is still holding it (taskStatus.ts's HELD_OPEN_BY_AN_OPERATOR),
+ *     same as `escalated`/`blocked` already here. A status this switch
+ *     doesn't yet know about (taxonomy.yml adding a 13th tomorrow) falls here
+ *     too — open rather than silently counted as done.
+ * Exhaustive over this fold (every input lands in exactly one bucket), so the
+ * five counts a caller builds from it always sum to the row count they were
+ * built from.
+ */
+export function statusBucketForTaskStatus(taskStatus) {
+    if (TERMINAL_OK_TASK_STATUSES.has(taskStatus))
+        return 'done';
+    switch (taskStatus) {
+        case 'todo':
+        case 'ready':
+            return 'todo';
+        case 'reviewing':
+        case 'merging':
+            return 'review';
+        case 'superseded':
+            return 'superseded';
+        default:
+            return 'inProgress';
+    }
+}
+function countStatuses(rows) {
+    const counts = { done: 0, review: 0, inProgress: 0, todo: 0, superseded: 0 };
+    for (const row of rows)
+        counts[statusBucketForTaskStatus(row.taskStatus)] += 1;
+    return counts;
+}
+/**
+ * DS4 S5b fix round 1 — EpicStatus from a StatusCounts + its total, over the
+ * epic's LIVE tasks (`tasksTotal` minus `superseded`): a replanned-away task
+ * is not part of what's left to ship, so it neither counts toward `done` nor
+ * holds the epic open. Every live task done is `done`; any task in the
+ * review or inProgress buckets means at least `in_progress`, rising to
+ * `review` only when every non-done live task is itself in the review bucket
+ * (no inProgress, no todo left over); some tasks done with the rest not
+ * all done is `in_progress` even between waves; otherwise, with nothing
+ * done and nothing open yet, `todo` — also the answer for a zero-task epic
+ * and for an epic whose tasks are ALL superseded (`live === 0`, so
+ * `done === live` is never true).
+ */
+function epicStatusFromCounts(counts, tasksTotal) {
+    const live = tasksTotal - counts.superseded;
+    if (live > 0 && counts.done === live)
+        return 'done';
+    if (counts.review > 0 || counts.inProgress > 0) {
+        return counts.inProgress === 0 && counts.todo === 0 ? 'review' : 'in_progress';
+    }
+    return counts.done > 0 ? 'in_progress' : 'todo';
+}
 /**
  * Join factory/specs/roadmap.md's milestones (db/schema.ts's `milestones`
  * table) with each milestone's mapped epics' task/token stats. A milestone
@@ -414,19 +515,27 @@ function milestoneTaskRefs(milestoneTasks, allTaskRows, edgeRows) {
  */
 function milestoneProgressRows(db, scope = {}, opts = {}) {
     const allMilestoneRows = db.select().from(milestones).orderBy(milestones.sequence).all();
-    const milestoneRows = scope.project !== undefined
-        ? allMilestoneRows.filter((m) => m.project === scope.project)
+    const project = scopeProject(scope);
+    const milestoneRows = project !== undefined
+        ? allMilestoneRows.filter((m) => m.project === project)
         : allMilestoneRows;
     if (milestoneRows.length === 0)
         return [];
     const taskRows = allTasksForScope(db, scope);
-    const { budgetByEpic, spentByEpic } = epicTokenMaps(db, scope, taskRows);
+    const { budgetByEpic, spentByEpic, unmeasuredByEpic } = epicTokenMaps(db, scope, taskRows);
     const edgeSessionCond = scopedToSessions(edges.sessionId, scope);
     const edgeRows = opts.includeTaskRefs
         ? edgeSessionCond
             ? db.select().from(edges).where(edgeSessionCond).all()
             : db.select().from(edges).all()
         : [];
+    const dispatchStartByTask = earliestDispatchByTask(db, scope);
+    // DS4 S5b — both prefetched once per call: prUrlByEpic is one scan of
+    // eventsRaw (same read kanban() shares via prUrlsByEpic()); epicPromptMemo
+    // bounds epicSourcePrompt()'s lineage walk to once per distinct epic id,
+    // not once per task, mirroring dispatchStartByTask's per-call prefetch above.
+    const prUrlByEpic = prUrlsByEpic(db);
+    const epicPromptMemo = new Map();
     return milestoneRows.map((m) => {
         const epicIds = JSON.parse(m.epicIds);
         const epicSet = new Set(epicIds);
@@ -435,8 +544,10 @@ function milestoneProgressRows(db, scope = {}, opts = {}) {
         let tokensSpent = 0;
         let tokensBudget = 0;
         let hasBudget = false;
+        let unmeasured = 0;
         for (const epicId of epicIds) {
             tokensSpent += spentByEpic.get(epicId) ?? 0;
+            unmeasured += unmeasuredByEpic.get(epicId) ?? 0;
             const budget = budgetByEpic.get(epicId);
             if (budget !== undefined) {
                 tokensBudget += budget;
@@ -446,6 +557,28 @@ function milestoneProgressRows(db, scope = {}, opts = {}) {
         const refs = opts.includeTaskRefs
             ? milestoneTaskRefs(milestoneTasks, taskRows, edgeRows)
             : undefined;
+        const { startedAt, finishedAt } = taskDateRange(milestoneTasks, dispatchStartByTask);
+        const epicDates = epicIds.map((epicId) => {
+            const epicTasks = milestoneTasks.filter((t) => t.epicId === epicId);
+            const statusCounts = countStatuses(epicTasks);
+            let sourcePrompt = null;
+            if (epicPromptMemo.has(epicId)) {
+                sourcePrompt = epicPromptMemo.get(epicId) ?? null;
+            }
+            else if (epicTasks[0] !== undefined) {
+                sourcePrompt = epicSourcePrompt(db, epicTasks[0].sessionId);
+                epicPromptMemo.set(epicId, sourcePrompt);
+            }
+            return {
+                epicId,
+                ...taskDateRange(epicTasks, dispatchStartByTask),
+                statusCounts,
+                status: epicStatusFromCounts(statusCounts, epicTasks.length),
+                project: m.project,
+                prUrl: prUrlByEpic.get(epicId) ?? null,
+                sourcePrompt,
+            };
+        });
         return {
             milestoneId: m.milestoneId,
             name: m.name,
@@ -455,15 +588,73 @@ function milestoneProgressRows(db, scope = {}, opts = {}) {
             epicIds,
             tasksTotal: milestoneTasks.length,
             tasksCompleted,
+            statusCounts: countStatuses(milestoneTasks),
             tokensSpent,
             tokensBudget: hasBudget ? tokensBudget : null,
+            unmeasured,
             project: m.project,
             kind: m.kind,
             errorIssuesEnabled: m.errorIssues,
+            startedAt,
+            finishedAt,
+            epics: epicDates,
             ...(refs ? { recentDone: refs.recentDone, nextUp: refs.nextUp } : {}),
         };
     });
 }
+/**
+ * Every task's earliest `dispatch_decision` timestamp, across the whole
+ * scope, in one query — not per milestone or per epic, so a roadmap with N
+ * milestones costs one scan of `dispatches` rather than N. A task never
+ * dispatched has no entry. Shared by taskDateRange()'s milestone-level and
+ * per-epic rollups.
+ */
+function earliestDispatchByTask(db, scope) {
+    const sessionCond = scopedToSessions(dispatches.sessionId, scope);
+    const rows = sessionCond
+        ? db
+            .select({ taskId: dispatches.taskId, ts: dispatches.ts })
+            .from(dispatches)
+            .where(sessionCond)
+            .all()
+        : db.select({ taskId: dispatches.taskId, ts: dispatches.ts }).from(dispatches).all();
+    const earliest = new Map();
+    for (const row of rows) {
+        if (!row.taskId)
+            continue;
+        const current = earliest.get(row.taskId);
+        if (current === undefined || row.ts < current)
+            earliest.set(row.taskId, row.ts);
+    }
+    return earliest;
+}
+/**
+ * `startedAt` is the earliest dispatch among a set of task rows (via
+ * `dispatchStartByTask`, see earliestDispatchByTask()), or `null` if none of
+ * them has one. `finishedAt` is the latest `terminalAt`, but only once every
+ * row is terminal — see MilestoneProgress.startedAt for why these are the
+ * right sources. Shared by the milestone-level and per-epic rollups in
+ * milestoneProgressRows() so the two never disagree about how a date is
+ * derived.
+ */
+function taskDateRange(rows, dispatchStartByTask) {
+    let startedAt = null;
+    let finishedAt = null;
+    let allTerminal = true;
+    for (const row of rows) {
+        const dispatchedAt = dispatchStartByTask.get(row.taskId);
+        if (dispatchedAt !== undefined && (startedAt === null || dispatchedAt < startedAt)) {
+            startedAt = dispatchedAt;
+        }
+        if (!TERMINAL_TASK_STATUSES.has(row.taskStatus)) {
+            allTerminal = false;
+        }
+        else if (row.terminalAt !== null && (finishedAt === null || row.terminalAt > finishedAt)) {
+            finishedAt = row.terminalAt;
+        }
+    }
+    return { startedAt, finishedAt: allTerminal ? finishedAt : null };
+}
 /** Roadmap page (§5.4): every milestone with its progress + mini-timeline, in roadmap.md order. */
 export function roadmapPage(db, scope = {}) {
     return milestoneProgressRows(db, scope, { includeTaskRefs: true });
@@ -505,6 +696,118 @@ function allAgentsForScope(db, scope) {
         return a.taskId !== null && scopedTasks.some((t) => taskIdsMatch(a.taskId, t.taskId));
     });
 }
+/**
+ * The projects each session worked on, keyed by session id.
+ *
+ * Two sources, unioned. The tasks a session owns (tasks.session_id: the
+ * first session to touch a task) keep the rule they always had, default
+ * project included. But a wave session is a continuation that runs the tasks
+ * its epic session added, so it owns almost none: owning alone left most
+ * sessions with no project at all. So every task id its events carry and
+ * every task and epic its agents name count too, resolved against the tasks
+ * table — taskIdsMatch, because the log spells one task both bare and
+ * epic-qualified; an epic, or a ref naming an epic (`<epic>/integration`),
+ * through the project its tasks agree on.
+ *
+ * Only the session's own rows: a continuation can start from another
+ * project's epic, so the lineage is never unioned in. A ref nothing answers
+ * for, or a bare id two projects share, adds nothing — no guess, and no
+ * fallback to the default project. Three queries whatever the session count.
+ */
+function sessionProjects(db, scope) {
+    const bySession = new Map();
+    const add = (sessionId, project) => {
+        const set = bySession.get(sessionId) ?? new Set();
+        set.add(project);
+        bySession.set(sessionId, set);
+    };
+    for (const t of allTasksForScope(db, scope))
+        add(t.sessionId, projectOf(t.project));
+    // Every task, not the scoped ones: a bare id is only unambiguous if no
+    // other project's task shares it, and only the whole table can say so.
+    const allTasks = db
+        .select({ taskId: tasks.taskId, epicId: tasks.epicId, project: tasks.project })
+        .from(tasks)
+        .all()
+        .map((t) => ({ ...t, project: t.project === null ? null : normalizeProjectName(t.project) }));
+    const byId = new Map(allTasks.map((t) => [t.taskId, t]));
+    const byBare = new Map();
+    for (const t of allTasks) {
+        const bare = bareTaskId(t.taskId);
+        byBare.set(bare, [...(byBare.get(bare) ?? []), t]);
+    }
+    const epicProject = unanimousEpicProjects(allTasks);
+    const refProject = (ref) => {
+        const exact = byId.get(ref)?.project;
+        if (exact)
+            return exact;
+        const refEpic = epicOfTaskId(ref);
+        const matched = new Set();
+        for (const t of byBare.get(bareTaskId(ref)) ?? []) {
+            // A qualified ref names its epic: another epic's bare row is not it.
+            if (refEpic !== null && t.epicId !== null && t.epicId !== refEpic)
+                continue;
+            if (t.project !== null && taskIdsMatch(ref, t.taskId))
+                matched.add(t.project);
+        }
+        if (matched.size > 1)
+            return null;
+        return [...matched][0] ?? epicProject.get(epicOfTaskId(ref) ?? ref) ?? null;
+    };
+    const wanted = scopeProject(scope);
+    const addRef = (sessionId, project) => {
+        if (project && (wanted === undefined || project === wanted))
+            add(sessionId, project);
+    };
+    const eventRefs = db
+        .selectDistinct({ sessionId: eventsRaw.sessionId, taskId: eventsRaw.taskId })
+        .from(eventsRaw)
+        .where(and(isNotNull(eventsRaw.taskId), scopedToSessions(eventsRaw.sessionId, scope)))
+        .all();
+    for (const e of eventRefs)
+        addRef(e.sessionId, refProject(e.taskId));
+    const agentRefs = db
+        .selectDistinct({ sessionId: agents.sessionId, taskId: agents.taskId, epicId: agents.epicId })
+        .from(agents)
+        .where(scopedToSessions(agents.sessionId, scope))
+        .all();
+    for (const a of agentRefs) {
+        if (a.taskId !== null)
+            addRef(a.sessionId, refProject(a.taskId));
+        if (a.epicId !== null)
+            addRef(a.sessionId, epicProject.get(a.epicId));
+    }
+    return bySession;
+}
+/**
+ * One grouped query, not one query per session (plan B, DS8). A title never
+ * comes from prompt text (a prompt is whatever the operator typed). It is
+ * derived from the epic of the session's earliest dispatched agent: the
+ * session id itself when it starts with that epic id and a dash (it names
+ * the epic and tells sibling sessions of one epic apart), else the epic id.
+ * A session with no dispatched agent has no title.
+ */
+function sessionTitles(db, scope) {
+    const titles = new Map();
+    const agentCond = scopedToSessions(agents.sessionId, scope);
+    const agentRows = agentCond
+        ? db.select().from(agents).where(agentCond).all()
+        : db.select().from(agents).all();
+    const agentsBySession = new Map();
+    for (const a of agentRows) {
+        const list = agentsBySession.get(a.sessionId) ?? [];
+        list.push(a);
+        agentsBySession.set(a.sessionId, list);
+    }
+    for (const [sessionId, rows] of agentsBySession) {
+        const earliest = inLogOrder(rows.map((a) => ({ ts: a.dispatchedAt, eventId: a.id, row: a })))[0];
+        const epicId = earliest?.row.epicId;
+        if (!epicId)
+            continue;
+        titles.set(sessionId, sessionId.startsWith(`${epicId}-`) ? sessionId : epicId);
+    }
+    return titles;
+}
 /**
  * Every projected session, most recently active first.
  *
@@ -534,12 +837,8 @@ export function runningSessions(db, scope = {}, opts = {}) {
             workingBySession.set(a.sessionId, (workingBySession.get(a.sessionId) ?? 0) + 1);
         }
     }
-    const projectsBySession = new Map();
-    for (const t of allTasksForScope(db, scope)) {
-        const set = projectsBySession.get(t.sessionId) ?? new Set();
-        set.add(projectOf(t.project));
-        projectsBySession.set(t.sessionId, set);
-    }
+    const projectsBySession = sessionProjects(db, scope);
+    const titles = sessionTitles(db, scope);
     // What each session did most recently. events_raw is not guaranteed to come
     // back in ts order, so the latest row is chosen by comparison rather than by
     // trusting scan order — and isLaterEvent settles a tie on ts the same way
@@ -548,6 +847,7 @@ export function runningSessions(db, scope = {}, opts = {}) {
     const eventQuery = db
         .select({
         sessionId: eventsRaw.sessionId,
+        taskId: eventsRaw.taskId,
         ts: eventsRaw.ts,
         eventType: eventsRaw.eventType,
         eventId: eventsRaw.eventId,
@@ -559,6 +859,43 @@ export function runningSessions(db, scope = {}, opts = {}) {
         if (seen === undefined || isLaterEvent(e, seen))
             lastEvent.set(e.sessionId, e);
     }
+    // A dispatch's role lives in its payload and its task's title in `tasks`;
+    // both are read only for the sessions whose last event is a dispatch.
+    const dispatchIds = [...lastEvent.values()]
+        .filter((e) => e.eventType === 'dispatch_decision')
+        .map((e) => e.eventId);
+    const roleByEvent = new Map();
+    const titleByTask = new Map();
+    if (dispatchIds.length > 0) {
+        for (const r of db
+            .select({ eventId: eventsRaw.eventId, payload: eventsRaw.payload })
+            .from(eventsRaw)
+            .where(inArray(eventsRaw.eventId, dispatchIds))
+            .all()) {
+            const role = JSON.parse(r.payload).agent_role;
+            if (typeof role === 'string')
+                roleByEvent.set(r.eventId, role);
+        }
+        const taskIds = [...lastEvent.values()].flatMap((e) => (e.taskId ? [e.taskId] : []));
+        if (taskIds.length > 0) {
+            for (const t of db
+                .select({ taskId: tasks.taskId, title: tasks.title })
+                .from(tasks)
+                .where(inArray(tasks.taskId, taskIds))
+                .all()) {
+                titleByTask.set(t.taskId, t.title);
+            }
+        }
+    }
+    const lastStep = (sessionId) => {
+        const e = lastEvent.get(sessionId);
+        if (e?.eventType !== 'dispatch_decision')
+            return { role: null, task: null };
+        return {
+            role: roleByEvent.get(e.eventId) ?? null,
+            task: (e.taskId && (titleByTask.get(e.taskId) || e.taskId)) || null,
+        };
+    };
     return (rows
         .map((s) => ({
         sessionId: s.sessionId,
@@ -568,15 +905,59 @@ export function runningSessions(db, scope = {}, opts = {}) {
         liveAgentCount: liveBySession.get(s.sessionId) ?? 0,
         workingAgentCount: workingBySession.get(s.sessionId) ?? 0,
         lastEventType: lastEvent.get(s.sessionId)?.eventType ?? null,
+        lastStepRole: lastStep(s.sessionId).role,
+        lastStepTask: lastStep(s.sessionId).task,
         projects: [...(projectsBySession.get(s.sessionId) ?? [])].sort(),
+        title: titles.get(s.sessionId) ?? null,
     }))
         // Under a project scope, a session belongs to the project only through
-        // its tasks — one with none (a run that has not planned anything yet) is
-        // not this project's business, and would otherwise show up in every
-        // project's Overview at once.
+        // the tasks it touched — one with none (a run that has not planned or
+        // dispatched anything yet) is not this project's business, and would
+        // otherwise show up in every project's Overview at once.
         .filter((s) => scope.project === undefined || s.projects.length > 0)
         .sort((a, b) => b.lastEventAt.localeCompare(a.lastEventAt) || a.sessionId.localeCompare(b.sessionId)));
 }
+/**
+ * Which factory sessions each of `cliIds` wrote into: one row per
+ * (CLI session, factory session) pair, ordered by CLI id then session id.
+ *
+ * The answer is read off `events_raw.cli_session_id`, the stamp events.ts
+ * puts on every write made inside a CLI session. It is a link and nothing
+ * more: a session continued by a second CLI session answers to both, an
+ * unstamped event (written outside one, or before the stamp existed) answers
+ * to neither, and since an epic session and its subagents can share one CLI
+ * session the pair says nothing about which agent wrote what -- so it is
+ * never turn or delegation evidence (architecture §18 rule 4).
+ */
+export function cliSessionLinks(db, cliIds) {
+    // No ids, no question -- and no `inArray(col, [])` either; see
+    // scopedToSessions for why this file never builds one.
+    if (cliIds.length === 0)
+        return [];
+    // Aggregated in SQL, one row per pair: a CLI session that wrote thousands
+    // of events costs one row here, not thousands folded in JS.
+    const rows = db
+        .select({
+        cliSessionId: eventsRaw.cliSessionId,
+        sessionId: eventsRaw.sessionId,
+        lastEventAt: max(eventsRaw.ts),
+    })
+        .from(eventsRaw)
+        .where(inArray(eventsRaw.cliSessionId, [...new Set(cliIds)]))
+        .groupBy(eventsRaw.cliSessionId, eventsRaw.sessionId)
+        .all();
+    const links = rows.flatMap((row) => row.cliSessionId === null || row.lastEventAt === null
+        ? []
+        : [
+            {
+                cliSessionId: row.cliSessionId,
+                sessionId: row.sessionId,
+                lastEventAt: row.lastEventAt,
+            },
+        ]);
+    const byCodePoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+    return links.sort((a, b) => byCodePoint(a.cliSessionId, b.cliSessionId) || byCodePoint(a.sessionId, b.sessionId));
+}
 function groupLiveAgents(rows) {
     const grouped = new Map();
     for (const row of rows) {
@@ -635,23 +1016,277 @@ function inFlightEpics(taskRows, closed) {
     const closedIds = new Set(closed.map((e) => e.epicId));
     return [
         ...new Set(taskRows
-            .filter((t) => t.epicId && !TERMINAL_TASK_STATUSES.has(t.taskStatus) && !closedIds.has(t.epicId))
+            .filter(
+        // ds-spec.md §4.1 "Data/API note" (audit item 2, DS2): a task the
+        // projector will not overwrite (TERMINAL_TASK_STATUSES) is not the
+        // same question as "does this epic still need a person" —
+        // `escalated`/`failed` are HELD_OPEN_BY_AN_OPERATOR (taskStatus.ts),
+        // and no `epic-closed` event exists for them. Filtering on
+        // TERMINAL_TASK_STATUSES alone dropped such an epic out of BOTH
+        // `epicsInFlight` and `closedEpics` the moment its last open task hit
+        // one of those two statuses — it simply disappeared from every
+        // picker that reads this field. CLOSED_TO_FURTHER_WORK excludes
+        // exactly the statuses a person is not expected to come back to.
+        (t) => t.epicId && !CLOSED_TO_FURTHER_WORK.has(t.taskStatus) && !closedIds.has(t.epicId))
             .map((t) => t.epicId)),
     ].sort();
 }
 /**
- * A finding the operator's pending-waiver count is about: one the waiver
- * machinery would actually act on. Both rosters are imported from the modules
- * that own them — the severities from waivers.ts, the statuses from findings.ts,
- * where they are read off LEGAL_TRANSITIONS — rather than spelled out here.
- * This count is a second *reader* of what can be waived and must not become a
- * second opinion about it: a count that disagrees with the batch does not
- * error, it just tells the operator a different number than `/bs waivers`
- * will offer them.
+ * The subset of `inFlightEpics()` an operator would call actually running:
+ * epics with a task in a truly open status, not merely one the projector
+ * still calls non-terminal. An epic whose only open task is `escalated` or
+ * `failed` stays in `inFlightEpics()` (it is still pickable on Kanban/Flow —
+ * see that function's doc), but it has nothing running and belongs in the
+ * inbox, not on the "Running now" card (ds-spec.md §4.1, DS2 review F1).
+ */
+function activeEpics(taskRows, closed, idle) {
+    const closedIds = new Set(closed.map((e) => e.epicId));
+    const idleIds = new Set(idle.map((e) => e.epicId));
+    return [
+        ...new Set(taskRows
+            .filter((t) => t.epicId &&
+            !TERMINAL_TASK_STATUSES.has(t.taskStatus) &&
+            !closedIds.has(t.epicId) &&
+            !idleIds.has(t.epicId))
+            .map((t) => t.epicId)),
+    ].sort();
+}
+/** An epic with no activity for longer than this is idle (7 x 24 h; exactly 7 days is not). */
+export const EPIC_IDLE_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * The newest event per (task id, payload `epic_id`, project), session-scoped. Read once
+ * per `overview()` and shared with every per-project summary, so a dashboard
+ * poll scans `events_raw` once rather than once per project plus once overall.
+ * Rows without a task id are kept: goal-check, spec-review and plan-amend
+ * events carry only the payload's `epic_id`.
+ */
+function epicActivityRows(db, scope) {
+    const sessionCond = scopedToSessions(eventsRaw.sessionId, scope);
+    // json_valid() first: json_extract() throws on a non-JSON payload, and one
+    // bad row must not fail the whole overview.
+    const payloadEpic = sql `CASE WHEN json_valid(${eventsRaw.payload}) THEN json_extract(${eventsRaw.payload}, '$.epic_id') END`;
+    const query = db
+        .select({
+        taskId: eventsRaw.taskId,
+        payloadEpic,
+        project: eventsRaw.project,
+        last: max(eventsRaw.ts),
+    })
+        .from(eventsRaw);
+    const rows = (sessionCond ? query.where(sessionCond) : query)
+        .groupBy(eventsRaw.taskId, payloadEpic, eventsRaw.project)
+        .all();
+    return rows.flatMap((r) => r.last === null
+        ? []
+        : [
+            {
+                taskId: r.taskId,
+                payloadEpic: typeof r.payloadEpic === 'string' ? r.payloadEpic : null,
+                project: projectOf(r.project),
+                last: r.last,
+            },
+        ]);
+}
+/**
+ * The in-flight epics nothing has happened to for more than 7 days before
+ * `nowIso`. An epic's last activity is the newest of its tasks' `updatedAt`
+ * and the `ts` of the newest event that belongs to it: `updatedAt` only moves
+ * when the projector touches the row, so a finding, a judge report or a gate
+ * result logged against a task would otherwise read as silence. An event
+ * belongs to an epic by, in order: its payload `epic_id` (the key the
+ * projector itself trusts, and the only one a task-less event has); the task
+ * id through `epicResolver`, so a bare task id lands on its epic as in the
+ * spend figures; the `<epic>/` prefix of a task id no task row carries, which
+ * is how a plan ref (`<epic>/plan-rN`, `<epic>/spec-review-rN`) names its
+ * epic. Timestamps compare as instants, not strings. An idle epic stays in
+ * `inFlightEpics()` (it is still pickable) and only leaves `activeEpics()`.
+ * With `project` set, only that project's events count (an unset one spans all).
+ */
+function idleEpics(taskRows, activity, inFlight, nowIso, project) {
+    const lastByEpic = new Map();
+    const bump = (epicId, ts) => {
+        if (epicId === undefined)
+            return;
+        const ms = Date.parse(ts);
+        if (Number.isNaN(ms))
+            return;
+        const seen = lastByEpic.get(epicId);
+        if (seen === undefined || ms > seen)
+            lastByEpic.set(epicId, ms);
+    };
+    const epicByTask = new Map();
+    for (const t of taskRows) {
+        if (!t.epicId)
+            continue;
+        epicByTask.set(t.taskId, t.epicId);
+        bump(t.epicId, t.updatedAt);
+    }
+    const epicOf = epicResolver(epicByTask);
+    for (const r of activity) {
+        if (project !== undefined && r.project !== project)
+            continue;
+        const slash = r.taskId?.lastIndexOf('/') ?? -1;
+        const prefix = r.taskId && slash > 0 ? r.taskId.slice(0, slash) : undefined;
+        bump(r.payloadEpic ?? epicOf(r.taskId ?? undefined) ?? prefix, r.last);
+    }
+    const now = Date.parse(nowIso);
+    const idle = [];
+    for (const epicId of inFlight) {
+        const lastMs = lastByEpic.get(epicId);
+        if (lastMs === undefined)
+            continue;
+        const idleMs = now - lastMs;
+        if (idleMs > EPIC_IDLE_MS)
+            idle.push({ epicId, idleDays: Math.floor(idleMs / (24 * 60 * 60 * 1000)) });
+    }
+    return idle;
+}
+/**
+ * A finding the waiver machinery would actually act on. Both rosters are
+ * imported from the modules that own them — the severities from waivers.ts,
+ * the statuses from findings.ts, where they are read off LEGAL_TRANSITIONS —
+ * rather than spelled out here. `bs waivers pending` lists every such finding:
+ * what *could* be waived. The operator's inbox and pending-waiver count are
+ * narrower, see needsOperatorWaiver() below.
  */
 function awaitsWaiverDecision(f) {
     return WAIVABLE_SEVERITIES.includes(f.severity) && WAIVABLE_STATUSES.includes(f.findingStatus);
 }
+/**
+ * The task row a finding's task id names: exact key first, then taskIdsMatch,
+ * the way projectResolver (projector.ts) does it. The log spells one task both
+ * bare ("task-1") and qualified ("epic-a/task-1"), and findings keep whichever
+ * spelling they were raised with. A bare id matches the same-named task of
+ * every epic, so the finding's own epic, when it names one, picks among them.
+ */
+function taskResolver(taskRows) {
+    const exact = new Map(taskRows.map((t) => [t.taskId, t]));
+    return (taskId, epicId) => {
+        const hit = exact.get(taskId);
+        if (hit)
+            return hit;
+        const matches = taskRows.filter((t) => taskIdsMatch(taskId, t.taskId));
+        return matches.find((t) => epicId !== null && t.epicId === epicId) ?? matches[0];
+    };
+}
+/**
+ * An undecided waivable finding the factory will no longer act on, so only the
+ * operator can: its task shipped, or it is epic-level (no task row, such as
+ * `<epic>/integration`) and its epic is closed. A task still open is in the
+ * factory's own fix loop (a follow-up task exists to fix its finding), a
+ * superseded task's findings are moot, and an escalated task has its own inbox
+ * row. No shared status set names "shipped" alone — TERMINAL_OK_TASK_STATUSES
+ * also holds `waived`, which is decided — so `completed` is spelled out. The
+ * inbox and both pendingWaivers counts read this one rule, so they agree.
+ */
+function needsOperatorWaiver(f, resolveTask, closedEpicIds) {
+    if (!awaitsWaiverDecision(f) || f.waiverId !== null)
+        return false;
+    const t = resolveTask(f.taskId, f.epicId);
+    if (t)
+        return t.taskStatus === 'completed';
+    return f.epicId !== null && closedEpicIds.has(f.epicId);
+}
+const INBOX_KIND_RANK = {
+    escalation: 0,
+    waiver: 1,
+    lesson_candidate: 2,
+};
+/** A task's Kanban display text — the same `objective ?? taskId` fallback
+ *  every other query on this table uses; tasks have no `title` column. */
+function taskDisplayText(t) {
+    return t.objective ?? t.taskId;
+}
+export function inboxRows(db, scope = {}) {
+    const taskRows = allTasksForScope(db, scope);
+    const resolveTask = taskResolver(taskRows);
+    const rows = [];
+    // Escalations: task rows the projector parked at `escalated`
+    // (db/projector.ts's error-logged handling, `coordination.*` errors).
+    // Dispatches for every escalated task are fetched in one query, not one
+    // per task, and grouped by taskId below.
+    const escalatedTaskIds = taskRows
+        .filter((t) => t.taskStatus === 'escalated')
+        .map((t) => t.taskId);
+    const lastDispatchByTask = new Map();
+    if (escalatedTaskIds.length > 0) {
+        const dispatchRows = inLogOrder(db.select().from(dispatches).where(inArray(dispatches.taskId, escalatedTaskIds)).all());
+        for (const d of dispatchRows) {
+            if (d.taskId)
+                lastDispatchByTask.set(d.taskId, d);
+        }
+    }
+    for (const t of taskRows) {
+        if (t.taskStatus !== 'escalated')
+            continue;
+        const lastDispatch = lastDispatchByTask.get(t.taskId);
+        rows.push({
+            id: `escalation:${t.taskId}`,
+            kind: 'escalation',
+            title: taskDisplayText(t),
+            description: lastDispatch ? `Escalated while dispatched as ${lastDispatch.agentRole}` : null,
+            project: projectOf(t.project),
+            taskId: t.taskId,
+            createdAt: t.updatedAt,
+        });
+    }
+    // Pending waivers: findings `needsOperatorWaiver()` covers (shipped work
+    // nothing else will touch), grouped one row per task (the operator waives a
+    // task's batch, not one finding at a time — /bs waivers's own unit).
+    const closedEpicIds = new Set(closedEpicsForScope(db, scope).map((e) => e.epicId));
+    const pendingFindings = allFindingsForScope(db, scope).filter((f) => needsOperatorWaiver(f, resolveTask, closedEpicIds));
+    const pendingByTask = new Map();
+    for (const f of pendingFindings) {
+        const t = resolveTask(f.taskId, f.epicId);
+        const key = t?.taskId ?? f.taskId;
+        const group = pendingByTask.get(key) ?? { t, findingRows: [] };
+        group.findingRows.push(f);
+        pendingByTask.set(key, group);
+    }
+    for (const [taskId, { t, findingRows }] of pendingByTask) {
+        const latest = findingRows.reduce((a, b) => (a.raisedAt > b.raisedAt ? a : b));
+        const count = findingRows.length;
+        rows.push({
+            id: `waiver:${taskId}`,
+            kind: 'waiver',
+            title: t ? taskDisplayText(t) : taskId,
+            description: `${count} finding${count === 1 ? '' : 's'} awaiting a waiver decision`,
+            project: projectOf(latest.project ?? t?.project ?? null),
+            taskId,
+            createdAt: latest.raisedAt,
+        });
+    }
+    // Lesson candidates: what /api/lessons already buckets as 'pending'. No
+    // project column on lessons — always the client's "All projects" group.
+    if (scope.project === undefined) {
+        const sessionCond = scopedToSessions(lessons.sessionId, scope);
+        const lessonRows = sessionCond
+            ? db.select().from(lessons).where(sessionCond).all()
+            : db.select().from(lessons).all();
+        for (const l of lessonRows) {
+            if (LESSON_BUCKET_FOR_STATUS[l.lessonStatus] !== 'pending')
+                continue;
+            rows.push({
+                id: `lesson_candidate:${l.lessonId}`,
+                kind: 'lesson_candidate',
+                title: l.statement,
+                description: null,
+                project: null,
+                taskId: null,
+                createdAt: l.validFrom,
+            });
+        }
+    }
+    return rows.sort((a, b) => {
+        const rank = INBOX_KIND_RANK[a.kind] - INBOX_KIND_RANK[b.kind];
+        if (rank !== 0)
+            return rank;
+        const created = a.createdAt.localeCompare(b.createdAt);
+        if (created !== 0)
+            return created;
+        return a.id.localeCompare(b.id);
+    });
+}
 /**
  * One project's overview slice, computed by the same logic overview() itself
  * uses (no drift). `nowIso` is the caller's single instant, not a fresh
@@ -659,24 +1294,34 @@ function awaitsWaiverDecision(f) {
  * for its own counts, so the project rows and the global card can never
  * disagree about which agents are working.
  */
-function projectSummary(db, project, baseScope, nowIso) {
+function projectSummary(db, project, baseScope, nowIso, activity) {
     const scope = { ...baseScope, project };
     const liveRows = allAgentsForScope(db, scope);
     const taskRows = allTasksForScope(db, scope);
-    const epicsInFlight = inFlightEpics(taskRows, closedEpicsForScope(db, scope));
-    const { budgetByEpic, spentByEpic } = epicTokenMaps(db, scope, taskRows);
+    const closedEpicsHere = closedEpicsForScope(db, scope);
+    const epicsInFlight = inFlightEpics(taskRows, closedEpicsHere);
+    const epicsIdle = idleEpics(taskRows, activity, epicsInFlight, nowIso, project);
+    const epicsActivelyRunning = activeEpics(taskRows, closedEpicsHere, epicsIdle);
+    const tokenMaps = epicTokenMaps(db, scope, taskRows);
+    const { budgetByEpic, spentByEpic, unmeasuredByEpic } = tokenMaps;
     const tokensSpent = [...spentByEpic.values()].reduce((s, v) => s + v, 0);
     const tokensBudget = budgetByEpic.size > 0 ? [...budgetByEpic.values()].reduce((s, v) => s + v, 0) : null;
+    const unmeasured = [...unmeasuredByEpic.values()].reduce((s, v) => s + v, 0);
     const escalations = taskRows.filter((t) => t.taskStatus === 'escalated').length;
-    const findingRows = allFindingsForScope(db, scope).filter(awaitsWaiverDecision);
-    const pendingWaivers = findingRows.filter((f) => f.waiverId === null).length;
+    const closedEpicIds = new Set(closedEpicsHere.map((e) => e.epicId));
+    const resolveTask = taskResolver(taskRows);
+    const pendingWaivers = allFindingsForScope(db, scope).filter((f) => needsOperatorWaiver(f, resolveTask, closedEpicIds)).length;
     return {
         project,
         liveAgentCount: liveRows.length,
         workingAgentCount: liveRows.filter((a) => isWorkingAt(a.dispatchedAt, nowIso)).length,
         epicsInFlight,
+        epicsActivelyRunning,
+        epicsIdle,
         tokensSpent,
         tokensBudget,
+        unmeasured,
+        tokensByEpic: epicTokenSpends(tokenMaps),
         alerts: { escalations, pendingWaivers },
     };
 }
@@ -780,7 +1425,9 @@ function tokensSpentAt(db, scope, cutoffIso, epicByTask) {
         const payload = JSON.parse(r.payload);
         if (!epicOf(resultTaskId({ payload, envelopeTaskId: r.taskId })))
             continue;
-        total += payload.token_usage?.total_tokens ?? 0;
+        const usage = readTokenUsage(payload.token_usage);
+        if (usage.measured)
+            total += usage.total;
     }
     return total;
 }
@@ -845,16 +1492,15 @@ export function overview(db, scope = {}, opts = {}) {
     const taskRows = allTasksForScope(db, scope);
     const closedEpics = closedEpicsForScope(db, scope);
     const epicsInFlight = inFlightEpics(taskRows, closedEpics);
-    const { budgetByEpic, spentByEpic } = epicTokenMaps(db, scope, taskRows);
-    const epicIds = new Set([...budgetByEpic.keys(), ...spentByEpic.keys()]);
-    const tokensByEpic = [...epicIds].sort().map((epicId) => ({
-        epicId,
-        tokensSpent: spentByEpic.get(epicId) ?? 0,
-        tokensBudget: budgetByEpic.get(epicId) ?? null,
-    }));
+    const activity = epicActivityRows(db, scope);
+    const epicsIdle = idleEpics(taskRows, activity, epicsInFlight, nowIso, scopeProject(scope));
+    const epicsActivelyRunning = activeEpics(taskRows, closedEpics, epicsIdle);
+    const { budgetByEpic, spentByEpic, unmeasuredByEpic } = epicTokenMaps(db, scope, taskRows);
+    const tokensByEpic = epicTokenSpends({ budgetByEpic, spentByEpic, unmeasuredByEpic });
     const escalations = taskRows.filter((t) => t.taskStatus === 'escalated').length;
-    const pendingWaiverFindings = allFindingsForScope(db, scope).filter(awaitsWaiverDecision);
-    const pendingWaivers = pendingWaiverFindings.filter((f) => f.waiverId === null).length;
+    const closedEpicIds = new Set(closedEpics.map((e) => e.epicId));
+    const resolveTask = taskResolver(taskRows);
+    const pendingWaivers = allFindingsForScope(db, scope).filter((f) => needsOperatorWaiver(f, resolveTask, closedEpicIds)).length;
     const dispatchSessionCond = scopedToSessions(dispatches.sessionId, scope);
     const dispatchRows = dispatchSessionCond
         ? db.select().from(dispatches).where(dispatchSessionCond).all()
@@ -866,10 +1512,21 @@ export function overview(db, scope = {}, opts = {}) {
     // them left the rows in the ascending order they arrived in: the ten this
     // then kept were the *oldest* ten of the burst, under a heading that says
     // recent.
-    const recentDispatches = inLogOrder(scopedDispatches)
+    const recentDispatchRows = inLogOrder(scopedDispatches)
         .reverse()
-        .slice(0, RECENT_DISPATCHES_LIMIT)
-        .map((d) => ({
+        .slice(0, RECENT_DISPATCHES_LIMIT);
+    // agents.id IS the dispatch event id (agents-registry.ts's foldAgents()),
+    // so a direct id lookup finds the round regardless of whether that agent
+    // is still live or has since gone terminal.
+    const roundByEventId = new Map(recentDispatchRows.length > 0
+        ? db
+            .select({ id: agents.id, round: agents.round })
+            .from(agents)
+            .where(inArray(agents.id, recentDispatchRows.map((d) => d.eventId)))
+            .all()
+            .map((a) => [a.id, a.round])
+        : []);
+    const recentDispatches = recentDispatchRows.map((d) => ({
         eventId: d.eventId,
         ts: d.ts,
         agentRole: d.agentRole,
@@ -877,6 +1534,7 @@ export function overview(db, scope = {}, opts = {}) {
         modelTier: d.modelTier,
         taskId: d.taskId,
         reason: d.reason,
+        round: roundByEventId.get(d.eventId) ?? 1,
     }));
     let projects;
     if (scope.project === undefined) {
@@ -894,15 +1552,25 @@ export function overview(db, scope = {}, opts = {}) {
         // Milestones carry no session_id and milestoneProgressRows() never
         // filters them by one, so they join the list under a session scope too.
         const declaredRows = db.select({ project: milestones.project }).from(milestones).all();
-        projects = distinctProjects(allTaskRowsUnfiltered, declaredRows).map((p) => projectSummary(db, p, scope, nowIso));
+        projects = distinctProjects(allTaskRowsUnfiltered, declaredRows).map((p) => projectSummary(db, p, scope, nowIso, activity));
     }
     const fiveMinAgo = new Date(now.getTime() - 5 * 60 * 1000).toISOString();
     const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000).toISOString();
     const liveAgentCountDelta5m = liveRows.length - liveAgentCountAt(db, scope, fiveMinAgo);
     const workingAgentCountDelta5m = workingRows.length - workingAgentCountAt(db, scope, fiveMinAgo);
-    const epicByTask = new Map(taskRows.filter((t) => t.epicId !== null).map((t) => [t.taskId, t.epicId]));
-    const totalBudgetNow = [...budgetByEpic.values()].reduce((s, v) => s + v, 0);
-    const totalSpentNow = [...spentByEpic.values()].reduce((s, v) => s + v, 0);
+    // The Budget panel counts the epics the Running-now cards count, so its
+    // 1-hour delta is folded over the same set: running epics that declare a
+    // budget (an unbudgeted epic adds to neither side of the card's ratio).
+    const runningBudgeted = new Set(epicsActivelyRunning.filter((e) => budgetByEpic.has(e)));
+    const epicByTask = new Map(taskRows
+        .filter((t) => t.epicId !== null && runningBudgeted.has(t.epicId))
+        .map((t) => [t.taskId, t.epicId]));
+    const totalBudgetNow = [...budgetByEpic]
+        .filter(([e]) => runningBudgeted.has(e))
+        .reduce((s, [, v]) => s + v, 0);
+    const totalSpentNow = [...spentByEpic]
+        .filter(([e]) => runningBudgeted.has(e))
+        .reduce((s, [, v]) => s + v, 0);
     let budgetUsedPctPointDelta1h = null;
     if (totalBudgetNow > 0) {
         const currentPct = (totalSpentNow / totalBudgetNow) * 100;
@@ -936,6 +1604,8 @@ export function overview(db, scope = {}, opts = {}) {
         stalledAgentCount: liveRows.length - workingRows.length,
         runningSessions: runningSessions(db, scope, { nowIso }),
         epicsInFlight,
+        epicsActivelyRunning,
+        epicsIdle,
         closedEpics,
         tokensByEpic,
         alerts: { escalations, pendingWaivers },
@@ -1033,6 +1703,14 @@ export const FREE_TIMELINE_EVENT_TYPES = [
     // only event written after `epic-closed`, so without it the timeline of a
     // closed epic ends at the closing and never shows what the closing was for.
     'integration-pr-opened',
+    // A comment the operator leaves mid-run on one task (feedback.ts), and its
+    // later resolution -- bounced, turned into a follow-up task, or dismissed.
+    // Both are the operator's own words about a specific task, the same reason
+    // operator-note is on this list, and neither carries a gate_event/graph_event
+    // tag: what happens to the comment is a later PR's playbook wiring, not a
+    // taxonomy outcome this orchestrator declares today.
+    'operator-feedback-recorded',
+    'operator-feedback-resolved',
 ];
 let cachedTaxonomy;
 /**
@@ -1061,7 +1739,93 @@ export function timelineEventTypes() {
         ...(cachedTaxonomy.dimensions.graph_event ?? []),
     ];
 }
-function toEntry(row) {
+/** Every `EventKind`, for routes validating a `kind=` query param against the real set. */
+export const EVENT_KINDS = [
+    'Prompt',
+    'Dispatched',
+    'Returned',
+    'Finding',
+    'Gate',
+    'Merge',
+    'Error',
+    'Feedback',
+    'System',
+];
+/**
+ * Which of the 9 kinds a raw event renders as (ds-spec.md §4.3's table) —
+ * pure in `(eventType, payload)` so both `timeline()` and `causalChain()` tag
+ * every row the same way. Unnamed types fall to `System`, the feed's
+ * catch-all for rare types.
+ *
+ * DS6 PR3 round 2 reconciles this with `ui/src/lib/timelineDisplay.ts`'s
+ * client-side `kindFor()` fallback switch (which this function already
+ * takes precedence over whenever a paged entry carries a server `kind`):
+ * both now agree that `judge-reported` is `Finding` and
+ * `waiver-granted`/`waiver-denied` are `Feedback`, per §4.3's table
+ * ("Finding (judge verdict)" -> `judge-reported`; "Feedback" ->
+ * `waiver-granted` / `waiver-denied`). The round-1 version of this switch
+ * only matched the 8 event types the mock happens to show, so every other
+ * gate/graph event — `finding-raised`, `schema-check-result`,
+ * `cross-finding-reconciled`, `epic-closed`, and the rest of
+ * taxonomy.yml's `gate_event`/`graph_event` vocabulary — fell through to
+ * `System`, which is where the "most rows are System" visual-pass finding
+ * came from. The groupings below follow the same families `kindFor()`'s
+ * switch already used, just with the one Finding/Feedback swap applied.
+ */
+export function eventKind(eventType, _payload) {
+    switch (eventType) {
+        case 'user_prompt':
+        case 'operator-note':
+            return 'Prompt';
+        case DISPATCH_EVENT_TYPE:
+            return 'Dispatched';
+        case TASK_RESULT_EVENT_TYPE:
+            return 'Returned';
+        case JUDGE_REPORT_EVENT_TYPE:
+        case 'finding-raised':
+        case 'finding-reverified':
+        case 'finding-suppressed':
+        case 'finding-transitioned':
+        case 'finding-reattributed':
+        case 'severity-decisions':
+        case 'task-waiver-approved':
+            return 'Finding';
+        case 'gate-outcome':
+        case 'testgate-result':
+        case 'schema-check-result':
+        case 'artifact-check-result':
+        case 'commit-check-result':
+        case 'deps-check-result':
+        case 'judges-outstanding':
+        case 'grader-verdict':
+        case 'budget-check-result':
+        case 'coverage-evidence':
+        case 'integration-check':
+        case 'spec-review-recorded':
+        case 'goal-check-recorded':
+        case 'quorum-decision':
+        case 'issue-reported':
+            return 'Gate';
+        case 'wave-merged':
+        case 'epic-closed':
+        case 'integration-pr-opened':
+            return 'Merge';
+        case ERROR_EVENT_TYPE:
+        case 'error-report-proposed':
+            return 'Error';
+        case 'waiver-granted':
+        case 'waiver-denied':
+        case 'judge-verdict':
+        case 'cross-finding-reconciled':
+        case 'spec-change-proposed':
+        case 'spec-change-decided':
+            return 'Feedback';
+        default:
+            return 'System';
+    }
+}
+function toEntry(row, nearestPromptId) {
+    const payload = JSON.parse(row.payload);
     return {
         eventId: row.eventId,
         ts: row.ts,
@@ -1070,9 +1834,14 @@ function toEntry(row) {
         agentId: row.agentId,
         planVersion: row.planVersion,
         causalParent: row.causalParent,
-        payload: JSON.parse(row.payload),
+        payload,
         project: row.project,
         actor: row.actor,
+        kind: eventKind(row.eventType, payload),
+        nearestPromptId,
+        sessionId: row.sessionId,
+        // Filled per-page by joinSessionTitles() below, same as run/gateCounts.
+        sessionTitle: row.sessionId,
     };
 }
 /**
@@ -1134,35 +1903,50 @@ function applyDecisionsLens(entries) {
     });
 }
 /**
- * Walk causal_parent pointers back to the root, oldest-first.
- *
- * P9-7: the walk crosses session boundaries. Event ids are globally unique
- * (`<session-id>#<index>`), so a hop needs the id alone; constraining every
- * lookup to `sessionId` used to stop the chain dead at the session root of a
- * continued epic — the projection reported a two-event history for a chain
- * that ran back through three sessions. `sessionId` still gates the FIRST
- * lookup, so asking for a chain that does not start in the named session
- * remains an empty answer rather than a silent redirect.
+ * Row cache shared across calls within one `kanban()` invocation (S3 fix):
+ * event ids are globally unique (see the docstring above), so a row fetched
+ * for one task's walk answers for every other walk that crosses the same
+ * event, and the session gate below still applies to it.
  */
-function causalChain(db, sessionId, eventId) {
-    const chain = [];
+function fetchEventRow(db, eventId, cache) {
+    if (cache?.has(eventId))
+        return cache.get(eventId) ?? null;
+    const row = db.select().from(eventsRaw).where(eq(eventsRaw.eventId, eventId)).get() ?? null;
+    cache?.set(eventId, row);
+    return row;
+}
+function causalChain(db, sessionId, eventId, eventCache) {
+    const rows = [];
     let currentId = eventId;
     const seen = new Set();
     let first = true;
     while (currentId && !seen.has(currentId)) {
         seen.add(currentId);
-        const idMatch = eq(eventsRaw.eventId, currentId);
-        const row = db
-            .select()
-            .from(eventsRaw)
-            .where(first ? and(idMatch, eq(eventsRaw.sessionId, sessionId)) : idMatch)
-            .get();
+        const row = fetchEventRow(db, currentId, eventCache);
         if (!row)
             break;
+        // Ids are globally unique, so a row fetched for a different session's
+        // walk can still answer this one's first hop — but that hop is only
+        // valid when it actually named a row inside the requested session,
+        // same as the original `and(idMatch, eq(sessionId))` constraint.
+        if (first && row.sessionId !== sessionId)
+            break;
         first = false;
-        chain.unshift(toEntry(row));
+        rows.unshift(row);
         currentId = row.causalParent;
     }
+    // `rows` is now the whole ancestor path, oldest-first, so each row's
+    // nearest `user_prompt` is answered by a single forward pass over this
+    // same array rather than a nested call into `nearestUserPrompt` — that
+    // function calls back into `causalChain`, and feeding it one row at a
+    // time from inside this loop was mutual recursion with no base case.
+    let lastPromptId = null;
+    const chain = [];
+    for (const row of rows) {
+        if (row.eventType === 'user_prompt')
+            lastPromptId = row.eventId;
+        chain.push(toEntry(row, lastPromptId));
+    }
     return chain;
 }
 /**
@@ -1188,12 +1972,55 @@ function epicOfEntry(entry) {
     const fromPayload = entry.payload.epic_id;
     return typeof fromPayload === 'string' ? fromPayload : null;
 }
+/**
+ * Whether an entry belongs to `epicId`. An entry that names an epic itself
+ * (`epicOfEntry` non-null) is decided by that alone: its own epic wins. A
+ * `user_prompt` naming none is derived at read (nothing stored) and shows
+ * under `epicId` when its session holds an entry of that epic, or when its id
+ * is named by a `parent_prompt_id` of such an entry or of any epic-less entry
+ * (the root `session-start`, which carries only `parent_prompt_id`) in one of
+ * those sessions. A prompt carrying its own epic does not make its session an
+ * epic session; it only decides itself. A session holding entries of two
+ * epics shares its epic-less prompts, and the `parent_prompt_id` naming of its
+ * epic-less entries, with both. The `prompts-<uuid>` home log has no entries
+ * of its own. Every other epic-less entry is dropped.
+ */
+function promptInEpic(entries, epicId) {
+    const sessions = new Set();
+    for (const e of entries) {
+        if (e.eventType !== 'user_prompt' && epicOfEntry(e) === epicId)
+            sessions.add(e.sessionId);
+    }
+    const named = new Set();
+    for (const e of entries) {
+        const own = epicOfEntry(e);
+        if (own !== null ? own !== epicId : !sessions.has(e.sessionId))
+            continue;
+        const parent = e.payload.parent_prompt_id;
+        if (typeof parent === 'string')
+            named.add(parent);
+    }
+    return (e) => {
+        const own = epicOfEntry(e);
+        if (own !== null)
+            return own === epicId;
+        return e.eventType === 'user_prompt' && (sessions.has(e.sessionId) || named.has(e.eventId));
+    };
+}
 export function timeline(db, filter = {}) {
     if (filter.causalChainFor) {
         if (!filter.sessionId) {
             throw new RangeError('timeline(): causalChainFor requires sessionId to be set.');
         }
-        return causalChain(db, filter.sessionId, filter.causalChainFor);
+        if (filter.limit !== undefined ||
+            filter.before !== undefined ||
+            filter.after !== undefined ||
+            filter.kinds !== undefined) {
+            throw new RangeError('timeline(): causalChainFor cannot be combined with limit, before, after or kinds — the causal chain is not pageable.');
+        }
+        const chain = causalChain(db, filter.sessionId, filter.causalChainFor);
+        joinSessionTitles(db, chain);
+        return chain;
     }
     const eventTypes = filter.eventTypes ?? timelineEventTypes();
     const conditions = [inArray(eventsRaw.eventType, eventTypes)];
@@ -1207,13 +2034,202 @@ export function timeline(db, filter = {}) {
         .from(eventsRaw)
         .where(and(...conditions))
         .all());
-    let entries = rows.map(toEntry);
+    // `kind` is cheap (pure function of eventType/payload) and the `kinds`
+    // filter needs it, so it is computed for every fetched row up front.
+    // `nearestPromptId` is the expensive one (a causal-parent walk), so it is
+    // deferred until AFTER filtering and paging and only computed for the rows
+    // that actually survive onto the page — see `memoizedNearestPromptId`.
+    let entries = rows.map((row) => toEntry(row, null));
     entries = filterByProject(entries, filter);
-    if (filter.epicId)
-        entries = entries.filter((e) => epicOfEntry(e) === filter.epicId);
+    if (filter.epicId) {
+        entries = entries.filter(promptInEpic(entries, filter.epicId));
+    }
+    if (filter.kinds?.length) {
+        const kinds = new Set(filter.kinds);
+        entries = entries.filter((e) => kinds.has(e.kind));
+    }
     if (filter.decisionsOnly)
         entries = applyDecisionsLens(entries);
-    return entries;
+    const page = paginate(db, entries, filter);
+    // Row lookup for the memo walk: the fetched rows answer most ancestors for
+    // free (one query already brought them all into memory); a fallback cache
+    // handles the rare ancestor outside that set (e.g. a cross-session hop).
+    const rowByEventId = new Map(rows.map((row) => [row.eventId, row]));
+    const ancestorCache = new Map();
+    const getRow = (eventId) => rowByEventId.get(eventId) ?? fetchEventRow(db, eventId, ancestorCache);
+    const promptMemo = new Map();
+    for (const entry of page) {
+        entry.nearestPromptId = memoizedNearestPromptId(entry.eventId, getRow, promptMemo);
+    }
+    joinDispatchRuns(db, page);
+    joinGateCounts(page);
+    joinSessionTitles(db, page);
+    return page;
+}
+/**
+ * DS6 PR4b (§4.1 1b) — fills `sessionTitle` on every entry in `page`, one
+ * grouped lookup (`sessionTitles()`, the same logic `runningSessions()` uses
+ * for its "Now running" cards) scoped to only the session ids the page
+ * actually carries, rather than one query per row or an unscoped scan of
+ * every session this factory has ever run.
+ */
+function joinSessionTitles(db, page) {
+    const sessionIds = [...new Set(page.map((e) => e.sessionId))];
+    if (sessionIds.length === 0)
+        return;
+    const titles = sessionTitles(db, { sessionIds });
+    for (const entry of page) {
+        entry.sessionTitle = titles.get(entry.sessionId) ?? entry.sessionId;
+    }
+}
+/**
+ * DS6 PR2 (§4.3 table) — fills `run` on every `Dispatched` entry in `page`,
+ * batched for the page only (same cost discipline as `nearestPromptId`
+ * above): one `agents` query keyed on the page's own dispatch event ids,
+ * then one `eventsRaw` query for the terminal `task_run_result` rows those
+ * `agents` rows name, rather than one query per row.
+ *
+ * `runStatus` is the task-result payload's `run_status` when present, else the
+ * agent's own `status` once it is no longer `live` (done / superseded / error /
+ * abandoned, so steps ended by judge-reported, error-logged, epic-closed etc.
+ * read as finished), else null (truly live). Tokens and duration still come
+ * only from a task-result payload.
+ */
+function joinDispatchRuns(db, page) {
+    const dispatchIds = page.filter((e) => e.kind === 'Dispatched').map((e) => e.eventId);
+    if (dispatchIds.length === 0)
+        return;
+    const agentRows = db.select().from(agents).where(inArray(agents.id, dispatchIds)).all();
+    const agentByDispatchId = new Map(agentRows.map((a) => [a.id, a]));
+    const terminalEventIds = agentRows
+        .map((a) => a.terminalEventId)
+        .filter((id) => id !== null);
+    const resultRows = terminalEventIds.length === 0
+        ? []
+        : db
+            .select({ eventId: eventsRaw.eventId, payload: eventsRaw.payload })
+            .from(eventsRaw)
+            .where(and(inArray(eventsRaw.eventId, terminalEventIds), eq(eventsRaw.eventType, TASK_RESULT_EVENT_TYPE)))
+            .all();
+    const resultPayloadByEventId = new Map(resultRows.map((r) => [r.eventId, JSON.parse(r.payload)]));
+    for (const entry of page) {
+        if (entry.kind !== 'Dispatched')
+            continue;
+        const agent = agentByDispatchId.get(entry.eventId);
+        if (!agent)
+            continue;
+        const resultPayload = agent.terminalEventId
+            ? resultPayloadByEventId.get(agent.terminalEventId)
+            : undefined;
+        const usage = readTokenUsage(resultPayload?.token_usage);
+        entry.run = {
+            tokensIn: usage.measured ? usage.input : null,
+            tokensOut: usage.measured ? usage.output : null,
+            durationMs: durationMsFromPayload(resultPayload ?? {}),
+            runStatus: typeof resultPayload?.run_status === 'string'
+                ? resultPayload.run_status
+                : agent.status !== 'live'
+                    ? agent.status
+                    : null,
+            dispatchedAt: agent.dispatchedAt,
+            round: agent.round,
+        };
+    }
+}
+/**
+ * DS6 PR2 (§4.3 table) — normalised `{passed, failed}` counts for every
+ * `Gate` entry in `page`, from `testgate-result.results` (or an artifact check's `checked`/`issues`, or
+ * `gate-outcome.results`, if a future writer adds one). `null` ("not
+ * measured") only where counts are expected and missing: an artifact check
+ * with neither field, or a `testgate-result` with no `results` array. Every
+ * other check type without a `results` array never carries counts, so its
+ * `gateCounts` stays unset and the UI leaves the item out. Pure over
+ * already-fetched payloads, so no extra query is needed.
+ */
+function joinGateCounts(page) {
+    for (const entry of page) {
+        if (entry.kind !== 'Gate')
+            continue;
+        if (entry.eventType === 'artifact-check-result') {
+            // Not a results array: { ok, checked, issues }.
+            const { ok, checked, issues } = entry.payload;
+            if (typeof checked !== 'number' && !Array.isArray(issues)) {
+                entry.gateCounts = null;
+                continue;
+            }
+            const failed = Math.max(Array.isArray(issues) ? issues.length : 0, ok === false ? 1 : 0);
+            const total = typeof checked === 'number' ? checked : 0;
+            entry.gateCounts = { passed: Math.max(0, total - failed), failed };
+            continue;
+        }
+        const results = entry.payload.results;
+        if (!Array.isArray(results)) {
+            if (entry.eventType === 'testgate-result')
+                entry.gateCounts = null;
+            continue;
+        }
+        let passed = 0;
+        let failed = 0;
+        for (const r of results) {
+            if (r && typeof r === 'object' && r.pass === true)
+                passed += 1;
+            else if (r && typeof r === 'object' && r.pass === false)
+                failed += 1;
+        }
+        entry.gateCounts = { passed, failed };
+    }
+}
+/** DS6 PR2 — a run's `duration_ms`, or null when the payload carries none (only some results carry it). */
+function durationMsFromPayload(payload) {
+    return typeof payload.duration_ms === 'number' ? payload.duration_ms : null;
+}
+/**
+ * Resolves `before`/`after` to the row's own `{ts, eventId}` so paging can
+ * compare it with `compareLogOrder` — the SAME ordering the rest of the log
+ * uses, never a string compare on the id (`<session>#<index>` ids are not
+ * orderable across sessions; `#9` would sort after `#10` as text).
+ */
+function resolveCursor(db, eventId) {
+    const row = db.select().from(eventsRaw).where(eq(eventsRaw.eventId, eventId)).get();
+    if (!row) {
+        throw new SmithError('timeline.unknown-cursor', `No event "${eventId}" to page from.`, {
+            eventId,
+        });
+    }
+    return { ts: row.ts, eventId: row.eventId };
+}
+/**
+ * DS6 pattern 5 (paginated "Load older" + infinite scroll). A no-op unless
+ * `limit`, `before` or `after` is set — the legacy oldest-first, unbounded
+ * shape stays exactly as it was for every existing caller.
+ *
+ * Paged mode is always newest-first. `before` keeps rows strictly older than
+ * the cursor (the "Load older" page). `after` keeps rows strictly newer; with
+ * `limit` that means the OLDEST `limit` of them — the page adjacent to the
+ * cursor on the newer side, read oldest-first then flipped to the feed's
+ * newest-first order — rather than the newest `limit`, which would skip rows
+ * between the cursor and the page it returned.
+ */
+function paginate(db, entries, filter) {
+    if (filter.limit === undefined && filter.before === undefined && filter.after === undefined) {
+        return entries;
+    }
+    let page = entries; // still oldest-first here
+    if (filter.before !== undefined) {
+        const cursor = resolveCursor(db, filter.before);
+        page = page.filter((e) => compareLogOrder(e, cursor) < 0);
+    }
+    if (filter.after !== undefined) {
+        const cursor = resolveCursor(db, filter.after);
+        page = page.filter((e) => compareLogOrder(e, cursor) > 0);
+    }
+    if (filter.limit !== undefined) {
+        page =
+            filter.after !== undefined
+                ? page.slice(0, filter.limit)
+                : page.slice(Math.max(0, page.length - filter.limit));
+    }
+    return page.slice().reverse();
 }
 function worstSeverity(severities) {
     let worst = null;
@@ -1236,6 +2252,160 @@ function worstSeverity(severities) {
  * task_status, tagged with case/origin/worst-open-finding severity plus
  * (Phase 6b) title/agent-role/milestone.
  */
+function firstLineOf(text) {
+    return (text.split('\n')[0] ?? '').trim();
+}
+function humanizeEpicId(epicId) {
+    const spaced = epicId.replace(/-/g, ' ');
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+/** DS3 — "<project>: <humanized epic id>[ (finished)]" (audit Kanban-4). */
+function epicLabelFor(epicId, project, closedEpicIds) {
+    if (!epicId)
+        return null;
+    const label = `${projectOf(project)}: ${humanizeEpicId(epicId)}`;
+    return closedEpicIds.has(epicId) ? `${label} (finished)` : label;
+}
+/** The epic a `<epic>/integration` task-ref belongs to, or null for any other ref. */
+function epicIdOfIntegrationRef(taskRef) {
+    return taskRef.endsWith('/integration') ? taskRef.slice(0, -'/integration'.length) : null;
+}
+/**
+ * DS4 S5b — every epic's latest `integration-pr-opened` URL, keyed by
+ * epic id. Extracted out of `kanban()` (where this lived inline) so
+ * `roadmapPage()` can share the exact same read instead of keeping a second
+ * copy; `inLogOrder` means a later row for the same epic overwrites an
+ * earlier one, so the map always holds the latest PR.
+ */
+function prUrlsByEpic(db) {
+    const integrationRows = inLogOrder(db.select().from(eventsRaw).where(eq(eventsRaw.eventType, 'integration-pr-opened')).all());
+    const result = new Map();
+    for (const r of integrationRows) {
+        const epicRef = r.taskId ? epicIdOfIntegrationRef(r.taskId) : null;
+        if (!epicRef)
+            continue;
+        const payload = JSON.parse(r.payload);
+        if (typeof payload.pr_url === 'string')
+            result.set(epicRef, payload.pr_url);
+    }
+    return result;
+}
+/**
+ * Cheap nearest-user_prompt-id resolver for `timeline()`'s full-table path:
+ * the nearest prompt of X is X itself when X is a `user_prompt`, otherwise
+ * the nearest prompt of X's causal parent. `nearestUserPrompt`/`causalChain`
+ * additionally require a matching row in the `prompts` table, but
+ * `projector.ts` inserts that row for EVERY `user_prompt` event in the same
+ * transaction it inserts `events_raw` from, so that check can never miss in
+ * practice and the eventType check alone is equivalent here.
+ *
+ * `causalChain`'s first-hop session gate (the walk refuses to start outside
+ * the session it is asked for) is also moot against this function: every
+ * caller feeds it a row's own `sessionId` as the walk's session (44ed474's
+ * `nearestUserPrompt(db, row.sessionId, row.eventId, ...)`, now this
+ * function's per-row callers in `timeline()`), so the first hop always names
+ * a row inside that very session and the gate never fires either way. Later
+ * hops were never gated in `causalChain` to begin with, so a cross-session
+ * ancestor is reachable from both, identically (parity test:
+ * `timelinePaging.test.ts`'s session-boundary case).
+ *
+ * Walks iteratively (no recursion — a session can chain thousands deep) and
+ * memoises every eventId it visits along the way, not just the one asked
+ * about, so a page of N rows with shared ancestors costs about one row
+ * lookup per DISTINCT event in play rather than one causal walk per row.
+ */
+function memoizedNearestPromptId(startId, getRow, memo) {
+    const path = [];
+    const visiting = new Set();
+    let current = startId;
+    let result = null;
+    while (current !== null) {
+        const cached = memo.get(current);
+        if (cached !== undefined) {
+            result = cached;
+            break;
+        }
+        if (visiting.has(current)) {
+            result = null;
+            break;
+        }
+        visiting.add(current);
+        const row = getRow(current);
+        if (!row) {
+            memo.set(current, null);
+            result = null;
+            break;
+        }
+        if (row.eventType === 'user_prompt') {
+            memo.set(current, current);
+            result = current;
+            break;
+        }
+        path.push(current);
+        current = row.causalParent;
+    }
+    for (const id of path)
+        memo.set(id, result);
+    return result;
+}
+function nearestUserPrompt(db, sessionId, eventId, eventCache) {
+    const chain = causalChain(db, sessionId, eventId, eventCache);
+    for (let i = chain.length - 1; i >= 0; i--) {
+        const entry = chain[i];
+        if (entry?.eventType !== 'user_prompt')
+            continue;
+        const row = db.select().from(prompts).where(eq(prompts.eventId, entry.eventId)).get();
+        if (row)
+            return { prompt: row.prompt, ts: row.ts, eventId: row.eventId, source: 'task' };
+    }
+    return null;
+}
+export function createQuoteMemo() {
+    return { events: new Map(), epicPrompt: new Map() };
+}
+/**
+ * "Epic started from" fallback (§4.7): the earliest `user_prompt` in the
+ * epic's session lineage. Exported (DS4 S5b) so `milestoneProgressRows()`
+ * can reuse it for `epics[].sourcePrompt` — same shape `requestQuoteForTask()`
+ * returns, so `RequestQuote.vue` renders it unchanged.
+ */
+export function epicSourcePrompt(db, anySessionIdInEpic) {
+    const lineage = projectedLineage(db, anySessionIdInEpic);
+    if (lineage.length === 0)
+        return null;
+    const rows = inLogOrder(db.select().from(prompts).where(inArray(prompts.sessionId, lineage)).all());
+    const earliest = rows[0];
+    return earliest
+        ? { prompt: earliest.prompt, ts: earliest.ts, eventId: earliest.eventId, source: 'epic' }
+        : null;
+}
+/**
+ * DS3 §4.7 — the operator prompt that led to `taskId`: a bounded, cycle-safe
+ * walk up `causal_parent` from the task's own events to the nearest
+ * `user_prompt` (reuses `causalChain`'s `seen` guard), falling back to the
+ * epic's own source prompt when the task's own walk finds none.
+ */
+export function requestQuoteForTask(db, taskId, taskSessionId, memo) {
+    const firstEvent = inLogOrder(db.select().from(eventsRaw).where(eq(eventsRaw.taskId, taskId)).all())[0];
+    if (firstEvent) {
+        const taskQuote = nearestUserPrompt(db, firstEvent.sessionId, firstEvent.eventId, memo?.events);
+        if (taskQuote)
+            return taskQuote;
+    }
+    // Two tasks named with the same epic share one `epicSourcePrompt` answer
+    // (same lineage walk, same earliest prompt), so the fallback is cached per
+    // epic rather than per task or per session.
+    const epicId = epicOfTaskId(taskId);
+    if (epicId !== null) {
+        const cached = memo?.epicPrompt.get(epicId);
+        if (cached !== undefined)
+            return cached;
+    }
+    const quote = epicSourcePrompt(db, taskSessionId);
+    if (epicId !== null)
+        memo?.epicPrompt.set(epicId, quote);
+    return quote;
+}
 export function kanban(db, epicId, scope = {}, opts = {}) {
     const nowIso = opts.nowIso ?? new Date().toISOString();
     const epicCond = epicId !== undefined ? eq(tasks.epicId, epicId) : undefined;
@@ -1247,7 +2417,7 @@ export function kanban(db, epicId, scope = {}, opts = {}) {
             .from(tasks)
             .where(and(...taskConds))
             .all()
-        : db.select().from(tasks).all(), scope);
+        : db.select().from(tasks).all(), scope).filter((t) => !isAuditAxisRowId(t.taskId));
     const epicIdsInScope = new Set(taskRows.map((t) => t.epicId).filter((e) => e !== null));
     const findingCond = epicId !== undefined ? eq(findings.epicId, epicId) : undefined;
     const findingRows = findingCond
@@ -1309,9 +2479,86 @@ export function kanban(db, epicId, scope = {}, opts = {}) {
         for (const e of JSON.parse(m.epicIds))
             milestoneByEpic.set(e, m.milestoneId);
     }
+    // DS3 item 2 — attempt count, per task_id, from the same dispatch rows above.
+    const attemptCountByTask = new Map();
+    for (const d of dispatchRows) {
+        if (!d.taskId)
+            continue;
+        attemptCountByTask.set(d.taskId, (attemptCountByTask.get(d.taskId) ?? 0) + 1);
+    }
+    // DS3 item 2 — highest judge-role dispatch round per task_id, from the agents fold.
+    const judgeRoleSet = new Set(JUDGE_ROLES);
+    const agentSessionCond = scopedToSessions(agents.sessionId, scope);
+    const agentRows = agentSessionCond
+        ? db.select().from(agents).where(agentSessionCond).all()
+        : db.select().from(agents).all();
+    const judgeRoundByTask = new Map();
+    for (const a of agentRows) {
+        if (!a.taskId || !judgeRoleSet.has(a.agentRole))
+            continue;
+        const current = judgeRoundByTask.get(a.taskId) ?? 0;
+        if (a.round > current)
+            judgeRoundByTask.set(a.taskId, a.round);
+    }
+    // DS3 item 2 — comment count per task_id, from operator_feedback.
+    const feedbackSessionCond = scopedToSessions(operatorFeedback.sessionId, scope);
+    const feedbackRows = feedbackSessionCond
+        ? db.select().from(operatorFeedback).where(feedbackSessionCond).all()
+        : db.select().from(operatorFeedback).all();
+    const commentCountByTask = new Map();
+    for (const f of feedbackRows) {
+        commentCountByTask.set(f.taskId, (commentCountByTask.get(f.taskId) ?? 0) + 1);
+    }
+    // DS3 item 2 — epic-level integration PR url, keyed by epic_id (there is no
+    // per-task PR concept today, only the epic's own integration-pr-opened).
+    // DS4 S5b — extracted to prUrlsByEpic() so roadmapPage() shares this exact
+    // read instead of keeping a second copy.
+    const prUrlByEpic = prUrlsByEpic(db);
+    // DS3 item 2 — this task's dependency edges, resolved against the task rows
+    // already in scope; a dependsOn id outside scope resolves to a null title/status.
+    const taskRowByTaskId = new Map(taskRows.map((t) => [t.taskId, t]));
+    const edgeSessionCond = scopedToSessions(edges.sessionId, scope);
+    const edgeRows = edgeSessionCond
+        ? db.select().from(edges).where(edgeSessionCond).all()
+        : db.select().from(edges).all();
+    const edgesByTask = new Map();
+    for (const e of edgeRows) {
+        const list = edgesByTask.get(e.taskId) ?? [];
+        list.push(e);
+        edgesByTask.set(e.taskId, list);
+    }
+    // DS3 item 2 — epic friendly label; closed epics (epics table holds only those) get " (finished)".
+    const closedEpicIds = new Set(db
+        .select({ epicId: epics.epicId })
+        .from(epics)
+        .all()
+        .map((e) => e.epicId));
+    // DS3 S3 fix — one shared memo for every task's request-quote walk in this
+    // call: bounds the N+1 causal walk/epic-fallback cost that scaled with the
+    // task count (see QuoteMemo's doc comment).
+    const quoteMemo = createQuoteMemo();
+    // A follow-up's origin lives only on the `finding-reattributed` event that
+    // follows its `task-added`; one read of those events, keyed by the follow-up.
+    const parentByFollowUp = new Map();
+    for (const e of db
+        .select({ payload: eventsRaw.payload })
+        .from(eventsRaw)
+        .where(eq(eventsRaw.eventType, 'finding-reattributed'))
+        .orderBy(sql `rowid`)
+        .all()) {
+        const p = JSON.parse(e.payload);
+        if (p.attribution === 'follow-up' &&
+            typeof p.from_task_id === 'string' &&
+            typeof p.to_task_id === 'string' &&
+            !parentByFollowUp.has(p.to_task_id)) {
+            // First event wins: the origin never moves once it is recorded.
+            parentByFollowUp.set(p.to_task_id, p.from_task_id);
+        }
+    }
     const columns = new Map();
     for (const t of taskRows) {
         const column = columns.get(t.taskStatus) ?? [];
+        const quote = requestQuoteForTask(db, t.taskId, t.sessionId, quoteMemo);
         column.push({
             taskId: t.taskId,
             taskStatus: t.taskStatus,
@@ -1325,19 +2572,74 @@ export function kanban(db, epicId, scope = {}, opts = {}) {
                 origin: t.origin,
                 severity: worstSeverity(openSeverityByTask.get(t.taskId) ?? []),
             },
+            updatedAt: t.updatedAt,
+            project: t.project,
+            attemptCount: attemptCountByTask.get(t.taskId) ?? 0,
+            judgeRound: judgeRoundByTask.get(t.taskId) ?? null,
+            commentCount: commentCountByTask.get(t.taskId) ?? 0,
+            prUrl: t.epicId ? (prUrlByEpic.get(t.epicId) ?? null) : null,
+            dependencies: (edgesByTask.get(t.taskId) ?? []).map((e) => {
+                const dep = taskRowByTaskId.get(e.dependsOn);
+                return {
+                    taskId: e.dependsOn,
+                    title: dep?.objective ?? null,
+                    status: dep?.taskStatus ?? null,
+                    edgeType: e.edgeType,
+                };
+            }),
+            epicLabel: epicLabelFor(t.epicId, t.project, closedEpicIds),
+            hasRequest: quote !== null,
+            requestFirstLine: quote ? firstLineOf(quote.prompt) : null,
+            parentTaskId: parentByFollowUp.get(t.taskId) ?? null,
+            parentTitle: taskRowByTaskId.get(parentByFollowUp.get(t.taskId) ?? '')?.objective ?? null,
         });
         columns.set(t.taskStatus, column);
     }
+    // DS3 item 3 — deterministic order within a column: most recently updated
+    // first, task_id as the tiebreaker so two same-instant rows never flap.
     return [...columns.entries()]
         .sort(([a], [b]) => a.localeCompare(b))
-        .map(([taskStatus, tasksInColumn]) => ({ taskStatus, tasks: tasksInColumn }));
+        .map(([taskStatus, tasksInColumn]) => ({
+        taskStatus,
+        tasks: [...tasksInColumn].sort((a, b) => {
+            if (a.updatedAt !== b.updatedAt)
+                return a.updatedAt < b.updatedAt ? 1 : -1;
+            return a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0;
+        }),
+    }));
 }
-export function taskDetail(db, taskId) {
+/**
+ * The per-event position of an artifact row, parsed off its own id
+ * (`${eventId}#${index}`, projector.ts). Splitting on the LAST `#` keeps an
+ * event id that itself contains one (every event id does: `<session>#<n>`)
+ * from being cut in the wrong place.
+ */
+function artifactIndexOf(id) {
+    const cut = id.lastIndexOf('#');
+    const index = Number(id.slice(cut + 1));
+    return cut === -1 || Number.isNaN(index) ? 0 : index;
+}
+export function taskDetail(db, taskId, opts = {}) {
+    const nowIso = opts.nowIso ?? new Date().toISOString();
     const task = db.select().from(tasks).where(eq(tasks.taskId, taskId)).get();
     if (!task)
         return null;
     const dispatchRows = inLogOrder(db.select().from(dispatches).where(eq(dispatches.taskId, taskId)).all());
     const agentRows = db.select().from(agents).where(eq(agents.taskId, taskId)).all();
+    // Mirrors kanban()'s activityByTask: a live agents row dispatched inside
+    // the stale window is "working"; a live row past it is "stalled"; a
+    // working row wins over a stalled one on the same task.
+    let agentActivity = null;
+    for (const a of agentRows) {
+        if (a.status !== 'live')
+            continue;
+        if (isWorkingAt(a.dispatchedAt, nowIso)) {
+            agentActivity = 'working';
+            break;
+        }
+        if (agentActivity === null)
+            agentActivity = 'stalled';
+    }
     const agentByEventId = new Map(agentRows.map((a) => [a.id, a]));
     const attempts = dispatchRows.map((d) => {
         const agent = agentByEventId.get(d.eventId);
@@ -1352,7 +2654,28 @@ export function taskDetail(db, taskId) {
         };
     });
     const findingRows = db.select().from(findings).where(eq(findings.taskId, taskId)).all();
-    const artifactRows = db.select().from(artifacts).where(eq(artifacts.taskId, taskId)).all();
+    // Outputs tab, newest first (same operator request as taskRuns() above):
+    // newest event first (`compareLogOrder`, the same log-order comparator the
+    // rest of the log uses — plain `id desc` breaks because the index on
+    // `${eventId}#${index}` is unpadded text, so `#10` sorts between `#1` and
+    // `#2`), and within one event, the order the agent listed the artifacts in
+    // (index ascending).
+    const artifactRows = db
+        .select()
+        .from(artifacts)
+        .where(eq(artifacts.taskId, taskId))
+        .all()
+        .sort((a, b) => {
+        const logCmp = compareLogOrder(b, a);
+        if (logCmp !== 0)
+            return logCmp;
+        return artifactIndexOf(a.id) - artifactIndexOf(b.id);
+    });
+    const feedbackRows = db
+        .select()
+        .from(operatorFeedback)
+        .where(eq(operatorFeedback.taskId, taskId))
+        .all();
     return {
         task,
         claims: task.claims ? JSON.parse(task.claims) : [],
@@ -1360,9 +2683,251 @@ export function taskDetail(db, taskId) {
         agents: agentRows,
         findings: findingRows,
         artifacts: artifactRows,
+        feedback: feedbackRows,
         branch: task.branch,
+        requestQuote: requestQuoteForTask(db, task.taskId, task.sessionId),
+        agentActivity,
+    };
+}
+// ---------------------------------------------------------------------------
+// taskRuns()
+// ---------------------------------------------------------------------------
+const RUN_EVENT_TYPES = [
+    DISPATCH_EVENT_TYPE,
+    JUDGE_REPORT_EVENT_TYPE,
+    TASK_RESULT_EVENT_TYPE,
+    ERROR_EVENT_TYPE,
+    JUDGE_VERDICT_EVENT_TYPE,
+];
+const RUN_KIND_BY_EVENT_TYPE = {
+    [DISPATCH_EVENT_TYPE]: 'dispatch',
+    [JUDGE_REPORT_EVENT_TYPE]: 'judge-report',
+    [TASK_RESULT_EVENT_TYPE]: 'result',
+    [ERROR_EVENT_TYPE]: 'error',
+    [JUDGE_VERDICT_EVENT_TYPE]: 'judge-verdict',
+};
+function tokensTotalFromPayload(payload) {
+    const usage = readTokenUsage(payload.token_usage);
+    return usage.measured ? usage.total : null;
+}
+function outcomeFromPayload(eventType, payload) {
+    if (eventType === TASK_RESULT_EVENT_TYPE && typeof payload.run_status === 'string')
+        return payload.run_status;
+    if (eventType === ERROR_EVENT_TYPE && typeof payload.error === 'string')
+        return payload.error;
+    if (eventType === JUDGE_REPORT_EVENT_TYPE) {
+        // judge-reported carries no accept/dismiss verdict of its own (that is a
+        // separate judge-verdict event, handled below) — the closest the report
+        // payload has to an outcome is whether it attested "no findings" rather
+        // than naming a finding count.
+        if (payload.attested_by !== undefined && payload.attested_by !== null)
+            return 'no-findings';
+        if (typeof payload.finding_count === 'number')
+            return `${payload.finding_count}-findings`;
+    }
+    if (eventType === JUDGE_VERDICT_EVENT_TYPE) {
+        // A verdict that never ran reads like the Activity feed's title: `failed`,
+        // with the error code when the payload names one.
+        if (payload.ok === false)
+            return typeof payload.error_code === 'string' && payload.error_code !== ''
+                ? `failed: ${payload.error_code}`
+                : 'failed';
+        if (typeof payload.verdict === 'string')
+            return payload.verdict;
+    }
+    return null;
+}
+function fetchTaskRunRows(db, taskId) {
+    return inLogOrder(db
+        .select()
+        .from(eventsRaw)
+        .where(and(eq(eventsRaw.taskId, taskId), inArray(eventsRaw.eventType, [...RUN_EVENT_TYPES])))
+        .all());
+}
+export function taskRuns(db, taskId) {
+    // `fetchTaskRunRows` stays oldest-first (shared with `taskTotals()`, which
+    // reads "first dispatch" / "last result" off that order); newest-first is
+    // this function's own output shape, so the rows are reversed here, once.
+    const rows = fetchTaskRunRows(db, taskId).slice().reverse();
+    // A judge-verdict names neither role nor (mostly) round; the agents row it
+    // terminated does. One query for the page.
+    const verdictIds = rows
+        .filter((r) => r.eventType === JUDGE_VERDICT_EVENT_TYPE)
+        .map((r) => r.eventId);
+    const agentByTerminal = new Map(verdictIds.length === 0
+        ? []
+        : db
+            .select({ t: agents.terminalEventId, role: agents.agentRole, round: agents.round })
+            .from(agents)
+            .where(inArray(agents.terminalEventId, verdictIds))
+            .all()
+            .map((a) => [a.t, a]));
+    return rows.flatMap((r) => {
+        const kind = RUN_KIND_BY_EVENT_TYPE[r.eventType];
+        if (!kind)
+            return [];
+        const payload = JSON.parse(r.payload);
+        const agentRow = agentByTerminal.get(r.eventId);
+        const round = typeof payload.round === 'number' ? payload.round : (agentRow?.round ?? null);
+        return [
+            {
+                eventId: r.eventId,
+                ts: r.ts,
+                kind,
+                agentRole: typeof payload.agent_role === 'string' ? payload.agent_role : (agentRow?.role ?? null),
+                round: round ?? (r.eventType === DISPATCH_EVENT_TYPE ? 1 : null),
+                tokensTotal: tokensTotalFromPayload(payload),
+                outcome: outcomeFromPayload(r.eventType, payload),
+            },
+        ];
+    });
+}
+/**
+ * DS3 §2.4c — the per-task totals read above `RunHistoryTimeline`, additive
+ * on `GET /api/tasks/:taskId/runs`. Scoped to the same rows `taskRuns()`
+ * reads (no new event type, no writer); "not measured" is `null`, never a
+ * bare 0 (the spec's own phrasing for this bar).
+ */
+export function taskTotals(db, taskId) {
+    const rows = fetchTaskRunRows(db, taskId);
+    let tokensSum = 0;
+    let anyTokens = false;
+    let durationSum = 0;
+    let anyDuration = false;
+    let startTs = null;
+    let endTs = null;
+    for (const r of rows) {
+        // A verdict is history-only: the totals never counted it, and still don't.
+        if (r.eventType === JUDGE_VERDICT_EVENT_TYPE)
+            continue;
+        const payload = JSON.parse(r.payload);
+        const tokens = tokensTotalFromPayload(payload);
+        if (tokens !== null) {
+            tokensSum += tokens;
+            anyTokens = true;
+        }
+        const durationMs = durationMsFromPayload(payload);
+        if (durationMs !== null) {
+            durationSum += durationMs;
+            anyDuration = true;
+        }
+        const kind = RUN_KIND_BY_EVENT_TYPE[r.eventType];
+        if (kind === 'dispatch') {
+            if (startTs === null || r.ts < startTs)
+                startTs = r.ts;
+        }
+        if (kind === 'result' || kind === 'error') {
+            if (endTs === null || r.ts > endTs)
+                endTs = r.ts;
+        }
+    }
+    return {
+        tokens: anyTokens ? tokensSum : null,
+        agentTimeMs: anyDuration ? durationSum : null,
+        elapsedMs: startTs !== null && endTs !== null
+            ? new Date(endTs).getTime() - new Date(startTs).getTime()
+            : null,
+        startedAt: startTs,
+        endedAt: endTs,
     };
 }
+/** `tokensTotalFromPayload` reads `total_tokens` only; this reads the full measured triple. */
+function tokenUsageFromPayload(payload) {
+    const usage = readTokenUsage(payload.token_usage);
+    if (usage.measured && usage.input !== null && usage.output !== null) {
+        return { state: 'measured', input: usage.input, output: usage.output, total: usage.total };
+    }
+    return { state: 'unmeasured' };
+}
+/**
+ * Projection read only (no new writer): every agent `sessionId` has
+ * dispatched, grouped by role in first-dispatch order. An unknown session
+ * returns `{ roles: [] }` — the route turns that into its own 404, since
+ * "no agents" and "no such session" read the same from here.
+ */
+export function sessionAgents(db, sessionId, opts = {}) {
+    const nowIso = opts.nowIso ?? new Date().toISOString();
+    const agentRows = inLogOrder(db
+        .select()
+        .from(agents)
+        .where(eq(agents.sessionId, sessionId))
+        .all()
+        .map((a) => ({ ...a, ts: a.dispatchedAt, eventId: a.id })));
+    if (agentRows.length === 0)
+        return { sessionId, roles: [] };
+    const taskIds = [...new Set(agentRows.flatMap((a) => (a.taskId ? [a.taskId] : [])))];
+    const taskTitleById = new Map(taskIds.length > 0
+        ? db
+            .select({ taskId: tasks.taskId, title: tasks.title })
+            .from(tasks)
+            .where(inArray(tasks.taskId, taskIds))
+            .all()
+            .map((t) => [t.taskId, t.title])
+        : []);
+    const eventRows = db.select().from(eventsRaw).where(eq(eventsRaw.sessionId, sessionId)).all();
+    const terminalPayloadById = new Map(eventRows.map((e) => [e.eventId, e]));
+    const roleOrder = [];
+    const byRole = new Map();
+    for (const a of agentRows) {
+        const tokens = a.status === 'live'
+            ? { state: 'pending' }
+            : a.status === 'done'
+                ? (() => {
+                    const terminalEvent = a.terminalEventId
+                        ? terminalPayloadById.get(a.terminalEventId)
+                        : undefined;
+                    return terminalEvent
+                        ? tokenUsageFromPayload(JSON.parse(terminalEvent.payload))
+                        : { state: 'unmeasured' };
+                })()
+                : { state: 'none' };
+        const windowEnd = a.terminalAt ?? nowIso;
+        // Scoped to this agent's own task when it has one; an epic-level dispatch
+        // (no task) has no narrower column to filter on than the session itself.
+        const windowEvents = eventRows.filter((e) => {
+            if (e.ts < a.dispatchedAt || e.ts > windowEnd)
+                return false;
+            return a.taskId ? e.taskId === a.taskId : true;
+        });
+        const lastEvent = inLogOrder(windowEvents).at(-1) ?? null;
+        const entry = {
+            id: a.id,
+            agentRole: a.agentRole,
+            provider: a.provider,
+            modelTier: a.modelTier,
+            taskId: a.taskId,
+            taskTitle: a.taskId ? (taskTitleById.get(a.taskId) ?? null) : null,
+            epicId: a.epicId,
+            round: a.round,
+            dispatchedAt: a.dispatchedAt,
+            terminalAt: a.terminalAt,
+            terminalType: a.terminalType,
+            status: a.status,
+            tokens,
+            lastEventType: lastEvent?.eventType ?? null,
+            lastEventAt: lastEvent?.ts ?? null,
+        };
+        if (!byRole.has(a.agentRole)) {
+            roleOrder.push(a.agentRole);
+            byRole.set(a.agentRole, []);
+        }
+        byRole.get(a.agentRole)?.push(entry);
+    }
+    return {
+        sessionId,
+        roles: roleOrder.map((role) => ({ agentRole: role, agents: byRole.get(role) ?? [] })),
+    };
+}
+/**
+ * One projected artifact row by its id (`${event_id}#${index}`), for the
+ * dashboard's artifact-serving route — it needs the declaring task and the
+ * declared path to resolve a file, and neither is safe to take from the
+ * request itself.
+ */
+export function artifactById(db, artifactId) {
+    return db.select().from(artifacts).where(eq(artifacts.id, artifactId)).get() ?? null;
+}
+const LESSONS_PASS_COMPLETED_EVENT_TYPE = 'lessons-pass-completed';
 /**
  * Every `lesson_status` the taxonomy declares, mapped to the bucket the
  * Lessons page renders it in. Total on purpose (D-220).
@@ -1388,12 +2953,46 @@ export const LESSON_BUCKET_FOR_STATUS = {
     superseded: 'closed',
     invalidated: 'closed',
 };
+/**
+ * The owning-session lookup behind the dashboard's three lesson write routes
+ * (ui/server's `lessonSession()`) — the session whose log a lesson's
+ * transition has to fold and append to, not whichever session a request body
+ * names. Returns `null` rather than throwing when no such lesson is
+ * projected; the caller decides what a missing lesson means.
+ */
+export function lessonOwnerSession(db, lessonId) {
+    const row = db
+        .select({ sessionId: lessons.sessionId })
+        .from(lessons)
+        .where(eq(lessons.lessonId, lessonId))
+        .get();
+    return row ? row.sessionId : null;
+}
+/** The latest `lessons-pass-completed` event's ts, scoped the same way as the rest of the page. */
+function lastLessonsPassAt(db, scope) {
+    const eventCond = eq(eventsRaw.eventType, LESSONS_PASS_COMPLETED_EVENT_TYPE);
+    const sessionCond = scopedToSessions(eventsRaw.sessionId, scope);
+    const rows = db
+        .select({ ts: eventsRaw.ts })
+        .from(eventsRaw)
+        .where(sessionCond ? and(eventCond, sessionCond) : eventCond)
+        .all();
+    const first = rows[0];
+    if (!first)
+        return null;
+    return rows.reduce((latest, row) => (row.ts > latest ? row.ts : latest), first.ts);
+}
 export function lessonsPage(db, scope = {}) {
     const sessionCond = scopedToSessions(lessons.sessionId, scope);
     const rows = sessionCond
         ? db.select().from(lessons).where(sessionCond).all()
         : db.select().from(lessons).all();
-    const result = { pending: [], approved: [], closed: [] };
+    const result = {
+        pending: [],
+        approved: [],
+        closed: [],
+        lastCheckedAt: lastLessonsPassAt(db, scope),
+    };
     for (const row of rows) {
         // An unrecognised status lands in `closed` rather than nowhere: being
         // invisible is the defect this map exists to close, and a row the
@@ -1402,7 +3001,15 @@ export function lessonsPage(db, scope = {}) {
     }
     return result;
 }
-export function errorsPage(db, scope = {}) {
+const TREND_WINDOW_DAYS = 7;
+/** The UTC calendar day (`YYYY-MM-DD`) `daysAgo` days before `nowIso`'s own day. */
+function utcDayOffset(nowIso, daysAgo) {
+    const d = new Date(nowIso);
+    d.setUTCHours(0, 0, 0, 0);
+    d.setUTCDate(d.getUTCDate() - daysAgo);
+    return d.toISOString().slice(0, 10);
+}
+export function errorsPage(db, scope = {}, opts = {}) {
     const sessionCond = scopedToSessions(errors.sessionId, scope);
     const allRows = sessionCond
         ? db.select().from(errors).where(sessionCond).all()
@@ -1410,6 +3017,10 @@ export function errorsPage(db, scope = {}) {
     const rows = filterByProject(allRows, scope);
     const byClass = new Map();
     const byDay = new Map();
+    const nowIso = opts.nowIso ?? new Date().toISOString();
+    const trendDays = Array.from({ length: TREND_WINDOW_DAYS }, (_, i) => utcDayOffset(nowIso, TREND_WINDOW_DAYS - 1 - i));
+    const trendDayIndex = new Map(trendDays.map((day, i) => [day, i]));
+    const classSummaries = new Map();
     for (const row of rows) {
         const key = `${row.errorGroup}.${row.errorClass}|${row.severity}`;
         const existing = byClass.get(key);
@@ -1426,15 +3037,62 @@ export function errorsPage(db, scope = {}) {
         }
         const day = row.ts.slice(0, 10);
         byDay.set(day, (byDay.get(day) ?? 0) + 1);
+        const classKey = `${row.errorGroup}.${row.errorClass}`;
+        let summary = classSummaries.get(classKey);
+        if (!summary) {
+            summary = {
+                errorGroup: row.errorGroup,
+                errorClass: row.errorClass,
+                count: 0,
+                severityMix: {},
+                lastSeen: row.ts,
+                projects: new Set(),
+                trend7d: new Array(TREND_WINDOW_DAYS).fill(0),
+            };
+            classSummaries.set(classKey, summary);
+        }
+        summary.count += 1;
+        summary.severityMix[row.severity] = (summary.severityMix[row.severity] ?? 0) + 1;
+        if (row.ts > summary.lastSeen)
+            summary.lastSeen = row.ts;
+        if (row.project)
+            summary.projects.add(row.project);
+        const dayIndex = trendDayIndex.get(day);
+        if (dayIndex !== undefined)
+            summary.trend7d[dayIndex] = (summary.trend7d[dayIndex] ?? 0) + 1;
     }
     return {
         byClass: [...byClass.values()].sort((a, b) => b.count - a.count),
         byDay: [...byDay.entries()]
             .sort(([a], [b]) => a.localeCompare(b))
             .map(([day, count]) => ({ day, count })),
+        classSummary: [...classSummaries.entries()]
+            .map(([id, s]) => ({
+            id,
+            errorGroup: s.errorGroup,
+            errorClass: s.errorClass,
+            count: s.count,
+            severityMix: s.severityMix,
+            lastSeen: s.lastSeen,
+            projects: [...s.projects],
+            trend7d: s.trend7d,
+        }))
+            .sort((a, b) => b.count - a.count),
     };
 }
-export function analytics(db, scope = {}) {
+const PERIOD_DAYS = { '7d': 7, '30d': 30, '90d': 90 };
+/** The UTC calendar days in `period`'s window ending on `nowIso`'s UTC date, inclusive, oldest-first. */
+function periodDays(period, nowIso) {
+    const now = new Date(nowIso);
+    const endUtcMs = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+    const days = PERIOD_DAYS[period];
+    const out = [];
+    for (let i = days - 1; i >= 0; i -= 1) {
+        out.push(new Date(endUtcMs - i * 86_400_000).toISOString().slice(0, 10));
+    }
+    return out;
+}
+export function analytics(db, scope = {}, opts = {}) {
     const taskRows = allTasksForScope(db, scope);
     const inScope = taskInScope(db, scope);
     const throughputByDay = new Map();
@@ -1450,17 +3108,30 @@ export function analytics(db, scope = {}) {
     const eventSessionCond = scopedToSessions(eventsRaw.sessionId, scope);
     const resultRows = eventSessionCond
         ? db
-            .select({ taskId: eventsRaw.taskId, payload: eventsRaw.payload })
+            .select({ taskId: eventsRaw.taskId, payload: eventsRaw.payload, ts: eventsRaw.ts })
             .from(eventsRaw)
             .where(and(eq(eventsRaw.eventType, 'task-result-recorded'), eventSessionCond))
             .all()
         : db
-            .select({ taskId: eventsRaw.taskId, payload: eventsRaw.payload })
+            .select({ taskId: eventsRaw.taskId, payload: eventsRaw.payload, ts: eventsRaw.ts })
             .from(eventsRaw)
             .where(eq(eventsRaw.eventType, 'task-result-recorded'))
             .all();
+    // No `period`: every row, exactly the pre-DS7 behaviour (backward compat).
+    // With `period`: only rows whose UTC day falls in the window — this also
+    // answers DS7's "per-provider totals for the period" ask (spec §4.4's
+    // "providers with totalTokens > 0"), so no separate field is added for it.
+    const window = opts.period
+        ? periodDays(opts.period, opts.nowIso ?? new Date().toISOString())
+        : null;
+    const windowSet = window ? new Set(window) : null;
+    const scopedResultRows = windowSet
+        ? resultRows.filter((row) => windowSet.has(row.ts.slice(0, 10)))
+        : resultRows;
     const costBuckets = new Map();
-    for (const row of resultRows) {
+    const dailyBuckets = new Map();
+    const roleTierBuckets = new Map();
+    for (const row of scopedResultRows) {
         const p = JSON.parse(row.payload);
         // Column first, payload second: both spellings occur, and one real row
         // omits `payload.task_id` while the column carries it.
@@ -1469,21 +3140,85 @@ export function analytics(db, scope = {}) {
         if (!p.model_tier || !p.provider)
             continue;
         const key = `${p.model_tier}|${p.provider}`;
-        const bucket = costBuckets.get(key) ?? { taskCount: 0, totalTokens: 0 };
+        const bucket = costBuckets.get(key) ?? { taskCount: 0, totalTokens: 0, unmeasuredTaskCount: 0 };
         bucket.taskCount += 1;
-        bucket.totalTokens += p.token_usage?.total_tokens ?? 0;
+        const usage = readTokenUsage(p.token_usage);
+        if (usage.measured) {
+            bucket.totalTokens += usage.total;
+        }
+        else {
+            bucket.unmeasuredTaskCount += 1;
+        }
         costBuckets.set(key, bucket);
+        if (window) {
+            const role = p.agent ?? 'unattributed';
+            const day = row.ts.slice(0, 10);
+            const daily = dailyBuckets.get(day) ?? {
+                tokensByRole: new Map(),
+                tokensByModelTier: new Map(),
+                unmeasuredRunCount: 0,
+            };
+            if (usage.measured) {
+                daily.tokensByRole.set(role, (daily.tokensByRole.get(role) ?? 0) + usage.total);
+                daily.tokensByModelTier.set(p.model_tier, (daily.tokensByModelTier.get(p.model_tier) ?? 0) + usage.total);
+            }
+            else {
+                daily.unmeasuredRunCount += 1;
+            }
+            dailyBuckets.set(day, daily);
+            const roleTierKey = `${role}|${p.model_tier}`;
+            const roleTier = roleTierBuckets.get(roleTierKey) ?? {
+                runCount: 0,
+                tokens: 0,
+                unmeasuredRunCount: 0,
+            };
+            roleTier.runCount += 1;
+            if (usage.measured) {
+                roleTier.tokens += usage.total;
+            }
+            else {
+                roleTier.unmeasuredRunCount += 1;
+            }
+            roleTierBuckets.set(roleTierKey, roleTier);
+        }
     }
     const costByModelTierAndProvider = [...costBuckets.entries()].map(([key, v]) => {
         const [modelTier, provider] = key.split('|');
+        const measuredTaskCount = v.taskCount - v.unmeasuredTaskCount;
         return {
             modelTier,
             provider,
             taskCount: v.taskCount,
             totalTokens: v.totalTokens,
-            avgTokensPerTask: v.taskCount > 0 ? v.totalTokens / v.taskCount : 0,
+            avgTokensPerTask: measuredTaskCount > 0 ? v.totalTokens / measuredTaskCount : 0,
+            unmeasuredTaskCount: v.unmeasuredTaskCount,
         };
     });
+    const tokensByDay = window
+        ? window.map((day) => {
+            const daily = dailyBuckets.get(day);
+            return {
+                day,
+                tokensByRole: daily ? Object.fromEntries(daily.tokensByRole) : {},
+                tokensByModelTier: daily ? Object.fromEntries(daily.tokensByModelTier) : {},
+                unmeasuredRunCount: daily?.unmeasuredRunCount ?? 0,
+            };
+        })
+        : undefined;
+    const tokensByRoleAndModelTier = window
+        ? [...roleTierBuckets.entries()].map(([key, v]) => {
+            const [role, modelTier] = key.split('|');
+            const measuredRunCount = v.runCount - v.unmeasuredRunCount;
+            return {
+                role,
+                modelTier,
+                runCount: v.runCount,
+                tokens: v.tokens,
+                avgTokensPerRun: measuredRunCount > 0 ? v.tokens / measuredRunCount : null,
+                unmeasuredRunCount: v.unmeasuredRunCount,
+            };
+        })
+        : undefined;
     const decisionRows = eventSessionCond
         ? db
             .select({ ts: eventsRaw.ts, taskId: eventsRaw.taskId, payload: eventsRaw.payload })
@@ -1535,6 +3270,8 @@ export function analytics(db, scope = {}) {
         // Same db, same scope: a project-scoped page gets project-scoped judge
         // stats, and no second round trip is needed to render the card.
         providerAgreement: providerAgreement(db, scope),
+        ...(tokensByDay ? { tokensByDay } : {}),
+        ...(tokensByRoleAndModelTier ? { tokensByRoleAndModelTier } : {}),
     };
 }
 /**