@juzser/blacksmith 0.3.0 → 0.5.0

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

@@ -35,19 +35,21 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { eq } from 'drizzle-orm';
+import { and, eq, isNull } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/better-sqlite3';
 import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
 import { detectStale as detectStaleAgents, foldAgents, } from '../agents-registry.js';
 import { eventTaskId, listSessionIds, mergeSessionLogs, readEvents, } from '../events.js';
+import { foldOperatorFeedback } from '../feedback.js';
 import { findingScope, foldFindingsDetailed, missingProjectionFields, } from '../findings.js';
 import { DB_MIGRATIONS_DIR, roadmapReadPath, STATE_DB_PATH, STATE_EVENTS_DIR } from '../paths.js';
 import { isPlanRefTaskId, latestPlanVersion, loadPlan } from '../plan.js';
+import { normalizeProjectName } from '../projectName.js';
 import { loadRoadmap } from '../roadmap.js';
 import { assertRuntimeSupported } from '../runtime.js';
 import { bareTaskId, epicOfTaskId, isQualifiedTaskId, qualifyTaskId, taskIdsMatch, } from '../taskId.js';
 import { TERMINAL_TASK_STATUSES } from '../taskStatus.js';
-import { RESERVED_TASK_ID, taskBranchName } from '../worktree.js';
+import { LEGACY_BRANCH_PREFIX, RESERVED_TASK_ID, taskBranchName } from '../worktree.js';
 import * as schema from './schema.js';
 /** Open (creating if needed) the projection DB and ensure its schema is current. */
 export function openDb(dbPath = STATE_DB_PATH, opts = {}) {
@@ -79,6 +81,7 @@ const ALL_TABLES = [
     schema.artifacts,
     schema.milestones,
     schema.issue_reports,
+    schema.operatorFeedback,
 ];
 /** Delete every row in every projection table (full "drop" for rebuild()). */
 function clearAll(handle) {
@@ -105,6 +108,9 @@ function clearSession(db, sessionId) {
     // those tables whole (D-199, D-200, and the continuation case projectTasks()
     // describes). Deleting by session_id here would delete a row this session
     // raised and another session has since approved, closed or worked on.
+    // `operator_feedback` is absent for the same reason: a comment recorded here
+    // can be resolved from a later, continuing session, so
+    // projectOperatorFeedback() owns that table whole too.
 }
 /**
  * Fully replace the milestones table from factory/specs/roadmap.md (not
@@ -154,6 +160,19 @@ function projectMilestones(handle, opts) {
         }
     });
 }
+/** Task 3 (dispatch reason fallback): writers put the reason under other
+ * keys than `reason` — the dashboard's "Recent dispatch decisions" showed
+ * "no reason given" on almost every row because of it. Same chain as the
+ * UI's own fallback (ui/src/lib/timelineDisplay.ts's dispatchReasonText):
+ * no shared lib between the two runtimes, so it's kept in step by hand. */
+function dispatchReasonText(p) {
+    for (const key of ['reason', 'rationale', 'note', 'why']) {
+        const v = p[key];
+        if (typeof v === 'string' && v.trim() !== '')
+            return v.trim();
+    }
+    return null;
+}
 function describeShape(value) {
     if (value === null)
         return 'null';
@@ -161,6 +180,26 @@ function describeShape(value) {
         return 'an array';
     return typeof value === 'object' ? 'an object' : `a ${typeof value}`;
 }
+/**
+ * A hand-written `task-result-recorded` from before `validateResultArtifactsShape`
+ * (events.ts) started refusing non-array artifacts at append time keyed them
+ * by name instead of listing them, e.g. `{"claude_half":
+ * "scratchpad/r23/claude-half.json"}`. The event log is append-only history,
+ * so that line can never be rewritten into the array shape the guard now
+ * requires — read it as the legacy shape it plainly is, rather than holding
+ * it back forever behind a banner an operator can never clear.
+ *
+ * Only a non-empty plain object whose every value is a non-empty string
+ * counts: an empty object, one bad value, or any other non-array shape goes
+ * through the loud skip below (D-141 — a loud undercount beats a crash).
+ */
+function readLegacyArtifactsMap(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const entries = Object.entries(value);
+    const allPaths = entries.length > 0 && entries.every(([, v]) => typeof v === 'string' && v.length > 0);
+    return allPaths ? entries : null;
+}
 /** Splits an `error.class` string into its group/class parts; tolerant of malformed values. */
 function splitErrorClass(value) {
     const [group, cls] = (value ?? '').split('.');
@@ -218,10 +257,16 @@ function readClaims(raw) {
         return undefined;
     return raw.every((c) => typeof c === 'string') ? raw : undefined;
 }
+// Fills in `branch` for a `task-added` written before taskEvents.ts's
+// `addedPayload` carried that field at all — every such event predates the
+// field, so it was written by a build that only ever knew `smith/`, never
+// `bs/`. Defaulting to `BRANCH_PREFIX` here would assert a branch
+// `worktree create` never cut for that task; `LEGACY_BRANCH_PREFIX` is the
+// one prefix that build could have used.
 function branchFor(epicId, taskId) {
     if (!epicId)
         return null;
-    return taskBranchName(epicId, taskId);
+    return taskBranchName(epicId, taskId, LEGACY_BRANCH_PREFIX);
 }
 /**
  * Every (task id, epic) pair an event asserts: from the id itself when it is
@@ -396,23 +441,55 @@ function waveTaskIds(record) {
     const taskId = eventTaskId(record);
     return taskId ? [taskId] : [];
 }
+/**
+ * The tasks one error-logged event names: the envelope/payload `task_id`
+ * (D-245) when the producer set one, else `payload.task_ref` split on `,`
+ * and each part trimmed. A comma joins several real ids into one string
+ * when a producer logged a single check's failure against more than one
+ * task at once — events.ts's append-time guard now refuses to write that
+ * shape, but a log written before the guard existed still carries it, and
+ * foldTasks() replays every log ever written. Splitting here, not only in
+ * assertedTaskIds()'s pre-pass, is what keeps the two agreeing on what the
+ * event names (see that function's own comment) — a fix that touched one
+ * and not the other used to mint a card whose id was the literal
+ * "epic-1/task-1,epic-1/task-2" string.
+ */
+function errorTaskRefIds(record) {
+    const envelopeId = eventTaskId(record);
+    if (envelopeId)
+        return [envelopeId];
+    const ref = record.payload.task_ref;
+    if (!ref)
+        return [];
+    return ref
+        .split(',')
+        .map((id) => id.trim())
+        .filter(Boolean);
+}
+/**
+ * `record.project`, normalized through the legacy alias -- the one place an
+ * event's raw project value becomes the current one before it reaches a
+ * row, so an old event stamped `project: 'black-smith'` never lands in the
+ * projection under that name.
+ */
+function recordProject(record) {
+    return record.project === undefined ? undefined : normalizeProjectName(record.project);
+}
 /**
  * The task ids one event asserts something about, spelled the way foldTasks()'s
  * switch reads them: the envelope or payload `task_id` (D-245) for the
  * single-task events, `payload.task_ids` for a wave's admission or merge, and
- * `error-logged`'s own `payload.task_ref`. Kept beside the switch on purpose —
- * the two must agree on what names a task, or the walk touches an id the
- * pre-pass never saw.
+ * `error-logged`'s own `payload.task_ref` (or its comma-joined list — see
+ * errorTaskRefIds()). Kept beside the switch on purpose — the two must agree
+ * on what names a task, or the walk touches an id the pre-pass never saw.
  */
 function assertedTaskIds(record) {
     switch (record.event_type) {
         case 'wave-admitted':
         case 'wave-merged':
             return waveTaskIds(record);
-        case 'error-logged': {
-            const id = eventTaskId(record) ?? record.payload.task_ref;
-            return id ? [id] : [];
-        }
+        case 'error-logged':
+            return errorTaskRefIds(record);
         case 'task-added':
         case 'gate-outcome':
         case 'task-superseded': {
@@ -423,6 +500,27 @@ function assertedTaskIds(record) {
             return [];
     }
 }
+/**
+ * The agent role an event names, read the one place both spellings live.
+ * `dispatch_decision` and `judge-reported` carry it as `agent_role`
+ * (DispatchPayload; events.ts's PAYLOAD_TAG_MAP); `task-result-recorded`
+ * carries the same fact as `agent` (results.ts's `ResultEnvelope.agent` —
+ * the role the dispatcher sent the work to). One reader for both spellings,
+ * so the auditor-close/reopen checks below never grow a second string
+ * compare that could disagree with this one.
+ */
+function closingTurnRole(record) {
+    const p = record.payload;
+    if (record.event_type === 'task-result-recorded')
+        return p?.agent ?? null;
+    return p?.agent_role ?? null;
+}
+/** Whether an event names an auditor turn — the only role that closes or
+ * reopens a task row outside wave-merged/task-superseded/error-logged (an
+ * audit axis never joins a wave, so these are the only signals it gets). */
+function isAuditorTurn(record) {
+    return closingTurnRole(record) === 'auditor';
+}
 export function foldTasks(events, opts = {}) {
     const byId = new Map();
     // Normalisation happens at this boundary, once, before any row exists —
@@ -461,12 +559,15 @@ export function foldTasks(events, opts = {}) {
                 taskStatus: 'todo',
                 planVersion: null,
                 objective: null,
+                title: null,
+                summary: null,
                 claims: null,
                 budgetTokens: null,
                 branch: null,
                 createdAt: ts,
                 updatedAt: ts,
                 project: null,
+                terminalAt: null,
             };
             // Not every id an event carries is a task, and a ref that is not a
             // task must never surface as a kanban card. Three shapes are refused by
@@ -545,10 +646,12 @@ export function foldTasks(events, opts = {}) {
                     row.taskStatus = p.task_status ?? row.taskStatus;
                 row.planVersion = p.plan_version ?? row.planVersion;
                 row.objective = p.objective ?? row.objective;
+                row.title = p.title ?? row.title;
+                row.summary = p.summary ?? row.summary;
                 row.claims = readClaims(p.claims) ?? row.claims;
                 row.budgetTokens = p.budget_tokens ?? row.budgetTokens;
                 row.branch = p.branch ?? branchFor(row.epicId, row.taskId);
-                row.project = record.project ?? row.project;
+                row.project = recordProject(record) ?? row.project;
                 break;
             }
             case 'wave-admitted': {
@@ -570,9 +673,44 @@ export function foldTasks(events, opts = {}) {
                 if (!eventTask)
                     break;
                 const row = touch(eventTask, record.ts, record.session_id);
-                if (!TERMINAL_TASK_STATUSES.has(row.taskStatus))
+                const terminal = TERMINAL_TASK_STATUSES.has(row.taskStatus);
+                if (!terminal) {
                     row.taskStatus = 'in-progress';
-                row.project = record.project ?? row.project;
+                }
+                else if (isAuditorTurn(record) && row.taskStatus === 'completed') {
+                    // An audit axis never joins a wave, so a `completed` row only ever
+                    // got there via the judge-reported/task-result-recorded close
+                    // below — a later auditor dispatch for the same id is a re-run of
+                    // that axis, not a stray dispatch against a shipped plan task
+                    // (those always move through wave-merged/task-superseded/
+                    // error-logged instead, never this role). terminalAt resets to
+                    // null — schema.ts's comment on tasks.terminalAt ("null while the
+                    // task is still open") describes this row again, exactly. Any
+                    // other terminal status (escalated, failed, waived, superseded…)
+                    // is held open for the operator and must not be reopened here.
+                    row.taskStatus = 'in-progress';
+                    row.terminalAt = null;
+                }
+                row.project = recordProject(record) ?? row.project;
+                break;
+            }
+            case 'judge-reported':
+            case 'task-result-recorded': {
+                if (!eventTask)
+                    break;
+                if (!isAuditorTurn(record))
+                    break;
+                if (record.event_type === 'task-result-recorded') {
+                    const p = record.payload;
+                    if (p.run_status !== 'done')
+                        break;
+                }
+                const row = touch(eventTask, record.ts, record.session_id);
+                // First terminal transition wins — see schema.ts's terminalAt comment.
+                if (TERMINAL_TASK_STATUSES.has(row.taskStatus))
+                    break;
+                row.terminalAt = record.ts;
+                row.taskStatus = 'completed';
                 break;
             }
             case 'gate-outcome': {
@@ -594,38 +732,51 @@ export function foldTasks(events, opts = {}) {
             }
             case 'wave-merged': {
                 for (const taskId of waveTaskIds(record)) {
-                    touch(taskId, record.ts, record.session_id).taskStatus = 'completed';
+                    const row = touch(taskId, record.ts, record.session_id);
+                    // First terminal transition wins — see schema.ts's terminalAt comment.
+                    if (row.terminalAt === null)
+                        row.terminalAt = record.ts;
+                    row.taskStatus = 'completed';
                 }
                 break;
             }
             case 'task-superseded': {
                 if (!eventTask)
                     break;
-                touch(eventTask, record.ts, record.session_id).taskStatus = 'superseded';
+                const row = touch(eventTask, record.ts, record.session_id);
+                if (row.terminalAt === null)
+                    row.terminalAt = record.ts;
+                row.taskStatus = 'superseded';
                 break;
             }
             case 'error-logged': {
                 const p = record.payload;
-                // `task_ref` is this event's own spelling; eventTaskId covers the two
-                // the rest of the log uses (D-245).
-                const taskId = eventTask ?? p.task_ref;
-                if (!taskId)
-                    break;
-                const row = touch(taskId, record.ts, record.session_id);
-                row.project = record.project ?? row.project;
-                if (TERMINAL_TASK_STATUSES.has(row.taskStatus))
-                    break;
-                // Severity decides whether the task moves; the error class decides
-                // where. taxonomy.yml: S3 is "real but waivable; batched to operator
-                // at epic end", S4 is "logged, never asked" — a budget note or a
-                // tool hiccup at that level is on the record but the task carries on,
-                // and showing it as blocked is what the board did for 43 of the 55
-                // errors logged so far. A record with no severity is treated as
-                // major: the write path requires the field, so its absence means a
-                // log this reader does not own.
-                if (NOTE_ONLY_SEVERITIES.has(p.severity ?? ''))
-                    break;
-                row.taskStatus = p.error?.startsWith('coordination.') ? 'escalated' : 'blocked';
+                // errorTaskRefIds() is this event's own spelling (D-245's envelope
+                // reader, or a comma-joined `task_ref` split into its real ids) —
+                // shared with assertedTaskIds()'s pre-pass so the two agree.
+                const taskIds = errorTaskRefIds(record);
+                for (const taskId of taskIds) {
+                    const row = touch(taskId, record.ts, record.session_id);
+                    row.project = recordProject(record) ?? row.project;
+                    if (TERMINAL_TASK_STATUSES.has(row.taskStatus))
+                        continue;
+                    // Severity decides whether the task moves; the error class decides
+                    // where. taxonomy.yml: S3 is "real but waivable; batched to operator
+                    // at epic end", S4 is "logged, never asked" — a budget note or a
+                    // tool hiccup at that level is on the record but the task carries on,
+                    // and showing it as blocked is what the board did for 43 of the 55
+                    // errors logged so far. A record with no severity is treated as
+                    // major: the write path requires the field, so its absence means a
+                    // log this reader does not own.
+                    if (NOTE_ONLY_SEVERITIES.has(p.severity ?? ''))
+                        continue;
+                    const nextStatus = p.error?.startsWith('coordination.') ? 'escalated' : 'blocked';
+                    // Only `escalated` is terminal (TERMINAL_TASK_STATUSES); `blocked` is
+                    // not, so it never sets terminalAt.
+                    if (nextStatus === 'escalated' && row.terminalAt === null)
+                        row.terminalAt = record.ts;
+                    row.taskStatus = nextStatus;
+                }
                 break;
             }
             default:
@@ -755,7 +906,7 @@ export function foldEpics(events) {
             blockers: Array.isArray(p.blockers) ? p.blockers : [],
             closedAt: record.ts,
             eventId: event_id,
-            project: record.project ?? null,
+            project: recordProject(record) ?? null,
         });
     }
     return [...byId.values()];
@@ -784,7 +935,7 @@ export function foldEpics(events) {
  * deliberate that an absent project stays absent on the wire -- but it IS a
  * gap in these tables, because db/queries.ts's projectOf() resolves a NULL
  * column to the DEFAULT project. Left alone, every gate outcome and every
- * failure of a demo-rpg run reads back as black-smith's.
+ * failure of a demo-rpg run reads back as blacksmith's.
  *
  * A child row's project is its task's, which is exactly the rule the Scope
  * docblock in db/queries.ts already states (D-170). Derived from the same
@@ -821,7 +972,7 @@ function projectResolver(taskRows) {
  * rows fold to project NULL, projectResolver() hands the NULL down to every
  * dispatch and error under them, and db/queries.ts's projectOf() resolves the
  * lot to the DEFAULT project: the whole demo-rpg epic filed under
- * black-smith, its own board empty. That history cannot be repaired from the
+ * blacksmith, its own board empty. That history cannot be repaired from the
  * log, because the log never held the answer. The plan file did, all along.
  *
  * Same source and same precedence as the write side -- what the envelope
@@ -848,8 +999,12 @@ function planProjectResolver(specsDir) {
         let project = null;
         try {
             const version = latestPlanVersion(epicId, { specsDir });
-            if (version !== null)
-                project = loadPlan(epicId, version, { specsDir }).project ?? null;
+            if (version !== null) {
+                // The plan file is immutable and may still literally say the legacy
+                // name; normalize it the same way an event's project value is.
+                const planProject = loadPlan(epicId, version, { specsDir }).project;
+                project = planProject === undefined ? null : normalizeProjectName(planProject);
+            }
         }
         catch (err) {
             console.error(`db/projector.ts planProjectResolver(): plan file for "${epicId}" ` +
@@ -869,11 +1024,50 @@ function planProjectResolver(specsDir) {
  * projectTasks() writes the tasks table from another over every session's
  * log, and projectFindings() folds the same events again for
  * findings.project. Split the backfill across only one of them and a single
- * task reads as demo-rpg's on the board and black-smith's on the errors page.
+ * task reads as demo-rpg's on the board and blacksmith's on the errors page.
  */
 function foldTasksWithPlanProject(events, opts) {
     const projectFromPlan = planProjectResolver(opts.specsDir);
-    return foldTasks([...events], { specsDir: opts.specsDir }).map((t) => t.project === null ? { ...t, project: projectFromPlan(t.epicId) } : t);
+    const folded = foldTasks([...events], { specsDir: opts.specsDir });
+    // The log before the plan file: a task added with no project -- a follow-up
+    // minted inside a wave, whose runner stamps nothing -- belongs where the
+    // rest of its epic's tasks were stamped. The plan file is only read when
+    // the log has nothing to say, and it may not be the project's own (ui serve
+    // without --specs-dir reads the factory's specs).
+    const fromSiblings = unanimousEpicProjects(folded);
+    return folded.map((t) => t.project === null
+        ? {
+            ...t,
+            project: (t.epicId === null ? undefined : fromSiblings.get(t.epicId)) ??
+                projectFromPlan(t.epicId),
+        }
+        : t);
+}
+/**
+ * The one project each epic's tasks agree on, keyed by epic id.
+ *
+ * An epic belongs to one project, so a task of it that was never stamped
+ * belongs to the project its siblings were. An epic whose tasks name two
+ * projects breaks that assumption, and the map leaves it out rather than
+ * pick a winner by log order: an unanswered epic stays NULL, which is
+ * visible; a guessed one is filed under the wrong project silently.
+ */
+export function unanimousEpicProjects(rows) {
+    const seen = new Map();
+    for (const { epicId, project } of rows) {
+        if (!epicId || project === null)
+            continue;
+        const prior = seen.get(epicId);
+        if (prior === undefined)
+            seen.set(epicId, project);
+        else if (prior !== project)
+            seen.set(epicId, null);
+    }
+    const agreed = new Map();
+    for (const [epicId, project] of seen)
+        if (project !== null)
+            agreed.set(epicId, project);
+    return agreed;
 }
 export function projectSession(handle, sessionId, events, opts = {}) {
     const skippedArtifacts = [];
@@ -889,7 +1083,7 @@ export function projectSession(handle, sessionId, events, opts = {}) {
         // plan-file backfill lands here so they agree with the global one.
         const taskRows = foldTasksWithPlanProject(events, opts);
         const projectForTask = projectResolver(taskRows);
-        const projectForEpic = new Map(taskRows.flatMap((t) => (t.project === null ? [] : [[t.epicId, t.project]])));
+        const projectForEpic = unanimousEpicProjects(taskRows);
         /**
          * The project a row inherits from whatever its ref names, task or epic.
          *
@@ -899,7 +1093,7 @@ export function projectSession(handle, sessionId, events, opts = {}) {
          * them (D-250), so the task leg alone can never answer. Resolving through
          * it alone left those rows NULL, and queries.ts's projectOf() reads a NULL
          * back as the DEFAULT project, not as "unscoped": every one of them was
-         * filed under black-smith, including the one stop-the-line error in the
+         * filed under blacksmith, including the one stop-the-line error in the
          * shipped logs, which demo-rpg had raised (D-252).
          *
          * epicOfTaskId() answers for a qualified ref; `?? ref` covers the bare
@@ -939,8 +1133,11 @@ export function projectSession(handle, sessionId, events, opts = {}) {
                 planVersion: record.plan_version,
                 causalParent: record.causal_parent,
                 payload: JSON.stringify(record.payload),
-                project: record.project ?? projectForRef(eventTask),
+                project: recordProject(record) ?? projectForRef(eventTask),
                 actor: record.actor,
+                // Copied, never derived: absent on a log written outside a CLI
+                // session or before the stamp existed, and NULL here for both.
+                cliSessionId: record.cli_session_id ?? null,
             })
                 .run();
             if (record.event_type === 'user_prompt') {
@@ -973,10 +1170,10 @@ export function projectSession(handle, sessionId, events, opts = {}) {
                     provider: p.provider,
                     modelTier: p.model_tier,
                     specRef: p.spec_ref ?? null,
-                    reason: p.reason ?? null,
+                    reason: dispatchReasonText(p),
                     parentPromptId: p.parent_prompt_id ?? null,
                     causalParent: record.causal_parent,
-                    project: record.project ?? projectForRef(eventTask),
+                    project: recordProject(record) ?? projectForRef(eventTask),
                 })
                     .run();
                 continue;
@@ -1016,7 +1213,7 @@ export function projectSession(handle, sessionId, events, opts = {}) {
                     errorClass: cls,
                     severity: p.severity,
                     detail: p.detail ?? null,
-                    project: record.project ?? projectForRef(p.task_ref ?? eventTask),
+                    project: recordProject(record) ?? projectForRef(p.task_ref ?? eventTask),
                 })
                     .run();
                 continue;
@@ -1040,7 +1237,7 @@ export function projectSession(handle, sessionId, events, opts = {}) {
                     reason: p.reason ?? null,
                     repoSlug: p.repo_slug ?? null,
                     source: p.source ?? '',
-                    project: record.project ?? projectForRef(p.task_ref ?? eventTask),
+                    project: recordProject(record) ?? projectForRef(p.task_ref ?? eventTask),
                 })
                     .run();
                 continue;
@@ -1058,6 +1255,28 @@ export function projectSession(handle, sessionId, events, opts = {}) {
                 // nothing. Hold back the one list that cannot be read, name it, and
                 // keep going (D-141: a loud undercount beats a crash).
                 if (p.artifacts !== undefined && !Array.isArray(p.artifacts)) {
+                    const legacyMap = readLegacyArtifactsMap(p.artifacts);
+                    if (legacyMap) {
+                        legacyMap.forEach(([description, artifactPath], index) => {
+                            txDb
+                                .insert(schema.artifacts)
+                                .values({
+                                id: `${event_id}#${index}`,
+                                sessionId: record.session_id,
+                                taskId,
+                                eventId: event_id,
+                                ts: record.ts,
+                                // Never 'screenshot': this is history from before artifacts
+                                // carried a type at all. An image path can still reach the
+                                // gallery by its extension, which is what it is.
+                                type: 'file',
+                                path: artifactPath,
+                                description,
+                            })
+                                .run();
+                        });
+                        continue;
+                    }
                     skippedArtifacts.push({
                         event_id,
                         session_id: record.session_id,
@@ -1180,7 +1399,8 @@ export function projectSession(handle, sessionId, events, opts = {}) {
 export function projectTasks(handle, events, opts = {}) {
     handle.db.transaction((txDb) => {
         txDb.delete(schema.tasks).run();
-        for (const task of foldTasksWithPlanProject(events, opts)) {
+        const rows = foldTasksWithPlanProject(events, opts);
+        for (const task of rows) {
             txDb
                 .insert(schema.tasks)
                 .values({
@@ -1192,15 +1412,30 @@ export function projectTasks(handle, events, opts = {}) {
                 taskStatus: task.taskStatus,
                 planVersion: task.planVersion,
                 objective: task.objective,
+                title: task.title,
+                summary: task.summary,
                 claims: task.claims ? JSON.stringify(task.claims) : null,
                 budgetTokens: task.budgetTokens,
                 branch: task.branch,
                 createdAt: task.createdAt,
                 updatedAt: task.updatedAt,
                 project: task.project,
+                terminalAt: task.terminalAt,
             })
                 .run();
         }
+        // The epics row is written per session, and a session that closes an
+        // epic it never planned -- a continuation -- folds none of its tasks, so
+        // the row's own fallback (projectForEpic in projectSession) has nothing
+        // to read and stays NULL. Every session's tasks are in hand here: fill
+        // what is still unanswered, and never overwrite a stamped project.
+        for (const [epicId, project] of unanimousEpicProjects(rows)) {
+            txDb
+                .update(schema.epics)
+                .set({ project })
+                .where(and(eq(schema.epics.epicId, epicId), isNull(schema.epics.project)))
+                .run();
+        }
     });
 }
 /**
@@ -1265,6 +1500,41 @@ function projectLessons(handle, events) {
         }
     });
 }
+/**
+ * Fully replace the operator_feedback table from EVERY session's log at
+ * once, in one causal order (mergeSessionLogs) — the same shape as
+ * projectLessons() above, and for the same reason: a comment recorded in one
+ * session's log is routinely resolved (bounced, or turned into a follow-up
+ * task) from a later, continuing session, so the table's primary key is the
+ * feedback id, not (session, feedback) — one global key, one global fold.
+ * feedback.ts's foldOperatorFeedback() already resolves a `resolved` event
+ * against the `recorded` row it belongs to; this only re-inserts the result.
+ */
+function projectOperatorFeedback(handle, events) {
+    handle.db.transaction((txDb) => {
+        txDb.delete(schema.operatorFeedback).run();
+        for (const row of foldOperatorFeedback(events)) {
+            txDb
+                .insert(schema.operatorFeedback)
+                .values({
+                id: row.feedbackId,
+                taskId: row.taskId,
+                sessionId: row.sessionId,
+                body: row.body,
+                kind: row.kind,
+                source: row.source,
+                externalId: row.externalId,
+                author: row.author,
+                recordedAt: row.recordedAt,
+                recordedEventId: row.recordedEventId,
+                resolvedAt: row.resolvedAt,
+                resolution: row.resolution,
+                followUpTaskId: row.followUpTaskId,
+            })
+                .run();
+        }
+    });
+}
 function findingTimestamps(events) {
     const stamps = new Map();
     for (const { event_id, record } of events) {
@@ -1349,7 +1619,7 @@ function projectFindings(handle, events, opts) {
     // against `<epic>/integration`, a pseudo-task that never gets a task row:
     // no task lookup can ever answer for it, its epic always can, and the row
     // already stores that epic. On the shipped logs this is 37 of 56 findings.
-    const projectForEpic = new Map(taskRows.flatMap((t) => (t.project === null ? [] : [[t.epicId, t.project]])));
+    const projectForEpic = unanimousEpicProjects(taskRows);
     const projectFromPlan = planProjectResolver(opts.specsDir);
     const rows = [];
     for (const finding of findings) {
@@ -1387,7 +1657,7 @@ function projectFindings(handle, events, opts) {
             taskId: finding.task_id,
             epicId: findingEpicId,
             project: projectForTask(finding.task_id) ??
-                projectForEpic.get(findingEpicId) ??
+                (findingEpicId === null ? undefined : projectForEpic.get(findingEpicId)) ??
                 projectFromPlan(findingEpicId),
             fingerprint: finding.fingerprint,
             findingCategory: finding.finding_category,
@@ -1472,6 +1742,7 @@ export async function rebuild(dbPath = STATE_DB_PATH, sessions = 'all', opts = {
         projectTasks(handle, merged, opts);
         const skippedFindings = projectFindings(handle, merged, opts);
         projectLessons(handle, merged);
+        projectOperatorFeedback(handle, merged);
         projectMilestones(handle, opts);
         return {
             sessionsProcessed: sessionIds.length,
@@ -1490,10 +1761,11 @@ export async function rebuild(dbPath = STATE_DB_PATH, sessions = 'all', opts = {
  * replaces only its rows, leaving every other session's projection intact.
  * Safe to call repeatedly while a session is still running (tailing).
  *
- * The four tables that are not session-scoped are rewritten whole on every
+ * The five tables that are not session-scoped are rewritten whole on every
  * call: `milestones` from roadmap.md, and — from every session's log, which is
  * why this reads more than the one session it re-folds — `tasks`
- * (projectTasks()), `lessons` (D-199) and `findings` (D-200).
+ * (projectTasks()), `lessons` (D-199), `findings` (D-200) and
+ * `operator_feedback` (projectOperatorFeedback(), same shape).
  */
 export async function apply(dbPath = STATE_DB_PATH, sessionId, opts = {}) {
     const handle = openDb(dbPath, opts);
@@ -1516,6 +1788,7 @@ export async function apply(dbPath = STATE_DB_PATH, sessionId, opts = {}) {
         projectTasks(handle, merged, opts);
         const skippedFindings = projectFindings(handle, merged, opts);
         projectLessons(handle, merged);
+        projectOperatorFeedback(handle, merged);
         projectMilestones(handle, opts);
         return {
             sessionsProcessed: 1,