@inerrata-corporation/errata 2.0.2-dev.545 → 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;
@@ -21850,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);
@@ -21877,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";
@@ -21888,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,
@@ -22004,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",
@@ -51964,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) => {
@@ -52163,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;
@@ -54328,7 +54374,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.545" : "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;
@@ -55001,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;
@@ -55120,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();
@@ -55529,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.545",
+  "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;