@inerrata-corporation/errata 2.0.2-dev.720 → 2.0.2-dev.723

package/errata.mjs

@@ -52305,33 +52305,34 @@ function readFrom(path2, fromByte, maxBytes) {
   try {
     fd = openSync(path2, "r");
   } catch {
-    return { text: "", nextOffset: fromByte, more: false };
+    return { text: "", nextOffset: fromByte, more: false, ioFailed: true };
   }
   try {
     const size = fstatSync(fd).size;
     const start2 = fromByte > 0 && fromByte <= size ? fromByte : 0;
     const remaining = size - start2;
-    if (remaining <= 0) return { text: "", nextOffset: size, more: false };
+    if (remaining <= 0) return { text: "", nextOffset: size, more: false, ioFailed: false };
     let cap = maxBytes && maxBytes > 0 ? maxBytes : remaining;
     for (; ; ) {
       const len = Math.min(cap, remaining);
       const buf = Buffer.allocUnsafe(len);
       readSync(fd, buf, 0, len, start2);
       if (len >= remaining) {
-        return { text: buf.toString("utf8"), nextOffset: size, more: false };
+        return { text: buf.toString("utf8"), nextOffset: size, more: false, ioFailed: false };
       }
       const nl = buf.lastIndexOf(10);
       if (nl >= 0) {
         return {
           text: buf.subarray(0, nl + 1).toString("utf8"),
           nextOffset: start2 + nl + 1,
-          more: true
+          more: true,
+          ioFailed: false
         };
       }
       cap *= 2;
     }
   } catch {
-    return { text: "", nextOffset: fromByte, more: false };
+    return { text: "", nextOffset: fromByte, more: false, ioFailed: true };
   } finally {
     closeSync(fd);
   }
@@ -52349,22 +52350,25 @@ function transcriptSize(path2) {
   }
 }
 function readTail(path2, maxBytes) {
+  return readTailWithLosses(path2, maxBytes).text;
+}
+function readTailWithLosses(path2, maxBytes) {
   let fd;
   try {
     fd = openSync(path2, "r");
   } catch {
-    return "";
+    return { text: "", bytesUnreachable: 0, ioFailed: true };
   }
   try {
     const size = fstatSync(fd).size;
     const start2 = Math.max(0, size - maxBytes);
     const len = size - start2;
-    if (len <= 0) return "";
+    if (len <= 0) return { text: "", bytesUnreachable: 0, ioFailed: false };
     const buf = Buffer.allocUnsafe(len);
     readSync(fd, buf, 0, len, start2);
-    return buf.toString("utf8");
+    return { text: buf.toString("utf8"), bytesUnreachable: start2, ioFailed: false };
   } catch {
-    return "";
+    return { text: "", bytesUnreachable: 0, ioFailed: true };
   } finally {
     closeSync(fd);
   }
@@ -52424,15 +52428,30 @@ function isUserTurnBoundary(obj) {
   if (blocks.some((b) => b["type"] === "tool_result")) return false;
   return blocks.some((b) => b["type"] === "text");
 }
-function readAssistantTurns(transcriptPath, includeThinking = true, maxBytes = 2e6) {
-  return parseAssistantTurns(readTail(transcriptPath, maxBytes), includeThinking);
+function readAssistantTurnsWithLosses(transcriptPath, includeThinking = true, maxBytes = 2e6) {
+  const tail = readTailWithLosses(transcriptPath, maxBytes);
+  const parsed = parseAssistantTurns(tail.text, includeThinking, false);
+  return {
+    turns: parsed.turns,
+    losses: {
+      parseFailures: parsed.parseFailures,
+      ioFailed: tail.ioFailed,
+      bytesUnreachable: tail.bytesUnreachable
+    }
+  };
 }
 function readAssistantTurnsFrom(transcriptPath, fromByte, includeThinking = true, maxBytes) {
-  const { text, nextOffset, more } = readFrom(transcriptPath, fromByte, maxBytes);
-  return { turns: parseAssistantTurns(text, includeThinking), nextOffset, more };
+  const { text, nextOffset, more, ioFailed } = readFrom(transcriptPath, fromByte, maxBytes);
+  const parsed = parseAssistantTurns(text, includeThinking, fromByte > 0);
+  return {
+    turns: parsed.turns,
+    nextOffset,
+    more,
+    losses: { parseFailures: parsed.parseFailures, ioFailed, bytesUnreachable: 0 }
+  };
 }
-function parseAssistantTurns(raw2, includeThinking) {
-  if (!raw2) return [];
+function parseAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure = false) {
+  if (!raw2) return { turns: [], parseFailures: 0 };
   const turns = [];
   const lines = raw2.split(/\r?\n/);
   let lastFile;
@@ -52441,6 +52460,7 @@ function parseAssistantTurns(raw2, includeThinking) {
   let editedFile;
   let editedFileTurnSeq = 0;
   let turnSeq = 0;
+  let parseFailures = 0;
   for (let i2 = 0; i2 < lines.length; i2++) {
     const line = lines[i2];
     if (!line) continue;
@@ -52448,6 +52468,7 @@ function parseAssistantTurns(raw2, includeThinking) {
     try {
       obj = JSON.parse(line);
     } catch {
+      if (!(i2 === 0 && skipFirstLineParseFailure)) parseFailures++;
       continue;
     }
     if (isUserTurnBoundary(obj)) {
@@ -52489,7 +52510,7 @@ function parseAssistantTurns(raw2, includeThinking) {
       ...commands.length > 0 ? { commands } : {}
     });
   }
-  return turns;
+  return { turns, parseFailures };
 }
 function turnsSince(turns, mark) {
   if (!mark) return turns;
@@ -52574,6 +52595,7 @@ var BUILDS_ON_PREFIX = /^\s*builds-on:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var SUPERSEDES_PREFIX = /^\s*supersedes:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var ALTERNATIVE_PREFIX = /^\s*alternative:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var INSTANCE_PREFIX = /^\s*instance:\s*/i;
+var BRACKETED_TOKEN_RE = /\[[^\]\n]{1,120}\]/;
 var CONFIRM_PREFIX = /^\s*confirm:\s*/i;
 var REFUTE_PREFIX = /^\s*refute:\s*/i;
 var REFUTE_REASON_MIN = 4;
@@ -52611,18 +52633,44 @@ function deriveFixRationale(sentence, startIdx, endIdx) {
   if (before.length >= FIX_RATIONALE_MIN) return before;
   return fixRationaleAfter(sentence, endIdx);
 }
+function emptyTagDispositions() {
+  return {
+    oversizeSegments: 0,
+    codeSpanNeutralized: 0,
+    refuteTooShort: 0,
+    causeTooShort: 0,
+    negated: 0,
+    unparseable: 0
+  };
+}
+function addTagDispositions(a, b) {
+  a.oversizeSegments += b.oversizeSegments;
+  a.codeSpanNeutralized += b.codeSpanNeutralized;
+  a.refuteTooShort += b.refuteTooShort;
+  a.causeTooShort += b.causeTooShort;
+  a.negated += b.negated;
+  a.unparseable += b.unparseable;
+}
 function parseInlineTags(text) {
+  return parseInlineTagsWithDispositions(text).tags;
+}
+function parseInlineTagsWithDispositions(text) {
   const out2 = [];
+  const dispositions = emptyTagDispositions();
   const deFenced = text.replace(/```[\s\S]*?```/g, " ");
   let seqNo = -1;
   for (const raw2 of deFenced.split(/(?<=[.!?])\s+|\n+/)) {
     seqNo++;
-    if (raw2.length > 2e4) continue;
+    if (raw2.length > 2e4) {
+      dispositions.oversizeSegments++;
+      continue;
+    }
     const seqStart = out2.length;
-    const sentence = raw2.replace(
-      /`[^`]*`/g,
-      (m) => /\[[!?]|\((?:fix|cause|constraint|tried|failed|confirm|refute):|\(\[/.test(m) ? " " : m
-    );
+    const sentence = raw2.replace(/`[^`]*`/g, (m) => {
+      if (!/\[[!?]|\((?:fix|cause|constraint|tried|failed|confirm|refute):|\(\[/.test(m)) return m;
+      dispositions.codeSpanNeutralized++;
+      return " ";
+    });
     const sfield = sentence.replace(/\s+/g, " ").trim().slice(0, 160);
     const citeMatched = /* @__PURE__ */ new Set();
     CITE_GROUP_RE.lastIndex = 0;
@@ -52672,6 +52720,7 @@ function parseInlineTags(text) {
           if (refuteM) {
             const reason = body2.replace(new RegExp(HANDLE_RE.source, "gi"), " ").replace(/\s+/g, " ").trim();
             if (reason.length >= REFUTE_REASON_MIN) out2.push({ kind: "refute", handle: handle2, statement: reason, sentence: sfield });
+            else dispositions.refuteTooShort++;
           } else {
             out2.push({ kind: "confirm", handle: handle2, sentence: sfield });
           }
@@ -52692,11 +52741,14 @@ function parseInlineTags(text) {
           if (raw3.length >= CAUSE_TEXT_MIN) {
             const causeText = raw3;
             out2.push({ kind: "triage", causeText, sentence: sfield, ...verbThread ? { threadId: verbThread } : {} });
-          }
+          } else dispositions.causeTooShort++;
         }
         continue;
       }
-      if (!isFix && NEG.test(clauseBefore(sentence, g.index))) continue;
+      if (!isFix && NEG.test(clauseBefore(sentence, g.index))) {
+        dispositions.negated++;
+        continue;
+      }
       let fixRationale;
       if (isFix) {
         const r = deriveFixRationale(sentence, g.index, g.index + g[0].length);
@@ -52722,6 +52774,9 @@ function parseInlineTags(text) {
         const note = content.replace(/\s+/g, " ").trim();
         if (note.length >= FIX_RATIONALE_MIN)
           out2.push({ kind: "fix", fixRationale: note, sentence: sfield, ...verbThread ? { threadId: verbThread } : {} });
+        else dispositions.unparseable++;
+      } else if (!isFix && !emittedHandle && BRACKETED_TOKEN_RE.test(content)) {
+        dispositions.unparseable++;
       }
     }
     for (const pass of [
@@ -52889,7 +52944,7 @@ function parseInlineTags(text) {
     }
     for (let i2 = seqStart; i2 < out2.length; i2++) out2[i2].seq = seqNo;
   }
-  return out2;
+  return { tags: out2, dispositions };
 }
 var LABEL_PAIR = {
   "Problem>RootCause": "CAUSED_BY",
@@ -53045,8 +53100,10 @@ function harvestInlineTags(store, text, opts) {
   const source = opts.sourceId ? store.getNode(opts.sourceId) : null;
   const mintPriors = opts.mintPriors ?? true;
   const touched = opts.sessionTouchedIds ?? /* @__PURE__ */ new Set();
-  const plan = { priorEdges: 0, corroboratedEdges: 0, exposureShown: 0, exposureEvicted: 0, exposureUnshown: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
-  const tags = parseInlineTags(text);
+  const plan = { priorEdges: 0, corroboratedEdges: 0, exposureShown: 0, exposureEvicted: 0, exposureUnshown: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], unresolvedHandles: [], priorEdgesSuppressed: { flagOff: 0, noSource: 0 }, dispositions: emptyTagDispositions(), transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
+  const parsed = parseInlineTagsWithDispositions(text);
+  const tags = parsed.tags;
+  plan.dispositions = parsed.dispositions;
   const symptomSeqs = tags.filter((t) => (t.kind === "problem" || t.kind === "todo") && t.statement).map((t) => ({ seq: t.seq ?? -1, statement: t.statement, threadId: t.threadId })).sort((a, b) => a.seq - b.seq);
   const bindSymptom = (seq, threadId) => {
     if (threadId) {
@@ -53068,6 +53125,11 @@ function harvestInlineTags(store, text, opts) {
     if (symptomSeqs.length === 1) return { statement: best.statement, evidence: "witnessed" };
     return { statement: best.statement, evidence: "inferred" };
   };
+  const resolveCited = (kind, handle2) => {
+    const id = resolveHandle(store, handle2, opts.handleMap) ?? null;
+    if (!id) plan.unresolvedHandles.push({ kind, handle: handle2 });
+    return id;
+  };
   for (const tag of tags) {
     if (tag.kind === "problem" || tag.kind === "todo") {
       plan.problems.push({
@@ -53109,7 +53171,7 @@ function harvestInlineTags(store, text, opts) {
         evidence: b.evidence
       };
       if (tag.handle) {
-        const causeId = resolveHandle(store, tag.handle, opts.handleMap);
+        const causeId = resolveCited("triage", tag.handle);
         const node2 = causeId ? store.getNode(causeId) : null;
         if (node2) plan.triages.push({ causeId: node2.id, causeDescription: node2.description, ...bound });
       } else if (tag.causeText) {
@@ -53128,7 +53190,7 @@ function harvestInlineTags(store, text, opts) {
     } else if (tag.kind === "transfer") {
       const targetIds = [];
       for (const h of tag.handles ?? []) {
-        const id = resolveHandle(store, h, opts.handleMap);
+        const id = resolveCited("transfer", h);
         if (id && !targetIds.includes(id)) targetIds.push(id);
       }
       if (targetIds.length > 0) {
@@ -53142,7 +53204,7 @@ function harvestInlineTags(store, text, opts) {
     } else if (tag.kind === "builds-on" || tag.kind === "supersedes" || tag.kind === "alternative") {
       const targetIds = [];
       for (const h of tag.handles ?? []) {
-        const id = resolveHandle(store, h, opts.handleMap);
+        const id = resolveCited(tag.kind, h);
         if (id && !targetIds.includes(id)) targetIds.push(id);
       }
       if (targetIds.length > 0) {
@@ -53158,7 +53220,7 @@ function harvestInlineTags(store, text, opts) {
     } else if (tag.kind === "instance") {
       const targetIds = [];
       for (const h of tag.handles ?? []) {
-        const id = resolveHandle(store, h, opts.handleMap);
+        const id = resolveCited("instance", h);
         if (id && !targetIds.includes(id)) targetIds.push(id);
       }
       if (targetIds.length > 0) {
@@ -53180,7 +53242,7 @@ function harvestInlineTags(store, text, opts) {
         evidence: b.evidence
       };
       if (tag.handle) {
-        const patternId = resolveHandle(store, tag.handle, opts.handleMap);
+        const patternId = resolveCited("pattern", tag.handle);
         if (patternId) plan.patterns.push({ patternId, ...bound });
       } else if (tag.patternText) {
         plan.patterns.push({ patternText: tag.patternText, ...bound });
@@ -53206,7 +53268,7 @@ function harvestInlineTags(store, text, opts) {
       else plan.components.push({ componentText: tag.componentText, ...bound });
     } else if (tag.kind === "attempt" || tag.kind === "failure") {
       for (const h of tag.refuteHandles ?? []) {
-        const nodeId = resolveHandle(store, h, opts.handleMap);
+        const nodeId = resolveCited("refute", h);
         if (nodeId) {
           const witnessKey = `refute:${nodeId}:${digest({ s: tag.statement ?? "" })}`.slice(0, 72);
           if (!plan.refutes.some((r) => r.witnessKey === witnessKey)) {
@@ -53229,7 +53291,7 @@ function harvestInlineTags(store, text, opts) {
         });
       }
     } else if (tag.kind === "confirm" || tag.kind === "refute") {
-      const targetId = resolveHandle(store, tag.handle, opts.handleMap);
+      const targetId = resolveCited(tag.kind, tag.handle);
       const target = targetId ? store.getNode(targetId) : null;
       const citedLabel = target?.label ?? opts.handleMap[tag.handle]?.label;
       if (targetId && citedLabel && CORROBORATABLE_LABELS.has(citedLabel)) {
@@ -53250,7 +53312,7 @@ function harvestInlineTags(store, text, opts) {
         }
       }
     } else if (tag.kind === "prior") {
-      const targetId = resolveHandle(store, tag.handle, opts.handleMap);
+      const targetId = resolveCited("prior", tag.handle);
       const target = targetId ? store.getNode(targetId) : null;
       const citedLabel = target?.label ?? opts.handleMap[tag.handle]?.label;
       if (targetId && citedLabel && CORROBORATABLE_LABELS.has(citedLabel)) {
@@ -53269,9 +53331,12 @@ function harvestInlineTags(store, text, opts) {
           plan.priorEdges++;
           if (m.corroborated) plan.corroboratedEdges++;
         }
+      } else if (target) {
+        if (!mintPriors) plan.priorEdgesSuppressed.flagOff++;
+        else if (!source) plan.priorEdgesSuppressed.noSource++;
       }
     } else if (mintPriors && source) {
-      const targetId = resolveHandle(store, tag.handle, opts.handleMap);
+      const targetId = resolveCited(tag.kind, tag.handle);
       const target = targetId ? store.getNode(targetId) : null;
       if (target) {
         const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
@@ -53280,6 +53345,9 @@ function harvestInlineTags(store, text, opts) {
           if (m.corroborated) plan.corroboratedEdges++;
         }
       }
+    } else if (tag.handle) {
+      if (!mintPriors) plan.priorEdgesSuppressed.flagOff++;
+      else if (!source) plan.priorEdgesSuppressed.noSource++;
     }
   }
   return plan;
@@ -55256,16 +55324,19 @@ var WITNESS_MAX_ATTEMPTS = 5;
 function witnessQueuePath(workspaceConfigDir) {
   return join25(workspaceConfigDir, "witness-queue.json");
 }
-function loadWitnessQueue(path2) {
+function loadWitnessQueueWithLosses(path2) {
+  let raw2;
   try {
-    const raw2 = JSON.parse(readFileSync20(path2, "utf8"));
-    if (!Array.isArray(raw2)) return [];
-    return raw2.filter(
-      (w) => !!w && typeof w === "object" && typeof w.nodeId === "string" && typeof w.witnessKey === "string"
-    );
-  } catch {
-    return [];
+    raw2 = JSON.parse(readFileSync20(path2, "utf8"));
+  } catch (err2) {
+    const absent = err2?.code === "ENOENT";
+    return { queue: [], fileUnreadable: !absent, malformedEntries: 0 };
   }
+  if (!Array.isArray(raw2)) return { queue: [], fileUnreadable: true, malformedEntries: 0 };
+  const queue = raw2.filter(
+    (w) => !!w && typeof w === "object" && typeof w.nodeId === "string" && typeof w.witnessKey === "string"
+  );
+  return { queue, fileUnreadable: false, malformedEntries: raw2.length - queue.length };
 }
 function saveWitnessQueue(path2, queue) {
   try {
@@ -55276,10 +55347,21 @@ function saveWitnessQueue(path2, queue) {
   }
 }
 function pruneWitnessQueue(queue, now) {
-  const live2 = queue.filter(
-    (w) => now - w.ts < WITNESS_TTL_MS && w.attempts < WITNESS_MAX_ATTEMPTS
-  );
-  return live2.length > WITNESS_QUEUE_CAP ? live2.slice(live2.length - WITNESS_QUEUE_CAP) : live2;
+  return pruneWitnessQueueWithDispositions(queue, now).queue;
+}
+function pruneWitnessQueueWithDispositions(queue, now) {
+  const dropped = { expiredTtl: 0, exhaustedAttempts: 0, cappedOverflow: 0 };
+  const live2 = [];
+  for (const w of queue) {
+    if (now - w.ts >= WITNESS_TTL_MS) dropped.expiredTtl++;
+    else if (w.attempts >= WITNESS_MAX_ATTEMPTS) dropped.exhaustedAttempts++;
+    else live2.push(w);
+  }
+  if (live2.length > WITNESS_QUEUE_CAP) {
+    dropped.cappedOverflow = live2.length - WITNESS_QUEUE_CAP;
+    return { queue: live2.slice(live2.length - WITNESS_QUEUE_CAP), dropped };
+  }
+  return { queue: live2, dropped };
 }
 function enqueueWitnesses(queue, fresh, now) {
   const byKey = new Map(queue.map((w) => [`${w.channel}:${w.witnessKey}`, w]));
@@ -55611,7 +55693,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.720" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.723" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -55718,10 +55800,19 @@ function createWorkspaceEngine(opts) {
     refreshRepoLocator(opts.workspaceRoot, profile);
   }
   const store = openGraphStore({ path: paths.castalia });
-  let witnessQueue = pruneWitnessQueue(
-    loadWitnessQueue(witnessQueuePath(paths.configDir)),
-    Date.now()
-  );
+  const witnessLoad = loadWitnessQueueWithLosses(witnessQueuePath(paths.configDir));
+  const witnessPrune = pruneWitnessQueueWithDispositions(witnessLoad.queue, Date.now());
+  let witnessQueue = witnessPrune.queue;
+  if (witnessLoad.fileUnreadable || witnessLoad.malformedEntries > 0 || witnessPrune.dropped.expiredTtl > 0 || witnessPrune.dropped.exhaustedAttempts > 0 || witnessPrune.dropped.cappedOverflow > 0) {
+    appendPassLedger(paths.configDir, "witness-queue", 0, {
+      loaded: witnessQueue.length,
+      fileUnreadable: witnessLoad.fileUnreadable ? 1 : 0,
+      malformedEntries: witnessLoad.malformedEntries,
+      prunedExpiredTtl: witnessPrune.dropped.expiredTtl,
+      prunedExhaustedAttempts: witnessPrune.dropped.exhaustedAttempts,
+      prunedCappedOverflow: witnessPrune.dropped.cappedOverflow
+    });
+  }
   const log = openEventLog({ path: paths.eventLog });
   const bundled = import.meta.url.endsWith(".mjs");
   const passWorker = bundled && paths.castalia !== ":memory:" ? new PassWorker({
@@ -56352,6 +56443,7 @@ function createWorkspaceEngine(opts) {
   const turnCursorPath = join27(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
+  const readLosses = { parseFailures: 0, ioFailures: 0, bytesUnreachable: 0, sliceGuardHits: 0 };
   const sessionLastProblem = /* @__PURE__ */ new Map();
   const sessionThreads = /* @__PURE__ */ new Map();
   const harvestTexts = async (sessionId, items) => {
@@ -56373,6 +56465,10 @@ function createWorkspaceEngine(opts) {
     let exposureEvicted = 0;
     let exposureUnshown = 0;
     let corroboratedEdges = 0;
+    const dispositions = emptyTagDispositions();
+    let unresolvedHandles = 0;
+    let priorEdgesFlagOff = 0;
+    let priorEdgesNoSource = 0;
     let touchedFileTurns = 0;
     let touchedToolTurns = 0;
     let anchorHintsUpgraded = 0;
@@ -56506,6 +56602,10 @@ function createWorkspaceEngine(opts) {
         });
         priorEdges += plan.priorEdges;
         corroboratedEdges += plan.corroboratedEdges;
+        addTagDispositions(dispositions, plan.dispositions);
+        unresolvedHandles += plan.unresolvedHandles.length;
+        priorEdgesFlagOff += plan.priorEdgesSuppressed.flagOff;
+        priorEdgesNoSource += plan.priorEdgesSuppressed.noSource;
         exposureShown += plan.exposureShown;
         exposureEvicted += plan.exposureEvicted;
         exposureUnshown += plan.exposureUnshown;
@@ -56941,8 +57041,32 @@ function createWorkspaceEngine(opts) {
         // touchedToolTurns 0 with this >0 = the hook and harvest disagree on
         // the session key; 0 with 0 = records never happen.
         toolSessionsTracked: toolRuns.sessions(),
-        seqAdvanced: store.currentIngestSeq() - seqAtStart
+        seqAdvanced: store.currentIngestSeq() - seqAtStart,
+        // TEL T1.1/T1.2/T1.3 — the capture path's drops. `tagsCodeSpan` and
+        // `tagsUnparseable` rising means the vocabulary and the writer disagree
+        // (our bug); `tagsRefuteTooShort` means a demotion verdict was lost;
+        // `unresolvedHandles` means an agent cited a prior we could no longer
+        // name. Every one of these used to be a silent `continue`.
+        tagsOversize: dispositions.oversizeSegments,
+        tagsCodeSpan: dispositions.codeSpanNeutralized,
+        tagsRefuteTooShort: dispositions.refuteTooShort,
+        tagsCauseTooShort: dispositions.causeTooShort,
+        tagsNegated: dispositions.negated,
+        tagsUnparseable: dispositions.unparseable,
+        unresolvedHandles,
+        priorEdgesFlagOff,
+        priorEdgesNoSource,
+        // TEL T1.7/T1.8 — transcript-read losses. `harvestBytesUnreachable` is
+        // the only counter here measuring knowledge that can never be recovered.
+        harvestParseFailures: readLosses.parseFailures,
+        harvestIoFailures: readLosses.ioFailures,
+        harvestBytesUnreachable: readLosses.bytesUnreachable,
+        harvestSliceGuardHits: readLosses.sliceGuardHits
       });
+      readLosses.parseFailures = 0;
+      readLosses.ioFailures = 0;
+      readLosses.bytesUnreachable = 0;
+      readLosses.sliceGuardHits = 0;
     }
   };
   const harvestTurns = async (sessionId, transcriptPath) => {
@@ -56951,12 +57075,20 @@ function createWorkspaceEngine(opts) {
     let nextOffset;
     try {
       if (known === void 0) {
-        turns = readAssistantTurns(transcriptPath);
+        const first = readAssistantTurnsWithLosses(transcriptPath);
+        turns = first.turns;
         nextOffset = transcriptSize(transcriptPath);
+        readLosses.bytesUnreachable += first.losses.bytesUnreachable;
+        readLosses.parseFailures += first.losses.parseFailures;
+        if (first.losses.ioFailed) readLosses.ioFailures++;
       } else {
-        ({ turns, nextOffset } = readAssistantTurnsFrom(transcriptPath, known, true, HARVEST_SLICE_BYTES));
+        const slice = readAssistantTurnsFrom(transcriptPath, known, true, HARVEST_SLICE_BYTES);
+        ({ turns, nextOffset } = slice);
+        readLosses.parseFailures += slice.losses.parseFailures;
+        if (slice.losses.ioFailed) readLosses.ioFailures++;
       }
     } catch {
+      readLosses.ioFailures++;
       return;
     }
     for (let slice = 0; ; slice++) {
@@ -56968,6 +57100,7 @@ function createWorkspaceEngine(opts) {
       }
       saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
       if (slice >= 256) {
+        readLosses.sliceGuardHits++;
         console.warn("[errata] harvest slice guard hit \u2014 backlog resumes next tick");
         break;
       }
@@ -56975,8 +57108,11 @@ function createWorkspaceEngine(opts) {
       try {
         next = readAssistantTurnsFrom(transcriptPath, nextOffset, true, HARVEST_SLICE_BYTES);
       } catch {
+        readLosses.ioFailures++;
         break;
       }
+      readLosses.parseFailures += next.losses.parseFailures;
+      if (next.losses.ioFailed) readLosses.ioFailures++;
       if (next.turns.length === 0 && !next.more) {
         turnOffset.set(sessionId, next.nextOffset);
         saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.2-dev.720",
+  "version": "2.0.2-dev.723",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {