@inerrata-corporation/errata 2.0.2-dev.540 → 2.0.2-dev.548

package/consolidate-worker.mjs

@@ -16580,6 +16580,16 @@ var SqliteGraphStore = class {
     if (revived > 0) this.mutations++;
     return revived;
   }
+  recentEdgeAttrCoverage(marker, attr, limit) {
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS total,
+                COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
+           FROM (SELECT attrs_json FROM edges
+                  WHERE valid_to IS NULL AND attrs_json LIKE ?
+                  ORDER BY created_at DESC LIMIT ?)`
+    ).get(attr, `%${marker}%`, limit);
+    return { count: Number(r.count), total: Number(r.total) };
+  }
   liveNodeIds(ids) {
     const live = /* @__PURE__ */ new Set();
     const CHUNK = 900;

package/errata.mjs

@@ -17255,6 +17255,16 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         if (revived > 0) this.mutations++;
         return revived;
       }
+      recentEdgeAttrCoverage(marker, attr, limit) {
+        const r = this.db.prepare(
+          `SELECT COUNT(*) AS total,
+                COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
+           FROM (SELECT attrs_json FROM edges
+                  WHERE valid_to IS NULL AND attrs_json LIKE ?
+                  ORDER BY created_at DESC LIMIT ?)`
+        ).get(attr, `%${marker}%`, limit);
+        return { count: Number(r.count), total: Number(r.total) };
+      }
       liveNodeIds(ids) {
         const live = /* @__PURE__ */ new Set();
         const CHUNK = 900;
@@ -19287,16 +19297,24 @@ function closeDesignProblem(store, problemId, fixNote, t) {
   const p = store.getNode(problemId);
   if (!p || p.label !== "Problem") return false;
   if (p.attrs["resolvedAs"]) return false;
-  if (fixNote?.trim() && store.outEdges(problemId, ["SOLVED_BY"]).length === 0) {
-    const solId = `dfix_${digest({ problemId, fix: fixNote })}`.slice(0, 56);
-    store.mergeNode(
-      buildNode(store, solId, "Solution", fixNote.trim(), t, { source: "convo", provisional: false })
-    );
-    mergeEdge(store, problemId, solId, "SOLVED_BY", t);
+  if (fixNote?.trim()) {
+    const sols = store.outEdges(problemId, ["SOLVED_BY"]).map((e) => store.getNode(e.to)).filter((n) => n !== null);
+    if (sols.every((s) => isAutoMinted(s))) {
+      const solId = `dfix_${digest({ problemId, fix: fixNote })}`.slice(0, 56);
+      store.mergeNode(
+        buildNode(store, solId, "Solution", fixNote.trim(), t, { source: "convo", provisional: false })
+      );
+      mergeEdge(store, problemId, solId, "SOLVED_BY", t);
+    }
   }
   if (p.attrs["resolvedAt"]) return false;
   store.updateNode(problemId, {
-    attrs: { ...p.attrs, provisional: false, resolvedAt: t },
+    // `resolutionWitnessed` records WHO closed it — an agent's explicit fix tag
+    // — so the reopen sweep can tell this close from the heuristic auto-closes
+    // it polices. The solution SET is the wrong proxy: a bare `(fix:[handle])`
+    // mints no Solution, and a legacy placeholder beside it reads as
+    // all-heuristic either way.
+    attrs: { ...p.attrs, provisional: false, resolvedAt: t, resolutionWitnessed: true },
     lastUpdatedAt: t
   });
   return true;
@@ -19307,6 +19325,10 @@ function reopenAutoClosedProblems(store, t) {
     if (p.attrs["resolvedAt"] == null) continue;
     if (p.attrs["resolvedAs"] != null) continue;
     if (p.attrs["mergedInto"] !== void 0) continue;
+    if (p.attrs["resolutionWitnessed"] === true) {
+      report.agentDescribed++;
+      continue;
+    }
     const sols = store.outEdges(p.id, ["SOLVED_BY"]).map((e) => store.getNode(e.to)).filter((n) => n !== null);
     if (sols.length === 0) continue;
     if (!sols.every((s) => String(s.description ?? "").startsWith(AUTO_MINT_PREFIX))) {
@@ -21838,14 +21860,24 @@ var init_principle_sync = __esm({
 
 // ../../packages/local-graph/src/mechanism-liveness.ts
 function evaluateFed(store, d) {
+  if (d.fedEdges) {
+    const { count: count2, total } = store.recentEdgeAttrCoverage(
+      d.fedEdges.marker,
+      d.fedEdges.attr,
+      d.fedEdges.recent
+    );
+    return { count: count2, total, fraction: total === 0 ? 0 : count2 / total };
+  }
+  if (!d.fed) return { count: 0, total: 0, fraction: 0 };
   const column = COLUMN_INPUTS[d.fed.attr];
-  const has = (n) => column ? column(n) : n.attrs[d.fed.attr] !== void 0;
-  const nodes = d.fed.labels.flatMap((label) => store.findNodesByLabel(label));
+  const fed = d.fed;
+  const has = (n) => column ? column(n) : n.attrs[fed.attr] !== void 0;
+  const nodes = fed.labels.flatMap((label) => store.findNodesByLabel(label));
   let window2 = nodes;
-  if (d.fed.recent !== void 0) {
-    window2 = [...nodes].sort((a, b) => b.createdAt - a.createdAt).slice(0, d.fed.recent);
+  if (fed.recent !== void 0) {
+    window2 = [...nodes].sort((a, b) => b.createdAt - a.createdAt).slice(0, fed.recent);
   }
-  if (d.fed.sinceFirstStamp) {
+  if (fed.sinceFirstStamp) {
     let anchor = Infinity;
     for (const n of window2) if (has(n) && n.createdAt < anchor) anchor = n.createdAt;
     window2 = anchor === Infinity ? [] : window2.filter((n) => n.createdAt >= anchor);
@@ -21865,7 +21897,7 @@ function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mech
     const stalled = backlog !== void 0 && backlog > 0 && effectCount === 0 && (inv?.runs ?? 0) >= STALL_MIN_RUNS && span >= STALL_MIN_SPAN_MS && (backlogWas === void 0 || backlog >= backlogWas);
     let verdict;
     if (!inv || inv.runs === 0) verdict = "never-invoked";
-    else if (fed.fraction < d.fed.minFraction) verdict = "starved";
+    else if (fed.fraction < (d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0)) verdict = "starved";
     else if (stalled) verdict = "stalled";
     else if (effectCount === 0) verdict = "no-effect";
     else verdict = "ok";
@@ -21876,7 +21908,7 @@ function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mech
       fedCount: fed.count,
       fedTotal: fed.total,
       fedFraction: fed.fraction,
-      minFraction: d.fed.minFraction,
+      minFraction: d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0,
       ...inv ? { lastInvokedMs: inv.lastTs } : {},
       runs: inv?.runs ?? 0,
       effectCount,
@@ -21992,6 +22024,20 @@ var init_mechanism_liveness = __esm({
         fed: { labels: ["File"], attr: "relPath", minFraction: 0.9 },
         effectCounter: "reaped"
       },
+      {
+        id: "prior-corroboration",
+        what: "grounds a cited prior by overlap with what the session actually touched",
+        // CAPTURE mints the edges and stamps the verdict; the fed metric is the
+        // corroborated fraction of the newest priorTag edges. Measured 2026-08-08:
+        // 1 of 139 recent despite 84 having a live grounding path — reading STARVED
+        // is the honest state until the touched-set plumbing is fixed
+        // (VS-corroboration-rate); an alarm on a genuinely broken channel is what
+        // alarms are for.
+        pass: "capture",
+        fedEdges: { marker: '"priorTag":true', attr: "corroborated", minFraction: 0.02, recent: 100 },
+        effectCounter: "corroboratedEdges",
+        note: "expected STARVED until VS-corroboration-rate lands \u2014 the channel is genuinely starved"
+      },
       {
         id: "liveness-watch",
         what: "the daemon-side schedule of this very verdict \u2014 alarms when a mechanism stops working",
@@ -51952,13 +51998,13 @@ function mintPriorEdge(store, source, target, sentence, touched, ts) {
     } catch {
     }
   }
-  return true;
+  return { corroborated };
 }
 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, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
+  const plan = { priorEdges: 0, corroboratedEdges: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
   const tags = parseInlineTags(text);
   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) => {
@@ -52151,11 +52197,23 @@ function harvestInlineTags(store, text, opts) {
           plan.corroborations.push({ nodeId: targetId, witnessKey });
         }
       }
-      if (mintPriors && source && target && mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts)) plan.priorEdges++;
+      if (mintPriors && source && target) {
+        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
+        if (m) {
+          plan.priorEdges++;
+          if (m.corroborated) plan.corroboratedEdges++;
+        }
+      }
     } else if (mintPriors && source) {
       const targetId = resolveHandle(store, tag.handle, opts.handleMap);
       const target = targetId ? store.getNode(targetId) : null;
-      if (target && mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts)) plan.priorEdges++;
+      if (target) {
+        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
+        if (m) {
+          plan.priorEdges++;
+          if (m.corroborated) plan.corroboratedEdges++;
+        }
+      }
     }
   }
   return plan;
@@ -54316,7 +54374,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.540" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.548" : "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;
@@ -54989,6 +55047,9 @@ function createWorkspaceEngine(opts) {
     let abstracted = 0;
     let triaged = 0;
     let priorEdges = 0;
+    let corroboratedEdges = 0;
+    let touchedFileTurns = 0;
+    let touchedToolTurns = 0;
     let linked = 0;
     const t = Date.now();
     let processedTurns = 0;
@@ -55108,6 +55169,9 @@ function createWorkspaceEngine(opts) {
           ...touched.size > 0 ? { sessionTouchedIds: touched } : {}
         });
         priorEdges += plan.priorEdges;
+        corroboratedEdges += plan.corroboratedEdges;
+        if (touchedFileId) touchedFileTurns++;
+        if ((toolRuns.get(sessionId)?.size ?? 0) > 0) touchedToolTurns++;
         const wf = workingFiles.get(sessionId);
         let inScopeProblemId;
         const threads = sessionThreads.get(sessionId) ?? /* @__PURE__ */ new Map();
@@ -55172,7 +55236,16 @@ function createWorkspaceEngine(opts) {
             }
             continue;
           }
-          if (resolveDesignProblemById(store, pid, fx.fixNote, t)) {
+          const closed = resolveDesignProblemById(store, pid, fx.fixNote, t);
+          if (!closed) {
+            const n = store.getNode(pid);
+            if (!n || n.label !== "Problem" || n.attrs["resolvedAs"] != null) {
+              console.warn(
+                `[errata] fix tag went nowhere: ${!n ? `id ${pid.slice(0, 32)} unknown` : n.label !== "Problem" ? `${pid.slice(0, 32)} is a ${n.label}, not a Problem` : "the problem was retracted \u2014 a retraction is not fixable"} \u2014 the fix was NOT recorded`
+              );
+            }
+          }
+          if (closed) {
             resolved++;
             const fxAnchor = editedTurnFile ?? turnFile ?? wf;
             if (fxAnchor) {
@@ -55508,6 +55581,9 @@ function createWorkspaceEngine(opts) {
         resolved,
         triaged,
         priorEdges,
+        corroboratedEdges,
+        touchedFileTurns,
+        touchedToolTurns,
         seqAdvanced: store.currentIngestSeq() - seqAtStart
       });
     }

package/package.json

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

package/pass-worker.mjs

@@ -24921,6 +24921,16 @@ var SqliteGraphStore = class {
     if (revived > 0) this.mutations++;
     return revived;
   }
+  recentEdgeAttrCoverage(marker, attr, limit) {
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS total,
+                COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
+           FROM (SELECT attrs_json FROM edges
+                  WHERE valid_to IS NULL AND attrs_json LIKE ?
+                  ORDER BY created_at DESC LIMIT ?)`
+    ).get(attr, `%${marker}%`, limit);
+    return { count: Number(r.count), total: Number(r.total) };
+  }
   liveNodeIds(ids) {
     const live = /* @__PURE__ */ new Set();
     const CHUNK = 900;
@@ -25627,6 +25637,10 @@ function reopenAutoClosedProblems(store2, t) {
     if (p.attrs["resolvedAt"] == null) continue;
     if (p.attrs["resolvedAs"] != null) continue;
     if (p.attrs["mergedInto"] !== void 0) continue;
+    if (p.attrs["resolutionWitnessed"] === true) {
+      report.agentDescribed++;
+      continue;
+    }
     const sols = store2.outEdges(p.id, ["SOLVED_BY"]).map((e) => store2.getNode(e.to)).filter((n) => n !== null);
     if (sols.length === 0) continue;
     if (!sols.every((s) => String(s.description ?? "").startsWith(AUTO_MINT_PREFIX))) {