@inerrata-corporation/errata 2.0.24-dev.5105 → 2.0.24-dev.5108

package/errata.mjs

@@ -20275,6 +20275,44 @@ var init_community_floor = __esm({
 });
 
 // ../../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;
+}
 var init_spectral = __esm({
   "../../packages/math/src/spectral.ts"() {
     "use strict";
@@ -20289,6 +20327,163 @@ var init_community_health = __esm({
   }
 });
 
+// ../../packages/math/src/detectability.ts
+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 count2 = 0;
+    let q = alpha[0] - x;
+    if (q < 0) count2++;
+    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) count2++;
+    }
+    return count2;
+  };
+  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;
+}
+var BETHE_DEFAULT_MAX, betheSteps, NEGATIVE_TOLERANCE;
+var init_detectability = __esm({
+  "../../packages/math/src/detectability.ts"() {
+    "use strict";
+    BETHE_DEFAULT_MAX = 32;
+    betheSteps = (maxCommunities) => 2 * maxCommunities + 40;
+    NEGATIVE_TOLERANCE = 1e-7;
+  }
+});
+
 // ../../packages/math/src/void-demand.ts
 var DEMAND_HOT, DEMAND_WARM;
 var init_void_demand = __esm({
@@ -20626,6 +20821,7 @@ var init_src3 = __esm({
     init_community_floor();
     init_spectral();
     init_community_health();
+    init_detectability();
     init_void_demand();
     init_motif_gate();
     init_bko();
@@ -23882,7 +24078,7 @@ function staticModel(header, scales, weights) {
     return ids;
   }
   function tokenize4(text) {
-    return preTokenize(normalize2(text)).flatMap(wordpiece);
+    return preTokenize(normalize3(text)).flatMap(wordpiece);
   }
   function embed2(text) {
     const sum = new Float64Array(dim);
@@ -23911,7 +24107,7 @@ function isBertPunctuation(ch) {
 function isCjk(c) {
   return c >= 19968 && c <= 40959 || c >= 13312 && c <= 19903 || c >= 131072 && c <= 173791 || c >= 173824 && c <= 177983 || c >= 177984 && c <= 178207 || c >= 178208 && c <= 183983 || c >= 63744 && c <= 64255 || c >= 194560 && c <= 195103;
 }
-function normalize2(text) {
+function normalize3(text) {
   let out2 = "";
   for (const ch of text) {
     const c = ch.codePointAt(0);
@@ -27140,8 +27336,78 @@ function candidateDomains(store, ids, labelOf) {
   }
   return out2;
 }
+function buildJointAdjacency(store, 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 store.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(store, 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) {
@@ -27165,25 +27431,12 @@ function detectLocalCommunities(store, 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 store.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(store, 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) ?? [];
@@ -27455,6 +27708,7 @@ async function resolveFoldCandidates(store, opts) {
     const fresh = store.getNode(node2.id);
     if (!openProblem(fresh)) continue;
     const mark = fresh.attrs["foldCandidate"];
+    if (!mark) continue;
     const firstLook = mark.examinedAtSeq === void 0;
     report.examined++;
     if (firstLook) {
@@ -27955,6 +28209,21 @@ var init_mechanism_liveness = __esm({
         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",
@@ -28329,6 +28598,7 @@ __export(src_exports2, {
   backfillLegacyAnchors: () => backfillLegacyAnchors,
   backfillProblemContext: () => backfillProblemContext,
   backfillProblemPackageLinks: () => backfillProblemPackageLinks,
+  buildJointAdjacency: () => buildJointAdjacency,
   buildLanguageIndex: () => buildLanguageIndex,
   buildPackageIndex: () => buildPackageIndex,
   buildPrincipleSync: () => buildPrincipleSync,
@@ -28426,6 +28696,7 @@ __export(src_exports2, {
   percolate: () => percolate,
   priorExposure: () => priorExposure,
   priorsForFile: () => priorsForFile,
+  projectionDetectability: () => projectionDetectability,
   promoteRouteWithDiscriminator: () => promoteRouteWithDiscriminator,
   propagateFactChange: () => propagateFactChange,
   propagateVersionChange: () => propagateVersionChange,
@@ -28961,6 +29232,19 @@ function renderSnapshot(s) {
     }
     lines.push("");
   }
+  if (s.neighbourAsks?.length) {
+    lines.push("### \u{1F9ED} Neighbours of your new problem");
+    lines.push(
+      "_These existing problems read closest to one you just stated. If one is related, cite it beside yours \u2014 `([h])` links them; a problem nobody links stays an island no later search can reach from here. Unrelated \u2192 ignore:_"
+    );
+    for (const a of s.neighbourAsks) {
+      lines.push(`- yours: **${a.problem.description}** \u2014 \`${a.problem.id}\``);
+      for (const n of a.neighbours) {
+        lines.push(`  - near: **${n.description}** \u2014 \`${n.id}\`${n.lifecycle ? ` _(${n.lifecycle})_` : ""} \u2192 related: ([${n.id}])`);
+      }
+    }
+    lines.push("");
+  }
   lines.push("### Recently observed problems in this workspace");
   if (s.recentProblems.length === 0 && s.recentResolved.length === 0 && s.recentConstraints.length === 0 && s.regressions.length === 0) {
     lines.push("- _none yet \u2014 errata is still building its model_");
@@ -29265,6 +29549,7 @@ function isolateSnapshot(s) {
     selfCiteSkips: _selfCiteSkips,
     supersessionAsks: _supersessionAsks,
     heldAsks: _heldAsks,
+    neighbourAsks: _neighbourAsks,
     pendingUpdate: _pendingUpdate,
     daemonDistress: _daemonDistress,
     reviewItems: _reviewItems,
@@ -82513,7 +82798,7 @@ init_review2();
 // src/turn.ts
 init_checkout_root();
 import { closeSync as closeSync2, existsSync as existsSync21, fstatSync, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, realpathSync as realpathSync2, statSync as statSync10 } from "node:fs";
-import { basename as basename6, delimiter, dirname as dirname14, join as join25, normalize as normalize4 } from "node:path";
+import { basename as basename6, delimiter, dirname as dirname14, join as join25, normalize as normalize5 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { createHash as createHash16 } from "node:crypto";
 function completeJsonlPrefix(buf) {
@@ -82956,7 +83241,7 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
 }
 function splitPathList(value, sep7 = delimiter) {
   if (!value) return [];
-  return value.split(sep7).map((d) => d.trim()).filter(Boolean).map((d) => normalize4(d));
+  return value.split(sep7).map((d) => d.trim()).filter(Boolean).map((d) => normalize5(d));
 }
 function codexSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
@@ -84569,6 +84854,92 @@ var SupersessionAsks = class {
   }
 };
 
+// src/neighbour-asks.ts
+init_src4();
+var NEIGHBOUR_ASK_MAX = 3;
+var NEIGHBOUR_ASK_TTL_MS = 30 * 6e4;
+var NEIGHBOUR_SCAN_CAP = 400;
+var NEIGHBOUR_MIN_SHARED_TERMS = 1;
+var NEIGHBOUR_TERM_DF_SHARE = 0.03;
+var TERM_MIN_LENGTH = 4;
+var termsOf2 = (text) => [...new Set(text.toLowerCase().split(/[^a-z0-9_.-]+/).filter((w) => w.length >= TERM_MIN_LENGTH))];
+var RELATED = ["RELATES_TO", "INSTANCE_OF", "REGRESSION_OF", "CAUSED_BY", "CONTRADICTS"];
+function alreadyRelated(store, a, b) {
+  const types = [...RELATED];
+  return store.outEdges(a, types).some((e) => e.to === b) || store.outEdges(b, types).some((e) => e.to === a);
+}
+function nearestProblems(store, workspaceId2, problemId, statement, opts = {}) {
+  const embed2 = opts.embed ?? embedTextSync;
+  const ours = embed2(statement);
+  const bands = cosineBandsFor(ours.version);
+  const excluded = /* @__PURE__ */ new Set([problemId, ...opts.excludeIds ?? []]);
+  const candidates = store.recentOpenProblemCandidates({
+    workspaceId: workspaceId2,
+    constraint: false,
+    limit: NEIGHBOUR_SCAN_CAP,
+    excludeId: problemId
+  });
+  const df = /* @__PURE__ */ new Map();
+  for (const c of candidates) for (const w of termsOf2(c.description)) df.set(w, (df.get(w) ?? 0) + 1);
+  const dfCap = Math.max(2, candidates.length * NEIGHBOUR_TERM_DF_SHARE);
+  const mine = new Set(termsOf2(statement).filter((w) => (df.get(w) ?? 0) <= dfCap));
+  const scored = [];
+  for (const c of candidates) {
+    if (excluded.has(c.id)) continue;
+    const theirs = embed2(c.description);
+    if (theirs.version !== ours.version) continue;
+    const s = cosine(ours.vector, theirs.vector);
+    if (s < bands.relatedStrong || s >= bands.nearMiss) continue;
+    if (termsOf2(c.description).filter((w) => mine.has(w)).length < NEIGHBOUR_MIN_SHARED_TERMS) continue;
+    if (alreadyRelated(store, problemId, c.id)) continue;
+    scored.push({ id: c.id, description: c.description, cosine: s });
+  }
+  scored.sort((a, b) => b.cosine - a.cosine);
+  return scored.slice(0, opts.limit ?? NEIGHBOUR_ASK_MAX);
+}
+var NeighbourAsks = class {
+  bySession = /* @__PURE__ */ new Map();
+  /** Ask (or refresh) for a problem the session just minted. */
+  add(sessionId, problemId, neighbourIds, now = Date.now()) {
+    if (!sessionId || neighbourIds.length === 0) return;
+    const asks = (this.bySession.get(sessionId) ?? []).filter((a) => a.problemId !== problemId);
+    asks.push({ problemId, neighbourIds, askedAt: now });
+    this.bySession.set(sessionId, asks);
+  }
+  forSession(sessionId, now = Date.now()) {
+    return (this.bySession.get(sessionId) ?? []).filter((a) => now - a.askedAt < NEIGHBOUR_ASK_TTL_MS);
+  }
+  /**
+   * After a harvest: a neighbour the session cited (any prior edge, confirm or
+   * refute names it) is answered and leaves the ask; what has outlived its TTL
+   * leaves too. Returns how many shown neighbours were linked — the effect this
+   * mechanism exists for.
+   */
+  settle(sessionId, judged, now = Date.now()) {
+    const asks = this.bySession.get(sessionId);
+    if (!asks) return 0;
+    let linked = 0;
+    const next = [];
+    for (const a of asks) {
+      const remaining = a.neighbourIds.filter((id) => {
+        if (judged.has(id)) {
+          linked++;
+          return false;
+        }
+        return true;
+      });
+      if (remaining.length > 0 && now - a.askedAt < NEIGHBOUR_ASK_TTL_MS) next.push({ ...a, neighbourIds: remaining });
+    }
+    if (next.length > 0) this.bySession.set(sessionId, next);
+    else this.bySession.delete(sessionId);
+    return linked;
+  }
+  /** A cache-key fingerprint of what this session's block would show. */
+  version(sessionId, now = Date.now()) {
+    return this.forSession(sessionId, now).map((a) => `${a.problemId}:${a.neighbourIds.join(",")}`).join(";");
+  }
+};
+
 // src/held-asks.ts
 import { readFileSync as readFileSync22, renameSync as renameSync4, writeFileSync as writeFileSync16 } from "node:fs";
 import { dirname as dirname15, join as join26 } from "node:path";
@@ -89369,7 +89740,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.24-dev.5105" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.24-dev.5108" : "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;
@@ -89822,6 +90193,7 @@ function createWorkspaceEngine(opts) {
   const sessionRenders = /* @__PURE__ */ new Map();
   const selfCiteSkipsBySession = /* @__PURE__ */ new Map();
   const supersessionAsks = new SupersessionAsks();
+  const neighbourAsks = new NeighbourAsks();
   const heldAsks = loadHeldAsks(heldAsksPath(paths.configDir));
   const releaseHeld = (all, t) => {
     const released = all.filter((r) => store.getNode(r.witness.nodeId)?.validTo == null);
@@ -89918,6 +90290,29 @@ function createWorkspaceEngine(opts) {
     const priors = a.priorIds.map((id) => store.getNode(id)).filter((n) => n !== null && n.validTo == null).map((n) => ({ id: n.id, description: n.description, ...lifecycleField(n) }));
     return fix && priors.length > 0 ? [{ fix: { id: fix.id, description: fix.description }, priors }] : [];
   });
+  const neighbourAsksFor = (sessionId) => neighbourAsks.forSession(sessionId).flatMap((a) => {
+    const problem = store.getNode(a.problemId);
+    if (!problem || problem.validTo != null || problem.attrs["resolvedAt"] != null) return [];
+    const neighbours = a.neighbourIds.map((id) => store.getNode(id)).filter((n) => n !== null && n.validTo == null).map((n) => ({ id: n.id, description: n.description, ...lifecycleField(n) }));
+    return neighbours.length > 0 ? [{ problem: { id: problem.id, description: problem.description }, neighbours }] : [];
+  });
+  const askNeighbours = (sessionId, problemId, statement, t) => {
+    if (!sessionId) return false;
+    try {
+      const node2 = store.getNode(problemId);
+      const foldTarget = node2?.attrs["foldCandidate"]?.targetId;
+      const near = nearestProblems(store, profile.id, problemId, statement, {
+        ...foldTarget ? { excludeIds: [foldTarget] } : {}
+      });
+      if (near.length === 0) return false;
+      neighbourAsks.add(sessionId, problemId, near.map((n) => n.id), t);
+      if (node2) store.updateNode(problemId, { attrs: { ...node2.attrs, neighbourAskedAt: t }, lastUpdatedAt: t });
+      return true;
+    } catch (err2) {
+      console.warn("[errata] neighbour ask skipped:", err2 instanceof Error ? err2.message : err2);
+      return false;
+    }
+  };
   const heldAsksFor = (sessionId) => {
     const shown = [];
     let discarded = false;
@@ -90402,6 +90797,7 @@ function createWorkspaceEngine(opts) {
     const key = JSON.stringify([
       supersessionAsks.version(sessionId),
       heldAsks.version(sessionId),
+      neighbourAsks.version(sessionId),
       subagentBaseVersion,
       lastRemoteAt,
       sessions.version(now),
@@ -90428,6 +90824,9 @@ function createWorkspaceEngine(opts) {
     delete scoped.heldAsks;
     const held = heldAsksFor(sessionId);
     if (held.length > 0) scoped.heldAsks = held;
+    delete scoped.neighbourAsks;
+    const near = neighbourAsksFor(sessionId);
+    if (near.length > 0) scoped.neighbourAsks = near;
     if (taskPriorsOn) {
       scoped.recentProblems = [];
       scoped.recentResolved = [];
@@ -90576,6 +90975,8 @@ function createWorkspaceEngine(opts) {
     let confirmsStamped = 0;
     let supersessionAsked = 0;
     let structureLinksMinted = 0;
+    let neighbourAsked = 0;
+    let neighbourLinksMinted = 0;
     let heldAsked = 0;
     let heldAnswered = 0;
     let recurrencesMarked = 0;
@@ -90676,6 +91077,7 @@ function createWorkspaceEngine(opts) {
             }
           }
           if (flag.kind !== "constraint") sessionLastProblem.set(sessionId, designProblemId(flag.problem));
+          if (r.created && flag.kind !== "constraint" && !replay2 && askNeighbours(sessionId, r.problemId, flag.problem, t)) neighbourAsked++;
           if (r.created || r.corroborated) {
             try {
               if (editedTurnFile) {
@@ -90972,6 +91374,7 @@ function createWorkspaceEngine(opts) {
           if (!r.rejected && r.problemId) {
             findingIds.set(p.statement, r.problemId);
             if (p.threadId) threads.set(p.threadId, r.problemId);
+            if (r.created && p.kind !== "constraint" && !replay2 && askNeighbours(sessionId, r.problemId, p.statement, t)) neighbourAsked++;
           }
           if (r.created && dedupPath && !replay2) {
             try {
@@ -91316,15 +91719,14 @@ function createWorkspaceEngine(opts) {
             structureLinksMinted++;
           }
         }
-        supersessionAsks.settle(
-          sessionId,
-          /* @__PURE__ */ new Set([
-            ...plan.solutionLinks.flatMap((sl) => sl.targetIds),
-            ...plan.corroborations.map((c) => c.nodeId),
-            ...withheldLeanIds,
-            ...plan.refutes.map((r) => r.nodeId)
-          ])
-        );
+        const judgedPriorIds = /* @__PURE__ */ new Set([
+          ...plan.solutionLinks.flatMap((sl) => sl.targetIds),
+          ...plan.corroborations.map((c) => c.nodeId),
+          ...withheldLeanIds,
+          ...plan.refutes.map((r) => r.nodeId)
+        ]);
+        supersessionAsks.settle(sessionId, judgedPriorIds);
+        neighbourLinksMinted += neighbourAsks.settle(sessionId, judgedPriorIds);
         const citingSession = sessionOriginKey(sessionId);
         const mintedHere = (nodeId) => store.getNode(nodeId)?.attrs["sources"]?.[0] === sessionId;
         const synthetic = sessions.originOf(sessionId) !== void 0;
@@ -91535,6 +91937,9 @@ function createWorkspaceEngine(opts) {
         confirmsStamped,
         supersessionAsked,
         structureLinksMinted,
+        // MEL-203: new problems shown their neighbours / neighbours the agent then linked.
+        neighbourAsked,
+        neighbourLinksMinted,
         heldAsked,
         heldAnswered,
         // RG-recognize tier A: resolved problems the door saw recur this pass.

package/package.json

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

package/pass-worker.mjs

@@ -26836,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);
@@ -30299,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) {
@@ -30324,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) ?? [];
@@ -30469,6 +30717,21 @@ var MECHANISMS = [
     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.24-dev.5105",
+  "version": "2.0.24-dev.5108",
   "description": "A minimal 3D view of loaded Errata priors and recent graph bursts.",
   "author": {
     "name": "inErrata"

package/resources/context-plugin/SHA256SUMS

@@ -1,4 +1,4 @@
-65ef21d093ccff4f2ae34ab42cad7e42471cbea231b89d529258b2a52dd7a3ab  .codex-plugin/plugin.json
+b248356a755620b6bea5fe049e927e82c6c0a30314cca9faf131c06d117fa53a  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 80431e822def1ed5f5376ff0e67af30b4d26829572982e08fe24f438838f134c  dist/client.js