@inerrata-corporation/errata 2.0.2-dev.600 → 2.0.2-dev.610

package/errata.mjs

@@ -19598,9 +19598,9 @@ function searchByIntent(store, intent, opts) {
   if (denom === 0) return [];
   const hits = [];
   for (const { node: node2, matched } of candidates) {
-    let num2 = 0;
-    for (const t of matched) num2 += idf(t);
-    const coverage = num2 / denom;
+    let num3 = 0;
+    for (const t of matched) num3 += idf(t);
+    const coverage = num3 / denom;
     if (coverage < minCoverage) continue;
     hits.push({ node: node2, coverage, matched });
   }
@@ -20904,18 +20904,18 @@ function triageOf(l2, q, mathOpts) {
   for (const e of l2.outEdges(triageId, [...ROUTE_EDGE_TYPES])) {
     const perContext = e.attrs["perContext"] ?? {};
     const counts = {};
-    for (const [bucket, num2] of Object.entries(perContext)) {
+    for (const [bucket, num3] of Object.entries(perContext)) {
       counts[bucket] = {
-        seen: seen[bucket] ?? num2.confirmed,
+        seen: seen[bucket] ?? num3.confirmed,
         // denominator ≥ numerator
-        confirmed: num2.confirmed,
+        confirmed: num3.confirmed,
         // Cloud-merged routes carry a distinct-uploader count; local routes count
         // their session contributors.
-        independent: num2.independent ?? num2.contributors?.length ?? 0,
+        independent: num3.independent ?? num3.contributors?.length ?? 0,
         // Discounted-in-trust-ramp subset (T3-weighting): the cloud-authoritative
         // corpus count when present, else the local inferred-only contributor count
         // (ambient-paired diagnoses whose binding the daemon guessed).
-        inferredIndependent: num2.inferredIndependent ?? num2.inferredContributors?.length ?? 0
+        inferredIndependent: num3.inferredIndependent ?? num3.inferredContributors?.length ?? 0
       };
     }
     const post = triagePosterior(counts, buckets, mathOpts);
@@ -22060,6 +22060,37 @@ var init_mechanism_liveness = __esm({
         effectCounter: "corroboratedEdges",
         note: "expected STARVED until VS-corroboration-rate lands \u2014 the channel is genuinely starved"
       },
+      {
+        id: "wm-reinforce-exposure",
+        what: "labels each paraphrase re-derivation with the prior's exposure (shown/evicted/unshown)",
+        // The producer runs inside capture's fold path (reinforceSameAnchorProblem),
+        // but capture cannot count it without threading the fold verdict up through
+        // ingestDesignProblem — so the WM-JOIN reading is the observable: the
+        // wm-calibration pass reads the stamped counters as levels every tick.
+        pass: "wm-calibration",
+        // Conditional stamp, rare by design (a paraphrase fold is a few-per-day
+        // event) — the bar is "the field is written at all", the revisit-sweep
+        // precedent. Zero everywhere = the outcome site never fired, which was
+        // this store's measured state on 2026-08-09, day one of WM-labels.
+        fed: { labels: ["Problem"], attr: "lastReinforceExposure", minFraction: 0 },
+        // A LEVEL, not an increment: nonzero once any node ever carried an outcome.
+        effectCounter: "reinforcedNodes",
+        note: "levels ride the wm-calibration row; expect no-effect until outcome data accrues"
+      },
+      {
+        id: "wm-leaned-exposure",
+        what: "classifies a leaned-cite's exposure at outcome time (the display-confounded cell)",
+        // CAPTURE parses the cite and classifies against the render stamps — the
+        // gate's input is `lastShownAtSeq`, the render ledger's seq stamp.
+        pass: "capture",
+        fed: {
+          labels: ["Problem", "Solution", "RootCause", "Pattern"],
+          attr: "lastShownAtSeq",
+          minFraction: 5e-3
+        },
+        effectCounter: "exposureOutcomes",
+        note: "0 with live render stamps = no lean-cites parsed, not a broken classifier"
+      },
       {
         id: "liveness-watch",
         what: "the daemon-side schedule of this very verdict \u2014 alarms when a mechanism stops working",
@@ -22084,6 +22115,57 @@ var init_mechanism_liveness = __esm({
   }
 });
 
+// ../../packages/local-graph/src/wm-calibration.ts
+function wmCalibrationCells(store) {
+  const cells = {
+    shownNodes: 0,
+    shownImpressions: 0,
+    evictedNodes: 0,
+    evictedImpressions: 0,
+    reinforceShown: 0,
+    reinforceEvicted: 0,
+    reinforceUnshown: 0,
+    reinforcedNodes: 0
+  };
+  for (const label of WM_CALIBRATION_LABELS) {
+    for (const n of store.findNodesByLabel(label)) {
+      const shown = num(n.attrs["shownCount"]);
+      const evicted = num(n.attrs["evictedCount"]);
+      if (shown > 0) {
+        cells.shownNodes++;
+        cells.shownImpressions += shown;
+      }
+      if (evicted > 0) {
+        cells.evictedNodes++;
+        cells.evictedImpressions += evicted;
+      }
+      const rs = num(n.attrs["reinforceShownCount"]);
+      const re = num(n.attrs["reinforceEvictedCount"]);
+      const ru = num(n.attrs["reinforceUnshownCount"]);
+      cells.reinforceShown += rs;
+      cells.reinforceEvicted += re;
+      cells.reinforceUnshown += ru;
+      if (rs + re + ru > 0) cells.reinforcedNodes++;
+    }
+  }
+  return cells;
+}
+var WM_CALIBRATION_LABELS, num;
+var init_wm_calibration = __esm({
+  "../../packages/local-graph/src/wm-calibration.ts"() {
+    "use strict";
+    WM_CALIBRATION_LABELS = [
+      "Problem",
+      "Solution",
+      "RootCause",
+      "Pattern",
+      "Technique",
+      "AntiPattern"
+    ];
+    num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  }
+});
+
 // ../../packages/local-graph/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
@@ -22107,6 +22189,7 @@ __export(src_exports2, {
   STALL_MIN_RUNS: () => STALL_MIN_RUNS,
   STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
   SqliteGraphStore: () => SqliteGraphStore,
+  WM_CALIBRATION_LABELS: () => WM_CALIBRATION_LABELS,
   addDependency: () => addDependency,
   aggregateClaimConfidence: () => aggregateClaimConfidence,
   anchorProblemToDiff: () => anchorProblemToDiff,
@@ -22218,7 +22301,8 @@ __export(src_exports2, {
   toolNodeId: () => toolNodeId,
   toolPriorsFor: () => toolPriorsFor,
   triageOf: () => triageOf,
-  walk: () => walk
+  walk: () => walk,
+  wmCalibrationCells: () => wmCalibrationCells
 });
 var init_src5 = __esm({
   "../../packages/local-graph/src/index.ts"() {
@@ -22243,6 +22327,7 @@ var init_src5 = __esm({
     init_tools();
     init_principle_sync();
     init_mechanism_liveness();
+    init_wm_calibration();
   }
 });
 
@@ -22941,10 +23026,10 @@ function pathsFor(node2) {
   return globs.length > 0 ? globs : ["**/*"];
 }
 function confidenceOf(n) {
-  return num(n.attrs["cloudConfidence"], num(n.attrs["claimConfidence"], n.extractionConfidence));
+  return num2(n.attrs["cloudConfidence"], num2(n.attrs["claimConfidence"], n.extractionConfidence));
 }
 function contributorsOf(n) {
-  return Math.max(num(n.attrs["cloudContributors"], 0), num(n.attrs["contributorCount"], 1));
+  return Math.max(num2(n.attrs["cloudContributors"], 0), num2(n.attrs["contributorCount"], 1));
 }
 function slugFor(n) {
   const kebab = n.description.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -22975,12 +23060,12 @@ _Collective principle \xB7 confidence ${conf.toFixed(2)} \xB7 ${contrib} contrib
     };
   });
 }
-var num, LANG_GLOBS;
+var num2, LANG_GLOBS;
 var init_select_durable_memory = __esm({
   "../../packages/context-writer/src/select-durable-memory.ts"() {
     "use strict";
     init_src2();
-    num = (v, d = 0) => typeof v === "number" && Number.isFinite(v) ? v : d;
+    num2 = (v, d = 0) => typeof v === "number" && Number.isFinite(v) ? v : d;
     LANG_GLOBS = {
       typescript: ["**/*.ts", "**/*.tsx"],
       javascript: ["**/*.js", "**/*.jsx"],
@@ -32519,7 +32604,7 @@ async function Module2(moduleArg = {}) {
   _fd_close.sig = "ii";
   var INT53_MAX = 9007199254740992;
   var INT53_MIN = -9007199254740992;
-  var bigintToI53Checked = /* @__PURE__ */ __name((num2) => num2 < INT53_MIN || num2 > INT53_MAX ? NaN : Number(num2), "bigintToI53Checked");
+  var bigintToI53Checked = /* @__PURE__ */ __name((num3) => num3 < INT53_MIN || num3 > INT53_MAX ? NaN : Number(num3), "bigintToI53Checked");
   function _fd_seek(fd, offset, whence, newOffset) {
     offset = bigintToI53Checked(offset);
     return 70;
@@ -32537,7 +32622,7 @@ async function Module2(moduleArg = {}) {
     }
   }, "printChar");
   var _fd_write = /* @__PURE__ */ __name((fd, iov, iovcnt, pnum) => {
-    var num2 = 0;
+    var num3 = 0;
     for (var i2 = 0; i2 < iovcnt; i2++) {
       var ptr = LE_HEAP_LOAD_U32((iov >> 2) * 4);
       var len = LE_HEAP_LOAD_U32((iov + 4 >> 2) * 4);
@@ -32545,9 +32630,9 @@ async function Module2(moduleArg = {}) {
       for (var j = 0; j < len; j++) {
         printChar(fd, HEAPU8[ptr + j]);
       }
-      num2 += len;
+      num3 += len;
     }
-    LE_HEAP_STORE_U32((pnum >> 2) * 4, num2);
+    LE_HEAP_STORE_U32((pnum >> 2) * 4, num3);
     return 0;
   }, "_fd_write");
   _fd_write.sig = "iippp";
@@ -52087,6 +52172,19 @@ var TIEBREAK = [
   { re: /same (issue|problem|pattern|root cause) as|instance of|an example of/i, type: "INSTANCE_OF" },
   { re: /depends on|requires|relies on/i, type: "DEPENDS_ON" }
 ];
+function packageName(description) {
+  const at = description.lastIndexOf("@");
+  return at > 0 ? description.slice(0, at) : description;
+}
+function fileImportsPackage(store, fileId, pkg) {
+  for (const e of store.outEdges(fileId, ["IMPORTS"])) {
+    const spec = store.getNode(e.to)?.description;
+    if (!spec || spec.startsWith(".") || spec.startsWith("/")) continue;
+    const specPkg = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
+    if (specPkg === pkg) return true;
+  }
+  return false;
+}
 function tagEdgeCorroborated(targetAnchorIds, sessionTouchedNodeIds, independentReassert = false) {
   if (independentReassert) return true;
   for (const a of targetAnchorIds) if (sessionTouchedNodeIds.has(a)) return true;
@@ -52152,6 +52250,18 @@ function mintPriorEdge(store, source, target, sentence, touched, ts) {
   if (anchorIds.size === 0 && (target.label === "Language" || target.label === "Package")) {
     for (const e of store.inEdges(target.id, STACK_GROUNDING_EDGES)) anchorIds.add(e.from);
   }
+  if ((target.label === "Language" || target.label === "Package") && target.description) {
+    const targetName = target.description;
+    for (const tid of touched) {
+      const tn = store.getNode(tid);
+      if (tn?.label !== "File") continue;
+      const grounded = target.label === "Language" ? String(tn.attrs["language"] ?? "").toLowerCase() === targetName.toLowerCase() : fileImportsPackage(store, tid, packageName(targetName));
+      if (grounded) {
+        anchorIds.add(tid);
+        break;
+      }
+    }
+  }
   if (anchorIds.size === 0 && target.label === "Tool") anchorIds.add(target.id);
   const corroborated = tagEdgeCorroborated(anchorIds, touched, false);
   store.mergeEdge({
@@ -54559,7 +54669,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.600" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.610" : "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;
@@ -55824,6 +55934,9 @@ function createWorkspaceEngine(opts) {
         exposureShown,
         exposureEvicted,
         exposureUnshown,
+        // The sum, so one liveness effectCounter sees an outcome regardless of
+        // which cell it landed in (WM-join).
+        exposureOutcomes: exposureShown + exposureEvicted + exposureUnshown,
         touchedFileTurns,
         touchedToolTurns,
         // Seam diagnostic: sessions holding tool-run records at harvest time.
@@ -56101,6 +56214,16 @@ function createWorkspaceEngine(opts) {
       if (report.revisitsCleared > 0 || report.fixCandidatesSettled > 0 || report.designResolved > 0) {
         refreshContextNow();
       }
+      try {
+        const t0 = Date.now();
+        appendPassLedger(
+          paths.configDir,
+          "wm-calibration",
+          Date.now() - t0,
+          wmCalibrationCells(store)
+        );
+      } catch {
+      }
       livenessWatch.maybeRun();
       return report;
     },
@@ -57728,6 +57851,12 @@ async function startMultiDaemon(opts = {}) {
       onHook: engine.webHooks.onHook,
       onHookEvent: engine.webHooks.onHookEvent,
       onShellEvent: engine.webHooks.onShellEvent,
+      // The tool-run RECORD seam (SP-tool-ground). The single-engine path wired
+      // this in #1172; this sibling builder never did, so on every multi
+      // deployment (i.e. every real one) the webui logged "tool-run recorded"
+      // and dropped the record on the floor — toolSessionsTracked read 0 across
+      // 936 turns while the log showed records landing (VS-corroboration-rate).
+      onToolsObserved: engine.webHooks.onToolsObserved,
       onToolError: engine.webHooks.onToolError,
       onDiagnostics: engine.webHooks.onDiagnostics,
       onTurn: engine.webHooks.onTurn,

package/package.json

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