@inerrata-corporation/errata 2.0.2-dev.881 → 2.0.2-dev.902

package/errata.mjs

@@ -22197,7 +22197,10 @@ function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mech
   return mechanisms.map((d) => {
     const fed = evaluateFed(store, d);
     const inv = invocations.get(d.pass);
-    const effectCount = inv?.totals[d.effectCounter] ?? 0;
+    const effectCount = d.effectIsLevel ? Math.max(
+      0,
+      (inv?.lastTotals?.[d.effectCounter] ?? 0) - (inv?.firstTotals?.[d.effectCounter] ?? 0)
+    ) : inv?.totals[d.effectCounter] ?? 0;
     const backlog = d.backlogCounter ? inv?.lastTotals?.[d.backlogCounter] : void 0;
     const backlogWas = d.backlogCounter ? inv?.firstTotals?.[d.backlogCounter] : void 0;
     const span = inv?.firstTs === void 0 ? 0 : inv.lastTs - inv.firstTs;
@@ -22394,7 +22397,11 @@ var init_mechanism_liveness = __esm({
         // 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.
+        // Which is precisely why it must be read as movement — measured across the
+        // 103 retained rows it never left 1, and the summed reading called that
+        // "effect 103, ok".
         effectCounter: "reinforcedNodes",
+        effectIsLevel: true,
         note: "levels ride the wm-calibration row; expect no-effect until outcome data accrues"
       },
       {
@@ -49850,19 +49857,32 @@ function summarizeWitnessLedger(configDir, nowMs) {
   if (entries.length === 0) return [];
   const byChannel = /* @__PURE__ */ new Map();
   for (const e of entries) {
-    const c = byChannel.get(e.channel) ?? { recorded: 0, selfSkipped: 0, selfGated: 0, unmatched: 0, lastTs: 0 };
+    const c = byChannel.get(e.channel) ?? {
+      recorded: 0,
+      selfSkipped: 0,
+      selfGated: 0,
+      unmatchedAttempts: 0,
+      parked: -1,
+      awaitingDrain: -1,
+      lastTs: 0
+    };
     c.recorded += e.recorded ?? 0;
     c.selfSkipped += e.clientSelfSkipped ?? 0;
     c.selfGated += e.selfGated ?? 0;
-    c.unmatched += e.unmatched ?? 0;
+    c.unmatchedAttempts += e.unmatched ?? 0;
+    if (e.ts >= c.lastTs) {
+      if (e.parked !== void 0) c.parked = e.parked;
+      if (e.awaitingDrain !== void 0) c.awaitingDrain = e.awaitingDrain;
+    }
     c.lastTs = Math.max(c.lastTs, e.ts);
     byChannel.set(e.channel, c);
   }
   const out2 = [];
   for (const [channel, c] of byChannel) {
     const ageH = Math.round((nowMs - c.lastTs) / 36e5);
+    const depth = c.parked < 0 ? "parked ?" : `parked ${c.parked}${c.awaitingDrain > 0 ? ` (${c.awaitingDrain} awaiting drain)` : ""}`;
     out2.push(
-      `${channel}: recorded ${c.recorded} \xB7 self-gated ${c.selfSkipped + c.selfGated} \xB7 unmatched ${c.unmatched} \xB7 last activity ${ageH}h ago`
+      `${channel}: recorded ${c.recorded} \xB7 self-gated ${c.selfSkipped + c.selfGated} \xB7 ${depth} \xB7 ${c.unmatchedAttempts} unmatched attempt(s) \xB7 last activity ${ageH}h ago`
     );
   }
   return out2;
@@ -56036,53 +56056,6 @@ function maybeFlushDigests() {
 
 // src/liveness-watch.ts
 init_src5();
-var LIVENESS_WATCH_INTERVAL_MS = 60 * 60 * 1e3;
-var ALARM_RENOTIFY_MS = 24 * 60 * 60 * 1e3;
-function createLivenessWatch(deps) {
-  let lastRunAt = 0;
-  const lastAlarmedAt = /* @__PURE__ */ new Map();
-  return {
-    maybeRun(nowMs = Date.now()) {
-      if (nowMs - lastRunAt < LIVENESS_WATCH_INTERVAL_MS) return null;
-      lastRunAt = nowMs;
-      try {
-        const started2 = Date.now();
-        const invocations = /* @__PURE__ */ new Map();
-        for (const [kind, s] of summarizePassLedger(deps.configDir)) {
-          invocations.set(kind, {
-            lastTs: s.lastTs,
-            firstTs: s.firstTs,
-            runs: s.runs,
-            totals: s.totals,
-            firstTotals: s.firstTotals,
-            lastTotals: s.lastTotals
-          });
-        }
-        const rows = evaluateMechanisms(deps.store, invocations);
-        const workspaceActive = invocations.has("capture") || invocations.has("render");
-        const bad = workspaceActive ? rows.filter((r) => hasStarvedMechanism([r])) : [];
-        appendPassLedger(deps.configDir, "liveness-watch", Date.now() - started2, {
-          mechanisms: rows.length,
-          alarms: bad.length,
-          ...Object.fromEntries(bad.map((r) => [`starved:${r.id}`, 1]))
-        });
-        if (bad.length > 0) {
-          const lines = formatMechanismStatus(rows, nowMs);
-          for (const r of bad) {
-            const at = lastAlarmedAt.get(r.id) ?? 0;
-            if (nowMs - at < ALARM_RENOTIFY_MS) continue;
-            lastAlarmedAt.set(r.id, nowMs);
-            const line = lines.find((l) => l.includes(r.id)) ?? `${r.verdict} ${r.id}`;
-            deps.onAlarm(r.id, `${line.trim()} \u2014 ${r.what}`);
-          }
-        }
-        return rows;
-      } catch {
-        return null;
-      }
-    }
-  };
-}
 
 // src/loop-lag.ts
 var HEARTBEAT_MS = 500;
@@ -56157,8 +56130,69 @@ function watchCensusLine(c = watchCensus()) {
   return base;
 }
 
+// src/liveness-watch.ts
+var LIVENESS_WATCH_INTERVAL_MS = 60 * 60 * 1e3;
+var ALARM_RENOTIFY_MS = 24 * 60 * 60 * 1e3;
+function createLivenessWatch(deps) {
+  let lastRunAt = 0;
+  const lastAlarmedAt = /* @__PURE__ */ new Map();
+  return {
+    maybeRun(nowMs = Date.now()) {
+      if (nowMs - lastRunAt < LIVENESS_WATCH_INTERVAL_MS) return null;
+      lastRunAt = nowMs;
+      try {
+        const started2 = Date.now();
+        const invocations = /* @__PURE__ */ new Map();
+        for (const [kind, s] of summarizePassLedger(deps.configDir)) {
+          invocations.set(kind, {
+            lastTs: s.lastTs,
+            firstTs: s.firstTs,
+            runs: s.runs,
+            totals: s.totals,
+            firstTotals: s.firstTotals,
+            lastTotals: s.lastTotals
+          });
+        }
+        const rows = evaluateMechanisms(deps.store, invocations);
+        const workspaceActive = invocations.has("capture") || invocations.has("render");
+        const bad = workspaceActive ? rows.filter((r) => hasStarvedMechanism([r])) : [];
+        const watch2 = watchCensus();
+        const pass = passState();
+        appendPassLedger(deps.configDir, "liveness-watch", Date.now() - started2, {
+          mechanisms: rows.length,
+          alarms: bad.length,
+          ...Object.fromEntries(bad.map((r) => [`starved:${r.id}`, 1])),
+          ...deps.witnessParked ? { witnessParked: deps.witnessParked() } : {},
+          watchDispatched: watch2.dispatched,
+          watchEmitted: watch2.emitted,
+          watchLogged: watch2.logged,
+          watchRejected: watch2.rejected,
+          // Concurrency and the longest single holder — the two readings that
+          // named the 6017s zombie pass. A pass legitimately running for hours
+          // and one wedged forever look identical without a trend.
+          passesActive: pass.active.length,
+          passLongestRunningMs: pass.active.reduce((m, p) => Math.max(m, p.runningMs), 0)
+        });
+        if (bad.length > 0) {
+          const lines = formatMechanismStatus(rows, nowMs);
+          for (const r of bad) {
+            const at = lastAlarmedAt.get(r.id) ?? 0;
+            if (nowMs - at < ALARM_RENOTIFY_MS) continue;
+            lastAlarmedAt.set(r.id, nowMs);
+            const line = lines.find((l) => l.includes(r.id)) ?? `${r.verdict} ${r.id}`;
+            deps.onAlarm(r.id, `${line.trim()} \u2014 ${r.what}`);
+          }
+        }
+        return rows;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.881" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.902" : "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;
@@ -56504,7 +56538,11 @@ function createWorkspaceEngine(opts) {
     onAlarm: (id, line) => {
       console.warn(`[errata] mechanism not working: ${line}`);
       notifyEvent("mechanism-stalled", line, { key: id });
-    }
+    },
+    // Read through a closure, not captured once: `witnessQueue` is reassigned
+    // on every harvest, so a snapshot would freeze the depth at boot — which is
+    // the same in-memory-only blindness this counter exists to end.
+    witnessParked: () => witnessQueue.length
   });
   const intents = createIntentState();
   const toolRuns = createToolRunState();
@@ -60435,7 +60473,11 @@ async function startMultiDaemon(opts = {}) {
             ...compositionCounters(composition),
             accepted: 0,
             rejected: 0,
-            blocked: 0
+            blocked: 0,
+            // Same shape as the drained row: a first/last trend reading must not
+            // straddle rows where the counter is merely absent.
+            blockedRepeat: 0,
+            rejectedRepeat: 0
           });
         }
         if (instances) {
@@ -60476,15 +60518,29 @@ async function startMultiDaemon(opts = {}) {
               if (sh) return { s: sharedStore, n: sh };
               return null;
             };
+            let blockedRepeat = 0;
+            let rejectedRepeat = 0;
+            const noteRefused = (id, repeat) => {
+              const owner = owningStore(id);
+              if (!owner) return;
+              if (owner.n.attrs["shipRefusedSinceSeq"] !== void 0) repeat();
+              else
+                owner.s.updateNode(id, {
+                  attrs: { ...owner.n.attrs, shipRefusedSinceSeq: seq }
+                });
+            };
+            for (const id of blocked) noteRefused(id, () => blockedRepeat++);
+            for (const id of rejected.keys()) noteRefused(id, () => rejectedRepeat++);
             for (const n of instances.nodes) {
               const owner = owningStore(n.id);
               if (!owner || !["Problem", "Solution", "RootCause"].includes(owner.n.label)) continue;
               if (blocked.has(n.id)) continue;
               if (rejected.has(n.id)) continue;
               const cloudNodeId = cloudIdByLocal.get(n.id);
+              const { shipRefusedSinceSeq: _cleared, ...carried } = owner.n.attrs;
               owner.s.updateNode(n.id, {
                 attrs: {
-                  ...owner.n.attrs,
+                  ...carried,
                   contributedAtSeq: seq,
                   ...cloudNodeId && cloudNodeId !== n.id ? { cloudNodeId } : {}
                 }
@@ -60510,7 +60566,13 @@ async function startMultiDaemon(opts = {}) {
               ...compositionCounters(instances.composition),
               accepted: res.accepted,
               rejected: rejected.size,
-              blocked: blocked.size
+              blocked: blocked.size,
+              // The half of the refusal count that is NOT news. `blocked` flat
+              // at 1 with `blockedRepeat` also 1 is one permanently stranded
+              // node; flat at 1 with `blockedRepeat` 0 is a different node
+              // failing every pass. Same total, different bug.
+              blockedRepeat,
+              rejectedRepeat
             });
             return res.accepted;
           });

package/package.json

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