@inerrata-corporation/errata 2.0.23 → 2.0.24-dev.5107

package/pass-worker.mjs

@@ -16534,7 +16534,25 @@ var TAG_CANONICAL_ID_PREFIXES, TAG_HANDLE_SOURCE, TAG_THREAD_SOURCE, TAG_PLACEHO
 var init_tag_grammar = __esm({
   "../../packages/local-shared/src/tag-grammar.ts"() {
     "use strict";
-    TAG_CANONICAL_ID_PREFIXES = ["pat", "sol", "drc", "dcause", "dfix", "dprob", "dvuln", "prob", "claim", "err"];
+    TAG_CANONICAL_ID_PREFIXES = [
+      "motif_community_projn",
+      "motif_community_orgn",
+      "motif",
+      "projn",
+      "orgn",
+      "dtri",
+      "dom",
+      "pat",
+      "sol",
+      "drc",
+      "dcause",
+      "dfix",
+      "dprob",
+      "dvuln",
+      "prob",
+      "claim",
+      "err"
+    ];
     TAG_HANDLE_SOURCE = String.raw`\[([a-z0-9][\w-]{0,80})\]|((?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})`;
     TAG_THREAD_SOURCE = String.raw`#([a-z][\w-]{0,63})`;
     TAG_PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
@@ -26818,6 +26836,197 @@ function communityDomain(memberDomains, domainSize) {
   return best;
 }
 
+// ../../packages/math/src/spectral.ts
+function largestConnectedComponent(n, adj) {
+  const seen = new Uint8Array(n);
+  let best = [];
+  for (let start2 = 0; start2 < n; start2++) {
+    if (seen[start2]) continue;
+    const comp = [];
+    const queue = [start2];
+    seen[start2] = 1;
+    while (queue.length) {
+      const v = queue.shift();
+      comp.push(v);
+      for (const { j } of adj[v]) {
+        if (!seen[j]) {
+          seen[j] = 1;
+          queue.push(j);
+        }
+      }
+    }
+    if (comp.length > best.length) best = comp;
+  }
+  return best;
+}
+function indexedAdjacency(input) {
+  const idx = new Map(input.nodeIds.map((id, i2) => [id, i2]));
+  const adj = input.nodeIds.map(() => []);
+  for (const id of input.nodeIds) {
+    const i2 = idx.get(id);
+    for (const { to, weight } of input.adj.get(id) ?? []) {
+      const j = idx.get(to);
+      if (j === void 0 || j === i2) continue;
+      adj[i2].push({ j, w: weight });
+    }
+  }
+  return adj;
+}
+function largestConnectedComponentSize(input) {
+  return largestConnectedComponent(input.nodeIds.length, indexedAdjacency(input)).length;
+}
+
+// ../../packages/math/src/detectability.ts
+var BETHE_DEFAULT_MAX = 32;
+var betheSteps = (maxCommunities) => 2 * maxCommunities + 40;
+var NEGATIVE_TOLERANCE = 1e-7;
+function betheDetectability(input, opts = {}) {
+  const unweighted = opts.unweighted ?? true;
+  const maxCommunities = opts.maxCommunities ?? BETHE_DEFAULT_MAX;
+  const n = input.nodeIds.length;
+  const empty = {
+    nodes: n,
+    meanDegree: 0,
+    negativeEigenvalues: [],
+    detectableCommunities: 0,
+    capped: false
+  };
+  if (n < 2) return empty;
+  const idx = /* @__PURE__ */ new Map();
+  input.nodeIds.forEach((id, i2) => idx.set(id, i2));
+  const rows = input.nodeIds.map(() => []);
+  const deg = new Float64Array(n);
+  let twoM = 0;
+  for (const id of input.nodeIds) {
+    const i2 = idx.get(id);
+    for (const { to, weight } of input.adj.get(id) ?? []) {
+      const j = idx.get(to);
+      if (j === void 0 || j === i2 || weight <= 0) continue;
+      const w = unweighted ? 1 : weight;
+      rows[i2].push([j, w]);
+      deg[i2] = deg[i2] + w;
+      twoM += w;
+    }
+  }
+  if (twoM <= 0) return empty;
+  const d = twoM / n;
+  let sumSq = 0;
+  for (let i2 = 0; i2 < n; i2++) sumSq += deg[i2] * deg[i2];
+  const excess = sumSq / twoM - 1;
+  if (excess <= 0) return { ...empty, meanDegree: d };
+  const r = Math.sqrt(excess);
+  const diagShift = r * r - 1;
+  const apply = (v, out2) => {
+    for (let i2 = 0; i2 < n; i2++) {
+      let av = 0;
+      for (const [j, w] of rows[i2]) av += w * v[j];
+      out2[i2] = diagShift * v[i2] - r * av + deg[i2] * v[i2];
+    }
+  };
+  const ritz = lanczosRitzValues(n, apply, Math.min(n, betheSteps(maxCommunities)), 24301);
+  let scale = 1;
+  for (const x of ritz) scale = Math.max(scale, Math.abs(x));
+  const negatives = ritz.filter((x) => x < -NEGATIVE_TOLERANCE * scale);
+  const capped = negatives.length >= maxCommunities;
+  const kept = negatives.slice(0, maxCommunities);
+  return {
+    nodes: n,
+    meanDegree: d,
+    negativeEigenvalues: kept,
+    detectableCommunities: Math.max(0, kept.length - 1),
+    capped
+  };
+}
+function lanczosRitzValues(n, apply, steps, seed) {
+  const prng = mulberry32(seed);
+  let v = new Float64Array(n);
+  for (let i2 = 0; i2 < n; i2++) v[i2] = prng() - 0.5;
+  const shaped = new Float64Array(n);
+  apply(v, shaped);
+  if (normalize2(shaped) > 0) v = shaped;
+  else if (normalize2(v) === 0) return [];
+  const basis = [];
+  const alpha = [];
+  const beta = [];
+  let prev = null;
+  let b = 0;
+  for (let j = 0; j < steps; j++) {
+    basis.push(v);
+    const w = new Float64Array(n);
+    apply(v, w);
+    let a = 0;
+    for (let i2 = 0; i2 < n; i2++) a += w[i2] * v[i2];
+    alpha.push(a);
+    for (let i2 = 0; i2 < n; i2++) w[i2] = w[i2] - a * v[i2] - (prev ? b * prev[i2] : 0);
+    for (const u of basis) projectOff(w, u);
+    b = normalize2(w);
+    if (b <= 1e-12 * Math.max(1, Math.abs(a))) break;
+    beta.push(b);
+    prev = v;
+    v = w;
+  }
+  return tridiagonalEigenvalues(alpha, beta.slice(0, alpha.length - 1));
+}
+function tridiagonalEigenvalues(alpha, beta) {
+  const m = alpha.length;
+  if (m === 0) return [];
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (let i2 = 0; i2 < m; i2++) {
+    const radius = (i2 > 0 ? Math.abs(beta[i2 - 1]) : 0) + (i2 < m - 1 ? Math.abs(beta[i2]) : 0);
+    lo = Math.min(lo, alpha[i2] - radius);
+    hi = Math.max(hi, alpha[i2] + radius);
+  }
+  const tiny = 1e-300;
+  const countBelow = (x) => {
+    let count = 0;
+    let q = alpha[0] - x;
+    if (q < 0) count++;
+    for (let i2 = 1; i2 < m; i2++) {
+      if (q === 0) q = tiny;
+      q = alpha[i2] - x - beta[i2 - 1] * beta[i2 - 1] / q;
+      if (q < 0) count++;
+    }
+    return count;
+  };
+  const out2 = [];
+  const width = Math.max(hi - lo, 1e-12);
+  for (let k = 0; k < m; k++) {
+    let a = lo;
+    let c = hi;
+    for (let it = 0; it < 200 && c - a > 1e-13 * width; it++) {
+      const mid = (a + c) / 2;
+      if (countBelow(mid) > k) c = mid;
+      else a = mid;
+    }
+    out2.push((a + c) / 2);
+  }
+  return out2;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function projectOff(v, u) {
+  let dot = 0;
+  for (let i2 = 0; i2 < v.length; i2++) dot += v[i2] * u[i2];
+  if (dot === 0) return;
+  for (let i2 = 0; i2 < v.length; i2++) v[i2] = v[i2] - dot * u[i2];
+}
+function normalize2(v) {
+  let s = 0;
+  for (let i2 = 0; i2 < v.length; i2++) s += v[i2] * v[i2];
+  const norm = Math.sqrt(s);
+  if (norm > 0) for (let i2 = 0; i2 < v.length; i2++) v[i2] = v[i2] / norm;
+  return norm;
+}
+
 // ../../packages/math/src/void-demand.ts
 var DEMAND_HOT = Math.log1p(10);
 var DEMAND_WARM = Math.log1p(5);
@@ -26976,13 +27185,23 @@ function pagerankLocal(input) {
   return { scores, iterations: iter, converged };
 }
 
+// ../../packages/math/src/reader-evidence.ts
+var FIELD_CODES = {
+  a: "acceptedCount",
+  c: "corroborationCount",
+  f: "failureReportCount",
+  p: "contradictionPressure"
+};
+var FIELDS = Object.values(FIELD_CODES);
+
 // ../../packages/local-graph/src/node-select.ts
 var SELECT_INDEXES = [
   "nodes_live_local_community",
   "nodes_live_fold_candidate",
   "nodes_live_resolved",
   "nodes_live_fix_candidate",
-  "nodes_live_anchor_hint"
+  "nodes_live_anchor_hint",
+  "nodes_live_created_v2"
 ];
 var EMBEDDING_DIM_SQL = "(CASE WHEN length(embedding_blob) >= 4 THEN length(embedding_blob) / 4 ELSE COALESCE(json_array_length(embedding_json), 0) END)";
 var KEY = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
@@ -27303,7 +27522,10 @@ CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
 `;
 var TEMPORAL_INDEX_SQL = `
 CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
-CREATE INDEX IF NOT EXISTS nodes_live_count ON nodes(valid_to);
+-- Dropped: a prefix of nodes_live_page_rank (valid_to, page_rank), which serves
+-- the live count and the "any live node?" check as a covering index too. It was
+-- re-keyed on every close and revive: ~11 KB of a symbol flip's ~80 KB.
+DROP INDEX IF EXISTS nodes_live_count;
 -- Problems by recency (the only label read newest-first). Over every live row,
 -- each write that stamps last_updated_at moved a code symbol's entry from a
 -- scattered leaf: ~19 KB per position-only symbol rewrite on a 1.1 GB store.
@@ -27315,7 +27537,13 @@ CREATE INDEX IF NOT EXISTS nodes_live_problem_recent ON nodes(label, last_update
 -- walks nodes_live and reads every live row of the label to test created_at:
 -- 56 MB per guard on a 1.1 GB store, to learn there was nothing to do. valid_to
 -- is a key column so the planner prefers this over nodes_live (one more term).
-CREATE INDEX IF NOT EXISTS nodes_live_created ON nodes(label, valid_to, created_at) WHERE valid_to IS NULL;
+-- last_updated_at rides along for errata.recent on code labels, which names this
+-- index: the filter runs on index entries, not on every row of the label (79 ms
+-- \u2192 3 ms for Function on a 1.1 GB store). It costs no extra writes: a close or
+-- revive already re-keys this index, and mergeNodeIfChanged leaves a symbol's
+-- last_updated_at alone when only its position moved.
+DROP INDEX IF EXISTS nodes_live_created;
+CREATE INDEX IF NOT EXISTS nodes_live_created_v2 ON nodes(label, valid_to, created_at, last_updated_at) WHERE valid_to IS NULL;
 -- Community members (the skills pull reads them twice per session boundary):
 -- ~15% of semantic nodes carry a localCommunity, and without this every live
 -- semantic row was read to find them (168 MB \u2192 18 MB per read).
@@ -27500,6 +27728,12 @@ function sameSqlValue(a, b) {
   if (a instanceof Uint8Array && b instanceof Uint8Array) return Buffer.compare(a, b) === 0;
   return false;
 }
+var POSITION_ATTRS = ["startByte", "endByte", "startRow"];
+function attrsJsonWithoutPositions(attrs) {
+  const rest = { ...attrs };
+  for (const k of POSITION_ATTRS) delete rest[k];
+  return JSON.stringify(rest);
+}
 var PRIOR_TAG_MARKER = '"priorTag":true';
 var SqliteGraphStore = class {
   db;
@@ -27600,7 +27834,7 @@ var SqliteGraphStore = class {
       lastUpdatedOf: this.db.prepare("SELECT last_updated_at AS t, attrs_json FROM nodes WHERE id = ?"),
       labelOf: this.db.prepare("SELECT label FROM nodes WHERE id = ?"),
       nodeContent: this.db.prepare(
-        "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, attrs_json FROM nodes WHERE id = ?"
+        "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, last_updated_at, attrs_json FROM nodes WHERE id = ?"
       ),
       edgeContent: this.db.prepare(
         "SELECT confidence, valid_to, attrs_json FROM edges WHERE from_id = ? AND type = ? AND to_id = ?"
@@ -28013,11 +28247,23 @@ var SqliteGraphStore = class {
    *  rank, community, landmark, surprise, hits, tier and the vector belong to
    *  the passes that compute them, and a skipped write leaves them as they are
    *  where a merge would have reset them to the producer's defaults. Returns
-   *  whether it wrote. */
+   *  whether it wrote.
+   *
+   *  A live row whose only change is its position keeps its lastUpdatedAt, so
+   *  that stamp means "this symbol's content changed": what errata.recent lists
+   *  and the fix-candidate ask reads, and what lets nodes_live_created_v2 carry
+   *  it without being re-keyed by every edit above a symbol. A closed row is
+   *  always stamped: reviveReobserved reopens what this pass stamped. */
   mergeNodeIfChanged(node) {
     const row = this.stmts.nodeContent.get(node.id);
-    if (row && row.valid_to === null && row.label === node.label && row.description === node.description && row.extraction_confidence === node.extractionConfidence && row.stability === node.stability && !EXPOSURE_ATTRS.some((k) => node.attrs?.[k] !== void 0) && row.attrs_json === JSON.stringify(node.attrs ?? {})) return false;
-    this.mergeNode(node);
+    if (!row || row.valid_to !== null || row.label !== node.label || row.description !== node.description || row.extraction_confidence !== node.extractionConfidence || row.stability !== node.stability || EXPOSURE_ATTRS.some((k) => node.attrs?.[k] !== void 0)) {
+      this.mergeNode(node);
+      return true;
+    }
+    const attrs = node.attrs ?? {};
+    if (row.attrs_json === JSON.stringify(attrs)) return false;
+    const moved = attrsJsonWithoutPositions(JSON.parse(row.attrs_json)) === attrsJsonWithoutPositions(attrs);
+    this.mergeNode(moved ? { ...node, lastUpdatedAt: row.last_updated_at } : node);
     return true;
   }
   updateNode(id, patch) {
@@ -28097,8 +28343,8 @@ var SqliteGraphStore = class {
       stmt2 = this.db.prepare(
         // Ordered, not left to the planner: readers take "first row wins" (the
         // symbol lexicon's name winner and doc pick), and the order otherwise
-        // followed whichever partial index the planner chose. nodes_live_created
-        // serves this order without a sort.
+        // followed whichever partial index the planner chose. nodes_live_created_v2
+        // serves it, sorting rowids only within an equal created_at.
         `SELECT id, description, community, extraction_confidence${cols} FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY created_at, rowid`
       );
       this.fieldStmts.set(cacheKey, stmt2);
@@ -29130,10 +29376,12 @@ function crystallize(store2, opts = { ts: 0 }) {
     const s = support(c) + Math.max(0, sourcesCount(c) - 1);
     const f = contradictions;
     const confidence = (1 + s) / (2 + s + f);
-    store2.updateNode(c.id, {
-      attrs: { ...c.attrs, confidence },
-      lastUpdatedAt: opts.ts
-    });
+    if (c.attrs["confidence"] !== confidence) {
+      store2.updateNode(c.id, {
+        attrs: { ...c.attrs, confidence },
+        lastUpdatedAt: opts.ts
+      });
+    }
     const sup = support(c);
     let tier = c.memoryTier;
     if (sup >= PERSISTENT_SUPPORT && confidence >= PERSISTENT_CONFIDENCE) tier = "persistent";
@@ -29201,7 +29449,10 @@ function mergeTruthKind(a, b) {
 function markBoth(store2, a, b, patch, ts) {
   for (const n of [a, b]) {
     const fresh = store2.getNode(n.id);
-    store2.updateNode(n.id, { attrs: { ...fresh.attrs, ...patch }, lastUpdatedAt: ts });
+    const next = { ...patch };
+    if (fresh.attrs["revisit"] === true && fresh.attrs["revisitReason"] === next["revisitReason"]) delete next["revisitSinceTs"];
+    if (Object.entries(next).every(([k, v]) => fresh.attrs[k] === v)) continue;
+    store2.updateNode(n.id, { attrs: { ...fresh.attrs, ...next }, lastUpdatedAt: ts });
   }
 }
 
@@ -29392,6 +29643,20 @@ function backfillProblemContext(store2, ts) {
   return report;
 }
 
+// ../../packages/embedding/src/bands.ts
+var DESIGNED_FOR_MINILM = {
+  dedup: 0.88,
+  softWriteMin: 0.8,
+  bindMin: 0.78,
+  nearMiss: 0.72,
+  judgeMin: 0.5,
+  predictionFloor: 0.5,
+  relevanceFloor: 0.25,
+  relatedWeak: 0.35,
+  relatedStrong: 0.45
+};
+var UNKNOWN = { ...DESIGNED_FOR_MINILM, relevanceFloor: 0.5 };
+
 // ../../packages/local-graph/src/design-problem.ts
 init_src2();
 
@@ -30225,8 +30490,78 @@ function candidateDomains(store2, ids, labelOf) {
   }
   return out2;
 }
+function buildJointAdjacency(store2, ids) {
+  const adj = /* @__PURE__ */ new Map();
+  const protect = [];
+  const add = (a, b, w) => {
+    const l = adj.get(a) ?? [];
+    l.push({ to: b, weight: w });
+    adj.set(a, l);
+  };
+  for (const id of ids) {
+    for (const e of store2.outEdges(id, [...JOINT_COMMUNITY_EDGES])) {
+      if (!ids.has(e.to)) continue;
+      if (e.type === "INSTANCE_OF" && e.extractionSource === "bko-inferred") continue;
+      const conf = e.confidence > 0 ? e.confidence : 0.5;
+      const w = Math.max(EDGE_WEIGHT[e.type] ?? 1, 0.1) * conf;
+      add(id, e.to, w);
+      add(e.to, id, w);
+      if (isCausalProtected(e.type)) protect.push([id, e.to]);
+    }
+  }
+  return { adj, protect };
+}
+function projectionDetectability(input) {
+  let support2 = 0;
+  for (const id of input.nodeIds) support2 += (input.adj.get(id) ?? []).length;
+  const meanDegree = input.nodeIds.length > 0 ? support2 / input.nodeIds.length : 0;
+  const lccIds = largestConnectedComponentMembers(input);
+  const lcc = lccIds.length >= 3 ? betheDetectability({ nodeIds: lccIds, adj: input.adj }) : null;
+  return {
+    readings: {
+      meanDegree,
+      lccSize: lccIds.length,
+      lccDetectable: lcc?.detectableCommunities ?? 0
+    },
+    lccIds
+  };
+}
+function largestConnectedComponentMembers(input) {
+  if (largestConnectedComponentSize(input) <= 1) return input.nodeIds.slice(0, 1);
+  const present = new Set(input.nodeIds);
+  const seen = /* @__PURE__ */ new Set();
+  let best = [];
+  for (const start2 of input.nodeIds) {
+    if (seen.has(start2)) continue;
+    const comp = [];
+    const stack = [start2];
+    seen.add(start2);
+    while (stack.length > 0) {
+      const id = stack.pop();
+      comp.push(id);
+      for (const { to } of input.adj.get(id) ?? []) {
+        if (!present.has(to) || seen.has(to)) continue;
+        seen.add(to);
+        stack.push(to);
+      }
+    }
+    if (comp.length > best.length) best = comp;
+  }
+  return best;
+}
 function detectLocalCommunities(store2, opts = {}) {
-  const report = { candidates: 0, communities: 0, joint: 0, assigned: 0, belowFloor: 0, cleared: 0 };
+  const report = {
+    candidates: 0,
+    communities: 0,
+    joint: 0,
+    assigned: 0,
+    belowFloor: 0,
+    cleared: 0,
+    meanDegree: 0,
+    lccSize: 0,
+    lccDetectable: 0,
+    lccPieces: 0
+  };
   const nodes = /* @__PURE__ */ new Map();
   const unowned = [];
   for (const label of JOINT_COMMUNITY_LABELS) {
@@ -30250,25 +30585,12 @@ function detectLocalCommunities(store2, opts = {}) {
     }
   });
   if (ids.size === 0) return report;
-  const adj = /* @__PURE__ */ new Map();
-  const protect = [];
-  const add = (a, b, w) => {
-    const l = adj.get(a) ?? [];
-    l.push({ to: b, weight: w });
-    adj.set(a, l);
-  };
-  for (const id of ids) {
-    for (const e of store2.outEdges(id, [...JOINT_COMMUNITY_EDGES])) {
-      if (!ids.has(e.to)) continue;
-      if (e.type === "INSTANCE_OF" && e.extractionSource === "bko-inferred") continue;
-      const conf = e.confidence > 0 ? e.confidence : 0.5;
-      const w = Math.max(EDGE_WEIGHT[e.type] ?? 1, 0.1) * conf;
-      add(id, e.to, w);
-      add(e.to, id, w);
-      if (isCausalProtected(e.type)) protect.push([id, e.to]);
-    }
-  }
-  const comm = detectCommunitiesLeiden({ nodeIds: [...ids], adj }, { protect });
+  const { adj, protect } = buildJointAdjacency(store2, ids);
+  const input = { nodeIds: [...ids], adj };
+  const detectability = projectionDetectability(input);
+  Object.assign(report, detectability.readings);
+  const comm = detectCommunitiesLeiden(input, { protect });
+  report.lccPieces = new Set(detectability.lccIds.map((id) => comm.community.get(id))).size;
   const members = /* @__PURE__ */ new Map();
   for (const [id, c] of comm.community) {
     const l = members.get(c) ?? [];
@@ -30346,6 +30668,70 @@ var MECHANISMS = [
     effectCounter: "refutesStamped",
     note: "RG-mark; reason text is local-only (wire ships nodeId+witnessKey)"
   },
+  {
+    id: "confirm-local-stamp",
+    what: "stamps a harvested confirm / leaned-on witness onto the LOCAL node (confirmedAt/confirmations)",
+    pass: "capture",
+    // The consumer is errata.search's one formula (apps/daemon one-search.ts
+    // localEvidence → packages/math rankKnowledge reliability). Self-gated and
+    // synthetic-gated at harvest, so a quiet counter can also mean every cite
+    // was the session's own — the written-at-all bar, like refutedAt.
+    fed: {
+      labels: ["Problem", "Solution", "RootCause", "Pattern"],
+      attr: "confirmedAt",
+      minFraction: 0
+    },
+    effectCounter: "confirmsStamped",
+    note: "consumed by one-search rankKnowledge; transport to cloud corroborationCount unchanged"
+  },
+  {
+    id: "supersession-ask",
+    what: "asks how a just-recorded fix relates to earlier fixes for the same symptom; the agent's answer mints SUPERSEDES/BUILDS_ON/ALTERNATIVE_TO",
+    pass: "capture",
+    // Conditional and rare (a fix landing beside earlier ones) — written-at-all
+    // bar. The consumer is supersededBy in rankKnowledge (local lifecycle.ts,
+    // cloud entry-rank.ts) and the superseded/held notes agents read.
+    fed: {
+      labels: ["Solution"],
+      attr: "supersessionAskedAt",
+      minFraction: 0
+    },
+    effectCounter: "structureLinksMinted",
+    note: "the answer is the agent's; nothing is inferred"
+  },
+  {
+    id: "held-ask",
+    what: "asks a session whether a prior it leaned on held; the agent's confirm/refute answers it",
+    pass: "capture",
+    // Opened only by a lean-on cite of a prior the session did not mint —
+    // written-at-all bar. The answers feed confirmedAt/refutedAt locally and
+    // the cloud's corroborate/contradict channels (§5.4 α/β) — the contrastive
+    // verdicts the FEP core needs (docs/reference/plans/fep-core.md §5.7).
+    fed: {
+      labels: ["Problem", "Solution", "RootCause", "Pattern"],
+      attr: "heldAskedAt",
+      minFraction: 0
+    },
+    // Counts only answers to questions a render actually SHOWED — a verdict the
+    // agent would have given unasked does not prove the ask did anything.
+    effectCounter: "heldAnswered",
+    note: "asked, never inferred; the lean is provisional while asked and replaced by the answer; Network-only priors are asked by id"
+  },
+  {
+    id: "neighbour-ask",
+    what: "shows a just-minted problem's nearest existing problems once; the agent's bare cite ([h]) mints RELATES_TO",
+    pass: "capture",
+    // Conditional (a new problem with a neighbour in the band) — written-at-all
+    // bar. Before this, 69% of open agent-observed Problems had no cause,
+    // instance or relation edge and never gained one (live store 2026-10-27).
+    fed: {
+      labels: ["Problem"],
+      attr: "neighbourAskedAt",
+      minFraction: 0
+    },
+    effectCounter: "neighbourLinksMinted",
+    note: "MEL-203; the link is the agent's \u2014 nothing is inferred from similarity"
+  },
   {
     id: "regression-recognize",
     what: "marks a resolved problem as resolutionSuspect when it recurs at the door",

package/resources/context-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.23",
+  "version": "2.0.24-dev.5107",
   "description": "A minimal 3D view of loaded Errata priors and recent graph bursts.",
   "author": {
     "name": "inErrata"

package/resources/context-plugin/SHA256SUMS

@@ -1,14 +1,14 @@
-2f63c615dcb8381cd2e5eda37ba5bb8aa79e35c7f536e9bbbb9ff5ec18d36040  .codex-plugin/plugin.json
+af56c071ef86e48a2112bfca26f77c5f0b1794b0b6eadac1903e12f5a82673a6  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
-73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js
+80431e822def1ed5f5376ff0e67af30b4d26829572982e08fe24f438838f134c  dist/client.js
 6d2d2068ffa7e6627151aa69e86654d1b3452e7205d75a15b312c1bc663d03d4  dist/index.html
-1c5b4bdf92eca32629bf74003f711cf5bafebb5c9cf988ea068feb8da536457b  dist/mcp-server.mjs
-fca26cc5a0ee1080a9f4aa1773b3e634ea7ff12376bbb66ea66ee3670dc5f274  dist/panel.html
+aa0bb16795d53b70e0de3aad9dbe2d9d13aec1bbe7f7b10f2ad6d636c574e265  dist/mcp-server.mjs
+18146fb994a6e04a1078bed957061e8128be97e8e9e15a06f5a82192476e0b7c  dist/panel.html
 ab99177aff0d134ef44f7867c61a7c4eb8a6afbb0f138c08dbb68e7546260147  dist/server.mjs
 5a721b645e399e676d48f8691ec81694172f1bbdea309c852dd099ef7a147018  dist/style.css
 2644953a4a3762926663db951c03ad3175061c9d52de49cf90d07ddb4c73846a  INSTALL.md
 fb840ab74865258c91565529fa08f9f8586261f973c08a798e8f66d85d3260ed  launch.mjs
 5abff6ef2aff3bc033862e2293421908e6d6fe9425de042412e0c8b577a6d8fc  skills/context-graph/SKILL.md
 9f8d96a5a28248e04b54fdabed59319a640dead39ede67fe9b9283aec678d46f  SUBMISSION.md
-5852d66e82ac6aab92911ba375fa1a02f3ad853f498517e1d50cc0225aa67d66  THIRD-PARTY-NOTICES.md
+24b45b998aae358bcdfbd7569c7243efe494acaca7f89089bbd848b07fc4eefb  THIRD-PARTY-NOTICES.md

package/resources/context-plugin/THIRD-PARTY-NOTICES.md

@@ -251,7 +251,7 @@ the full license text.
 
 ---
 
-## @modelcontextprotocol/sdk@1.29.0
+## @modelcontextprotocol/sdk@1.32.2
 
 LICENSE
 MIT License
@@ -996,6 +996,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
+---
+
+## eventsource-parser@3.1.1
+
+LICENSE
+MIT License
+
+Copyright (c) 2026 Espen Hovlandsdal <espen@hovlandsdal.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
 ---
 
 ## eventsource@3.0.7