@juzser/blacksmith 0.2.0 → 0.4.0

package/factory/orchestrator/dist/daemon.js

@@ -22,10 +22,12 @@ import { loadCrosscheckPolicy } from './crosscheck.js';
 import { apply, foldTasks, rebuild } from './db/projector.js';
 import { summariseEpicWidth, UNMEASURED_HINT } from './epicWidth.js';
 import { SmithError } from './errors.js';
-import { listSessionIds, mergeSessionLogs, parseEventId, readEvents, } from './events.js';
+import { listSessionIds, mergeSessionLogs, parseEventId } from './events.js';
 import { ageFindings, memoryOf } from './findingAge.js';
+import { LogCache } from './logCache.js';
 import { STATE_DAEMON_DIR, STATE_DB_PATH, STATE_EVENTS_DIR } from './paths.js';
 import { unwatchedProjects } from './projects.js';
+import { FACTORY_PROJECT } from './roadmap.js';
 import { computeProposals, loadSchedulerPolicy, } from './scheduler.js';
 import { foldSpecChanges } from './specChange.js';
 export class DaemonError extends SmithError {
@@ -62,6 +64,20 @@ function admitFor(proposals, events, lens) {
 function staleSubject(agent) {
     return agent.taskId ?? agent.epicId ?? agent.agentId ?? agent.id;
 }
+/**
+ * The session an event id names, for a finding that has nothing better to key
+ * on than the id of the event that raised it. `null` on anything that is not
+ * a well-formed event id, rather than throwing — a proposal's origin is a
+ * nicety, not a fact `inspectSession` should die over.
+ */
+function originSessionId(eventId) {
+    try {
+        return parseEventId(eventId).sessionId;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Everything one session's lineage says about itself: spend against the epic
  * cap, dispatches nobody can be billed for, agents that never came back, and
@@ -118,10 +134,24 @@ export function inspectSession(sessionId, events, opts = {}) {
         });
     }
     for (const agent of detectStale(foldAgents(events), now.toISOString(), staleHours)) {
+        // Same rule as the budget check above, and the same reason: a closed
+        // epic's dispatch cannot still be live, so flagging it would raise the
+        // same line every tick until the log is archived. `foldAgents`'s own
+        // epic-closed handling only closes an entry against the session that
+        // closed it (D-234) — a dispatch and the epic's close can sit in
+        // different sessions of one lineage, which is exactly the shape this
+        // tick's merged log hands here, so the same-session fold alone would
+        // miss it.
+        if (agent.epicId !== null && closedEpics.has(agent.epicId))
+            continue;
         findings.push({
             kind: 'stale-agent',
             severity: 'attention',
-            sessionId,
+            // The dispatch's own session, not the tree's primary leaf: a fork
+            // asks inspectSession once for the whole tree, and the agent that
+            // never came back belongs to whichever session actually dispatched
+            // it.
+            sessionId: agent.sessionId,
             subject: staleSubject(agent),
             detail: `${agent.agentRole} (${agent.provider}/${agent.modelTier}) has been live for ` +
                 `${agent.liveHours.toFixed(1)}h with no result, error or supersession — past the ` +
@@ -141,7 +171,10 @@ export function inspectSession(sessionId, events, opts = {}) {
         findings.push({
             kind: 'spec-change',
             severity: proposal.blocking ? 'attention' : 'info',
-            sessionId,
+            // `proposalId` is the `spec-change-proposed` event's own id, so this is
+            // the session that actually raised the proposal — not the tree's
+            // primary leaf, which a fork may have picked for an unrelated sibling.
+            sessionId: originSessionId(proposal.proposalId) ?? sessionId,
             subject: proposal.taskId,
             detail: `${proposal.proposedBy} proposes amending ${proposal.criterionRef}: ${proposal.assumption} ` +
                 `(${proposal.severity}, ${proposal.blocking ? 'blocking' : 'non-blocking'}, ` +
@@ -149,21 +182,63 @@ export function inspectSession(sessionId, events, opts = {}) {
                 `${proposal.proposalId}\` or \`smith plan reject ${proposal.proposalId}\`.`,
         });
     }
-    const proposals = computeProposals({ events, now, policy: schedulerPolicy });
+    const proposals = computeProposals({
+        events,
+        now,
+        policy: schedulerPolicy,
+        ...(opts.resolveProjectForTaskRef === undefined
+            ? {}
+            : { resolveProjectForTaskRef: opts.resolveProjectForTaskRef }),
+        ...(opts.selfFallbackForTaskRef === undefined
+            ? {}
+            : { selfFallbackForTaskRef: opts.selfFallbackForTaskRef }),
+    });
     const admissions = admitFor(proposals, events, opts.admission);
+    // `TaskFoldRow.sessionId` is stamped once, the first time `touch()` builds
+    // the row, and never overwritten by a later touch — the task's origin
+    // session, not whichever one most recently merged or dispatched against it.
+    const taskSession = new Map(foldTasks(events).map((row) => [row.taskId, row.sessionId]));
     for (const [index, proposal] of proposals.entries()) {
-        if (proposal.kind !== 'recheck')
-            continue;
         const admission = admissions[index];
-        findings.push({
-            kind: 'recheck',
-            severity: 'info',
-            sessionId,
-            subject: proposal.taskId,
-            detail: `Recheck due (${proposal.reasons.join(', ')}): ${proposal.mergeCount} later overlapping ` +
-                `merge(s), ${proposal.daysElapsed} day(s) elapsed, confidence ${proposal.confidence}.`,
-            ...(admission === undefined ? {} : { admission }),
-        });
+        if (proposal.kind === 'recheck') {
+            findings.push({
+                kind: 'recheck',
+                severity: 'info',
+                sessionId: taskSession.get(proposal.taskId) ?? sessionId,
+                subject: proposal.taskId,
+                detail: `Recheck due (${proposal.reasons.join(', ')}): ${proposal.mergeCount} later overlapping ` +
+                    `merge(s), ${proposal.daysElapsed} day(s) elapsed, confidence ${proposal.confidence}.`,
+                ...(admission === undefined ? {} : { admission }),
+            });
+        }
+        else if (proposal.kind === 'error-report') {
+            // An error the log holds that nobody has reported — the session died
+            // before its run could. `info`, not `attention`: the error itself was
+            // raised when it happened, and what is left is work to schedule, which
+            // the discharge command below clears. Reported here and not in
+            // inspectFactory because `issue-reported` lands in the error's own
+            // session, so this lineage is the one that can answer it.
+            const project = proposal.project === null
+                ? ' (unresolved project)'
+                : proposal.project === FACTORY_PROJECT
+                    ? ''
+                    : ` (${proposal.project})`;
+            const projectPhrase = proposal.project === null ? 'an unresolved project' : `project ${proposal.project}`;
+            findings.push({
+                kind: 'unreported-error',
+                severity: 'info',
+                // `report.session_id` — the session the error actually lives in, and
+                // the same one the detail text below already sends the operator to.
+                sessionId: proposal.sessionId,
+                subject: `error ${proposal.fingerprint}${project}`,
+                detail: `Error ${proposal.fingerprint} in ${projectPhrase} ` +
+                    `(${proposal.errorClass}, task ${proposal.taskRef}, ${proposal.occurrences} occurrence(s)) ` +
+                    'has no issue-reported event. Report it with ' +
+                    `\`smith issues report --session ${proposal.sessionId}\`; ` +
+                    `\`smith issues preview --session ${proposal.sessionId}\` is the dry run.`,
+                ...(admission === undefined ? {} : { admission }),
+            });
+        }
     }
     return findings;
 }
@@ -186,6 +261,12 @@ export function inspectFactory(events, opts = {}) {
         policy,
         ...(opts.projectDirs === undefined ? {} : { projectDirs: opts.projectDirs }),
         ...(opts.readOutdated === undefined ? {} : { readOutdated: opts.readOutdated }),
+        ...(opts.resolveProjectForTaskRef === undefined
+            ? {}
+            : { resolveProjectForTaskRef: opts.resolveProjectForTaskRef }),
+        ...(opts.selfFallbackForTaskRef === undefined
+            ? {}
+            : { selfFallbackForTaskRef: opts.selfFallbackForTaskRef }),
     });
     const admissions = admitFor(proposals, events, opts.admission);
     for (const [index, proposal] of proposals.entries()) {
@@ -221,9 +302,9 @@ export function inspectFactory(events, opts = {}) {
                 ...(admission === undefined ? {} : { admission }),
             });
         }
-        // Rechecks are deliberately dropped here: inspectSession already reports
-        // each against the session that owns it, and a second copy with no session
-        // is a duplicate an operator cannot act on.
+        // Rechecks and unreported errors are deliberately dropped here: inspectSession
+        // already reports each against the session that owns it, and a second copy
+        // with no session is a duplicate an operator cannot act on.
     }
     // The claim this repo rests on, watched instead of waited on. `smith epic
     // width` answers it over all of history the moment somebody types it — and
@@ -321,21 +402,29 @@ function errorMessage(err) {
 /**
  * One pass over the state directory.
  *
- * Two rules hold it together. It reads every log ONCE and folds lineages in
- * memory, so a five-session lineage reports one budget alarm rather than five
- * (D-119's argument, read from the other end). And no single unreadable log or
- * failed projection ends the tick: both become findings, because a watchdog
- * that dies on the first corrupt line is a watchdog that is silent exactly
- * when something is wrong.
+ * Two rules hold it together. It reads every log ONCE and folds each lineage
+ * TREE in memory — not once per leaf — so a five-session chain reports one
+ * budget alarm rather than five (D-119's argument, read from the other end),
+ * and a base session that forked into several wave children reports it once
+ * rather than once per sibling. And no single unreadable log or failed
+ * projection ends the tick: both become findings, because a watchdog that
+ * dies on the first corrupt line is a watchdog that is silent exactly when
+ * something is wrong.
  */
 export async function runTick(opts = {}) {
     const now = opts.now ?? new Date();
     const stateDir = opts.stateDir ?? STATE_EVENTS_DIR;
     const findings = [];
+    // No shared cache passed in: a fresh one is cold for every session, so this
+    // reads identically to the old `readEvents`-per-session loop — one full
+    // read per log, this call only.
+    const cache = opts.logCache ?? new LogCache();
     const logs = new Map();
+    const liveSessionIds = new Set();
     for (const sessionId of listSessionIds(stateDir)) {
+        liveSessionIds.add(sessionId);
         try {
-            logs.set(sessionId, await readEvents(sessionId, { stateDir }));
+            logs.set(sessionId, await cache.read(sessionId, { stateDir }));
         }
         catch (err) {
             findings.push({
@@ -347,6 +436,13 @@ export async function runTick(opts = {}) {
             });
         }
     }
+    // Sessions that disappear from `listSessionIds` are evicted here, on the
+    // next tick, so the cache's memory is bounded by live logs, not by
+    // history. Driven by the LISTED set, not the read-succeeded set: a session
+    // that is listed but unreadable this tick keeps its entry. On a fresh,
+    // unshared cache (`opts.logCache` undefined) this is a no-op -- nothing
+    // was cached to evict.
+    cache.retainOnly(liveSessionIds);
     const parentOf = new Map();
     for (const [sessionId, events] of logs) {
         const root = events.find((e) => e.record.event_type === ROOT_EVENT_TYPE);
@@ -368,17 +464,59 @@ export async function runTick(opts = {}) {
             ancestors.add(parent);
     }
     const leaves = [...logs.keys()].filter((id) => !ancestors.has(id)).sort();
-    const lineageOf = (leaf) => {
-        const chain = [];
+    // parentOf inverted: a session's immediate children among the sessions this
+    // tick loaded. Lets a shared ancestor's descendants be walked forward once,
+    // instead of re-walked backward once per leaf below it.
+    const childrenOf = new Map();
+    for (const [childId, parent] of parentOf) {
+        if (parent === null || !logs.has(parent))
+            continue;
+        const siblings = childrenOf.get(parent) ?? [];
+        siblings.push(childId);
+        childrenOf.set(parent, siblings);
+    }
+    // The furthest ancestor of `id` that this tick still holds a log for — the
+    // root of the tree `id` belongs to, and the same root for every session in
+    // that tree regardless of which leaf asks.
+    const rootOf = (id) => {
+        let current = id;
         const seen = new Set();
-        let current = leaf;
-        while (current !== null && logs.has(current) && !seen.has(current)) {
+        while (true) {
+            const parent = parentOf.get(current) ?? null;
+            if (parent === null || !logs.has(parent) || seen.has(current))
+                return current;
             seen.add(current);
-            chain.unshift(current);
-            current = parentOf.get(current) ?? null;
+            current = parent;
+        }
+    };
+    // Every session reachable from `root` by walking children — the whole tree
+    // a lineage forks into, not just the one leaf that happened to ask for it.
+    // Guarded like rootOf: a cycle in causal parents must cost a tick nothing,
+    // not grow this list until the process dies.
+    const treeSessions = (root) => {
+        const all = [root];
+        const seen = new Set(all);
+        for (let i = 0; i < all.length; i += 1) {
+            for (const child of childrenOf.get(all[i]) ?? []) {
+                if (seen.has(child))
+                    continue;
+                seen.add(child);
+                all.push(child);
+            }
         }
-        return chain.map((sessionId) => ({ sessionId, events: logs.get(sessionId) ?? [] }));
+        return all;
     };
+    // Leaves grouped by the tree they fork from. A base session with several
+    // wave children is one tree with several leaves — inspected once, not once
+    // per sibling, so the shared ancestor's findings are not re-emitted once
+    // per fork (the D-119 argument, which a single chain never forks to break).
+    const leavesByRoot = new Map();
+    for (const leaf of leaves) {
+        const root = rootOf(leaf);
+        const group = leavesByRoot.get(root) ?? [];
+        group.push(leaf);
+        leavesByRoot.set(root, group);
+    }
     // A tick reports the admission line by default, where `inspectSession` and
     // `inspectFactory` stay silent unless asked. The asymmetry is deliberate: a
     // caller who reaches for one function is answering their own question and
@@ -400,6 +538,12 @@ export async function runTick(opts = {}) {
         ...(opts.projectDirs === undefined ? {} : { projectDirs: opts.projectDirs }),
         ...(opts.readOutdated === undefined ? {} : { readOutdated: opts.readOutdated }),
         ...(opts.readProjects === undefined ? {} : { readProjects: opts.readProjects }),
+        ...(opts.resolveProjectForTaskRef === undefined
+            ? {}
+            : { resolveProjectForTaskRef: opts.resolveProjectForTaskRef }),
+        ...(opts.selfFallbackForTaskRef === undefined
+            ? {}
+            : { selfFallbackForTaskRef: opts.selfFallbackForTaskRef }),
     };
     const projectDb = opts.projectDb ?? true;
     const dbPath = opts.dbPath ?? STATE_DB_PATH;
@@ -415,16 +559,55 @@ export async function runTick(opts = {}) {
         detail: `The read-model refresh failed: ${errorMessage(err)}. The event log is unaffected — ` +
             'it is the UI and `smith status` that are now stale.',
     });
-    for (const leaf of leaves) {
-        findings.push(...inspectSession(leaf, mergeSessionLogs(lineageOf(leaf)), inspectOpts));
-        if (!projectDb)
-            continue;
-        try {
-            await apply(dbPath, leaf, dbOpts);
-            projected += 1;
+    for (const [root, group] of leavesByRoot) {
+        // Sorted, so a forked tree attributes its shared findings to the same
+        // leaf on every tick, rather than whichever one Map iteration hands back
+        // first — the same determinism `leaves` itself already sorts for.
+        const primary = [...group].sort()[0];
+        const merged = mergeSessionLogs(treeSessions(root).map((sessionId) => ({ sessionId, events: logs.get(sessionId) ?? [] })));
+        findings.push(...inspectSession(primary, merged, inspectOpts));
+    }
+    // The signature a leaf's projection was last applied against: every
+    // session in its own upward chain, keyed by the fingerprint the cache read
+    // it at. Two ticks that see the same fingerprints for the same chain saw
+    // no change anywhere that leaf's own projection or lineage-scoped folds
+    // depend on, so re-applying would write the same rows a second time.
+    // `opts.logCache === undefined` opts a caller all the way out: with no
+    // cache to remember a signature against, every leaf is applied every tick,
+    // unchanged from before this cache existed.
+    const leafSignature = (leaf) => {
+        const chain = [];
+        const seen = new Set();
+        let current = leaf;
+        while (current !== null && !seen.has(current)) {
+            seen.add(current);
+            chain.push(current);
+            const parent = parentOf.get(current) ?? null;
+            current = parent !== null && logs.has(parent) ? parent : null;
         }
-        catch (err) {
-            findings.push(projectionFailed(leaf, err));
+        return chain
+            .map((id) => {
+            const fp = cache.fingerprintOf(id);
+            return fp === undefined ? `${id}:?` : `${id}:${fp.dev}.${fp.ino}.${fp.size}.${fp.mtimeMs}`;
+        })
+            .join('|');
+    };
+    const applyFn = opts.applyFn ?? apply;
+    if (projectDb) {
+        for (const leaf of leaves) {
+            const signature = opts.logCache === undefined ? undefined : leafSignature(leaf);
+            if (signature !== undefined && opts.logCache?.getAppliedSignature(leaf) === signature) {
+                continue;
+            }
+            try {
+                await applyFn(dbPath, leaf, dbOpts);
+                projected += 1;
+                if (signature !== undefined)
+                    opts.logCache?.setAppliedSignature(leaf, signature);
+            }
+            catch (err) {
+                findings.push(projectionFailed(leaf, err));
+            }
         }
     }
     // The read-model is not made of sessions alone. `milestones` is a full
@@ -661,6 +844,10 @@ export async function runDaemon(opts) {
     const tick = opts.tick ?? runTick;
     const sleep = opts.sleep ?? defaultSleep;
     const shouldContinue = opts.shouldContinue ?? (() => true);
+    // One cache for the whole run: this is the loop finding 50acc356 is about
+    // — the process that survives long enough for "every tick re-reads every
+    // byte ever written" to matter.
+    const logCache = opts.logCache ?? new LogCache();
     acquireLock(opts.dir, { pid, startedAt, intervalSeconds }, opts.isAlive === undefined ? {} : { isAlive: opts.isAlive });
     const tickOptions = {
         ...(opts.now === undefined ? {} : { now: opts.now }),
@@ -673,6 +860,8 @@ export async function runDaemon(opts) {
         ...(opts.projectDb === undefined ? {} : { projectDb: opts.projectDb }),
         ...(opts.dbPath === undefined ? {} : { dbPath: opts.dbPath }),
         ...(opts.dbOpts === undefined ? {} : { dbOpts: opts.dbOpts }),
+        ...(opts.applyFn === undefined ? {} : { applyFn: opts.applyFn }),
+        logCache,
     };
     // Read from disk rather than held in a variable, so a daemon restarted by
     // cron or by the operator picks up where the last process stopped. A tick

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

@@ -46,6 +46,7 @@ import { isPlanRefTaskId, latestPlanVersion, loadPlan } from '../plan.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 * as schema from './schema.js';
 /** Open (creating if needed) the projection DB and ensure its schema is current. */
@@ -77,6 +78,7 @@ const ALL_TABLES = [
     schema.lessons,
     schema.artifacts,
     schema.milestones,
+    schema.issue_reports,
 ];
 /** Delete every row in every projection table (full "drop" for rebuild()). */
 function clearAll(handle) {
@@ -97,6 +99,7 @@ function clearSession(db, sessionId) {
     db.delete(schema.errors).where(eq(schema.errors.sessionId, sessionId)).run();
     db.delete(schema.waivers).where(eq(schema.waivers.sessionId, sessionId)).run();
     db.delete(schema.artifacts).where(eq(schema.artifacts.sessionId, sessionId)).run();
+    db.delete(schema.issue_reports).where(eq(schema.issue_reports.sessionId, sessionId)).run();
     // `lessons`, `findings` and `tasks` are deliberately absent, like
     // `milestones` — projectLessons(), projectFindings() and projectTasks() own
     // those tables whole (D-199, D-200, and the continuation case projectTasks()
@@ -145,6 +148,7 @@ function projectMilestones(handle, opts) {
                 epicIds: JSON.stringify(m.epicIds),
                 project: m.project,
                 kind: m.kind,
+                errorIssues: m.errorIssuesEnabled,
             })
                 .run();
         }
@@ -162,16 +166,21 @@ function splitErrorClass(value) {
     const [group, cls] = (value ?? '').split('.');
     return { group: group ?? 'unknown', cls: cls ?? 'unknown' };
 }
-const TERMINAL_TASK_STATUSES = new Set([
-    'completed',
-    'superseded',
-    'failed',
-    'escalated',
-    'waived',
-]);
 /**
- * Severities that record an error without stopping the task (taxonomy.yml
- * `severity`). An `error-logged` at one of these leaves `task_status` alone.
+ * Severities that record an error without stopping the task: the
+ * `blocks_merge: false` half of `factory/policies/severity.yml`. An
+ * `error-logged` at one of these leaves `task_status` alone.
+ *
+ * It is a literal rather than a read of that file on purpose. `apply()` and
+ * `rebuild()` are a deterministic fold over the event log, and a fold that
+ * consulted today's policy would replay a months-old log under a ruling
+ * nobody had made when it was written — the board would change because a
+ * policy did, with no event to point at. So the copy stays, and a test holds
+ * it to the policy instead: `test/db/projector.test.ts`, "an error-logged
+ * moves a task only when its severity says so", drives this fold once per
+ * severity severity.yml declares. Declare a non-blocking one without adding
+ * it here and that test fails rather than the board quietly showing its
+ * tasks as blocked.
  */
 const NOTE_ONLY_SEVERITIES = new Set(['S3-minor', 'S4-nit']);
 /**
@@ -387,23 +396,46 @@ 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);
+}
 /**
  * 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': {
@@ -597,26 +629,27 @@ export function foldTasks(events, opts = {}) {
             }
             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 = record.project ?? 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;
+                    row.taskStatus = p.error?.startsWith('coordination.') ? 'escalated' : 'blocked';
+                }
                 break;
             }
             default:
@@ -1012,6 +1045,30 @@ export function projectSession(handle, sessionId, events, opts = {}) {
                     .run();
                 continue;
             }
+            if (record.event_type === 'issue-reported') {
+                const p = record.payload;
+                if (!p.fingerprint || !p.outcome)
+                    continue;
+                txDb
+                    .insert(schema.issue_reports)
+                    .values({
+                    eventId: event_id,
+                    sessionId: record.session_id,
+                    ts: record.ts,
+                    taskRef: p.task_ref ?? eventTask,
+                    errorClass: p.error_class ?? '',
+                    fingerprint: p.fingerprint,
+                    issueUrl: p.issue_url ?? null,
+                    latestEventId: p.latest_event_id ?? '',
+                    outcome: p.outcome,
+                    reason: p.reason ?? null,
+                    repoSlug: p.repo_slug ?? null,
+                    source: p.source ?? '',
+                    project: record.project ?? projectForRef(p.task_ref ?? eventTask),
+                })
+                    .run();
+                continue;
+            }
             if (record.event_type === 'task-result-recorded') {
                 const p = record.payload;
                 // Envelope first, like every other reader — this line used to prefer