@inerrata-corporation/errata 2.0.21-dev.3975 → 2.0.21-dev.3996

package/package.json

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

package/pass-worker.mjs

@@ -16639,7 +16639,7 @@ function hasForkedDrift(currentHex, birthHex, maxSimRatio = DRIFT_FORK_RATIO) {
   if (!currentHex || !birthHex) return false;
   return simRatio(fromHex(currentHex), fromHex(birthHex)) < maxSimRatio;
 }
-function jaccard(a, b) {
+function jaccard2(a, b) {
   if (a.size === 0 && b.size === 0) return 0;
   let inter = 0;
   for (const x of a) if (b.has(x)) inter++;
@@ -16673,7 +16673,7 @@ function score(a, b) {
   weighted += body2 * WEIGHTS.body;
   total += WEIGHTS.body;
   if (a.callees.size > 0 || b.callees.size > 0) {
-    const topo = jaccard(a.callees, b.callees);
+    const topo = jaccard2(a.callees, b.callees);
     evidence["topology"] = round(topo);
     weighted += topo * WEIGHTS.topology;
     total += WEIGHTS.topology;
@@ -25728,6 +25728,26 @@ function detectCommunitiesLeiden(input, opts = {}) {
   return normalize(assignment);
 }
 
+// ../../packages/math/src/community-floor.ts
+var COMMUNITY_MIN_SIZE = 2;
+var COMMUNITY_FLOOR_SCALE = 0.5;
+function communitySizeFloor(domainSize) {
+  if (!(domainSize > 1)) return COMMUNITY_MIN_SIZE;
+  return Math.max(COMMUNITY_MIN_SIZE, Math.ceil(COMMUNITY_FLOOR_SCALE * Math.log(domainSize)));
+}
+function communityDomain(memberDomains, domainSize) {
+  const held = /* @__PURE__ */ new Map();
+  for (const domains of memberDomains) for (const d of new Set(domains)) held.set(d, (held.get(d) ?? 0) + 1);
+  let best = null;
+  for (const [d, n] of held) {
+    if (n * 2 < memberDomains.length) continue;
+    const size = domainSize.get(d) ?? Infinity;
+    const bestSize = best === null ? Infinity : domainSize.get(best) ?? Infinity;
+    if (best === null || size < bestSize || size === bestSize && d < best) best = d;
+  }
+  return best;
+}
+
 // ../../packages/math/src/void-demand.ts
 var DEMAND_HOT = Math.log1p(10);
 var DEMAND_WARM = Math.log1p(5);
@@ -25777,8 +25797,10 @@ function a2MotifQuality(input) {
 // ../../packages/math/src/motif-gate.ts
 var MOTIF_MIN_MEMBERS = 5;
 var MOTIF_MIN_SURVIVED = 2;
+var MOTIF_MIN_COHERENCE = 0.5;
 function motifDecision(input) {
-  if (input.memberCount < MOTIF_MIN_MEMBERS) {
+  const isIncoherent = input.coherence !== void 0 && input.coherence < MOTIF_MIN_COHERENCE;
+  if (input.memberCount < MOTIF_MIN_MEMBERS || isIncoherent) {
     return {
       isCandidate: false,
       survivedRuns: input.priorSurvivedRuns,
@@ -28300,6 +28322,137 @@ var DRIFT_VALUES = new Set(Object.values(DRIFT_KIND));
 
 // ../../packages/local-graph/src/community.ts
 init_src2();
+var JOINT_COMMUNITY_LABELS = [
+  "Problem",
+  "Vulnerability",
+  "Solution",
+  "RootCause",
+  "Pattern"
+];
+var JOINT_COMMUNITY_EDGES = [
+  "CAUSED_BY",
+  "SOLVED_BY",
+  "FIXED_BY",
+  "CONTRADICTS",
+  "INSTANCE_OF",
+  "MATCHES",
+  "IMPLEMENTS",
+  "TRIAGED_BY",
+  "INDICATES",
+  "CONFIRMS",
+  "RELATES_TO"
+];
+var DOMAIN_EDGES = ["DEPENDS_ON", "CONCERNS", "OCCURS_IN"];
+var DOMAIN_INHERIT_EDGES = ["CAUSED_BY", "SOLVED_BY", "FIXED_BY"];
+function domainKey(id) {
+  return id.replace(/(.)@[^@/]*$/, "$1");
+}
+function candidateDomains(store2, ids, labelOf) {
+  const own = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const label = labelOf.get(id);
+    if (label !== "Problem" && label !== "Vulnerability") continue;
+    const domains = store2.outEdges(id, DOMAIN_EDGES).map((e) => domainKey(e.to));
+    if (domains.length > 0) own.set(id, domains);
+  }
+  const out2 = new Map(own);
+  for (const id of ids) {
+    const label = labelOf.get(id);
+    if (label !== "RootCause" && label !== "Solution") continue;
+    const inherited = store2.inEdges(id, DOMAIN_INHERIT_EDGES).flatMap((e) => own.get(e.from) ?? []);
+    if (inherited.length > 0) out2.set(id, [...new Set(inherited)]);
+  }
+  return out2;
+}
+function detectLocalCommunities(store2, opts = {}) {
+  const report = { candidates: 0, communities: 0, joint: 0, assigned: 0, belowFloor: 0, cleared: 0 };
+  const nodes = /* @__PURE__ */ new Map();
+  const unowned = [];
+  for (const label of JOINT_COMMUNITY_LABELS) {
+    for (const n of store2.findNodesByLabel(label)) {
+      if (n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) unowned.push(n);
+      else nodes.set(n.id, n);
+    }
+  }
+  const ids = new Set(nodes.keys());
+  report.candidates = ids.size;
+  for (const label of SEMANTIC_NODE_LABELS) {
+    if (!JOINT_COMMUNITY_LABELS.includes(label)) unowned.push(...store2.findNodesByLabel(label));
+  }
+  store2.transaction(() => {
+    for (const n of unowned) {
+      if (n.attrs["localCommunity"] !== void 0) {
+        const { localCommunity: _gone, ...rest } = n.attrs;
+        store2.updateNode(n.id, { attrs: rest });
+      }
+      if (!n.community || n.attrs["source"] === "cloud") continue;
+      store2.setCommunity(n.id, null);
+      report.cleared++;
+    }
+  });
+  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 members = /* @__PURE__ */ new Map();
+  for (const [id, c] of comm.community) {
+    const l = members.get(c) ?? [];
+    l.push(id);
+    members.set(c, l);
+  }
+  const domains = candidateDomains(store2, ids, new Map([...nodes].map(([id, n]) => [id, n.label])));
+  const domainSize = /* @__PURE__ */ new Map();
+  for (const ds of domains.values()) for (const d of new Set(ds)) domainSize.set(d, (domainSize.get(d) ?? 0) + 1);
+  const floorOf = (mem) => {
+    if (opts.minCommunitySize !== void 0) return opts.minCommunitySize;
+    const domain2 = communityDomain(mem.map((id) => domains.get(id) ?? []), domainSize);
+    return communitySizeFloor(domain2 === null ? ids.size : domainSize.get(domain2));
+  };
+  store2.transaction(() => {
+    for (const [cid, mem] of members) {
+      const qualifies = mem.length >= floorOf(mem);
+      if (!qualifies && mem.length >= 2) report.belowFloor++;
+      let hasLocal = false;
+      let hasCloud = false;
+      for (const id of mem) {
+        const n = nodes.get(id);
+        const pulled = n.attrs["source"] === "cloud";
+        if (pulled) hasCloud = true;
+        else hasLocal = true;
+        const want = qualifies ? cid : void 0;
+        if (n.attrs["localCommunity"] !== want) {
+          const nextAttrs = { ...n.attrs };
+          if (want) nextAttrs["localCommunity"] = want;
+          else delete nextAttrs["localCommunity"];
+          store2.updateNode(id, { attrs: nextAttrs });
+        }
+        if (!pulled && (n.community ?? null) !== (want ?? null)) store2.setCommunity(id, want ?? null);
+      }
+      if (qualifies) {
+        report.communities++;
+        report.assigned += mem.length;
+        if (hasLocal && hasCloud) report.joint++;
+      }
+    }
+  });
+  return report;
+}
 
 // ../../packages/local-graph/src/tools.ts
 init_src();
@@ -28707,14 +28860,16 @@ init_src2();
 init_src2();
 init_src();
 var MEMBER_LABELS = ["Problem", "RootCause", "Solution"];
+var MOTIF_LABELS = ["Pattern", "Technique", "AntiPattern"];
+var LINEAGE_MIN_JACCARD = 0.5;
 function layerOf(kind) {
   return kind === "Technique" ? "technique" : kind === "AntiPattern" ? "antipattern" : "pattern";
 }
-function motifTitle(members, layer, instanceCount) {
-  const top = [...members].sort(
-    (a, b) => b.extractionConfidence - a.extractionConfidence
-  )[0];
-  return `${layer} \xD7${instanceCount} (exemplar): ${top?.description ?? "recurring problem cluster"}`;
+function motifTitle(exemplar, layer, instanceCount) {
+  return `${layer} \xD7${instanceCount} (exemplar): ${exemplar?.description ?? "recurring problem cluster"}`;
+}
+function exemplarOf(members) {
+  return [...members].sort((a, b) => b.extractionConfidence - a.extractionConfidence || a.id.localeCompare(b.id))[0];
 }
 function classifyMotif(store2, instances, promoted) {
   if (!promoted || instances.length === 0) return "Pattern";
@@ -28723,70 +28878,141 @@ function classifyMotif(store2, instances, promoted) {
   if (solvedShare <= 0.2) return "AntiPattern";
   return "Pattern";
 }
+function isDerived(e) {
+  return e.extractionSource === "bko-inferred";
+}
+function motifCoherence(store2, members, instances) {
+  if (instances.length === 0) return 0;
+  const types = [...JOINT_COMMUNITY_EDGES];
+  const near = /* @__PURE__ */ new Map();
+  const link = (a, b) => {
+    const s = near.get(a) ?? /* @__PURE__ */ new Set();
+    s.add(b);
+    near.set(a, s);
+  };
+  for (const id of members) {
+    for (const e of store2.outEdges(id, types)) {
+      if (!members.has(e.to) || isDerived(e)) continue;
+      link(id, e.to);
+      link(e.to, id);
+    }
+  }
+  const isInstance = new Set(instances);
+  let bound = 0;
+  for (const p of instances) {
+    const hop1 = near.get(p) ?? /* @__PURE__ */ new Set();
+    const reached = [...hop1, ...[...hop1].flatMap((x) => [...near.get(x) ?? []])];
+    if (reached.some((q) => q !== p && isInstance.has(q))) bound++;
+  }
+  return bound / instances.length;
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let both = 0;
+  for (const x of a) if (b.has(x)) both++;
+  return both / (a.size + b.size - both);
+}
 function promoteMotifs(store2, t) {
+  const report = { communities: 0, candidates: 0, incoherent: 0, promoted: 0, techniques: 0, antipatterns: 0, retracted: 0, retired: 0 };
   const byCommunity = /* @__PURE__ */ new Map();
   for (const label of MEMBER_LABELS) {
     for (const n of store2.findNodesByLabel(label)) {
       if (n.label === "Problem" && n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) continue;
-      const c = n.community;
-      if (!c) continue;
+      const c = n.attrs["localCommunity"];
+      if (typeof c !== "string") continue;
       const g = byCommunity.get(c) ?? [];
       g.push(n);
       byCommunity.set(c, g);
     }
   }
-  let candidates = 0;
-  let promoted = 0;
-  let techniques = 0;
-  let antipatterns = 0;
+  report.communities = byCommunity.size;
+  const existing = /* @__PURE__ */ new Map();
+  for (const label of MOTIF_LABELS) {
+    for (const node of store2.findNodesByLabel(label)) {
+      if (!node.id.startsWith("motif_")) continue;
+      const edges = store2.inEdges(node.id, ["INSTANCE_OF"]).filter(isDerived);
+      const remembered = node.attrs["memberIds"];
+      const members = new Set(Array.isArray(remembered) ? remembered : edges.map((e) => e.from));
+      existing.set(node.id, { node, edges, members });
+    }
+  }
+  const pairs = [];
+  for (const [cid, members] of byCommunity) {
+    const instances = new Set(members.filter((m) => m.label === "Problem").map((m) => m.id));
+    for (const [motifId, m] of existing) {
+      const j = jaccard(instances, m.members);
+      if (j >= LINEAGE_MIN_JACCARD) pairs.push({ cid, motifId, j });
+    }
+  }
+  pairs.sort((a, b) => b.j - a.j || a.motifId.localeCompare(b.motifId));
+  const motifOf = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Set();
+  for (const p of pairs) {
+    if (motifOf.has(p.cid) || claimed.has(p.motifId)) continue;
+    motifOf.set(p.cid, p.motifId);
+    claimed.add(p.motifId);
+  }
+  const kept = /* @__PURE__ */ new Set();
   store2.transaction(() => {
     for (const [cid, members] of byCommunity) {
       const instances = members.filter((m) => m.label === "Problem");
       const instanceCount = instances.length || members.length;
-      const motifId = `motif_${cid}`;
-      const existing = store2.getNode(motifId);
+      const motifId = motifOf.get(cid) ?? (claimed.has(`motif_${cid}`) ? `motif_${cid}_${digest(instances.map((m) => m.id).sort()).slice(0, 8)}` : `motif_${cid}`);
+      const prior = existing.get(motifId);
+      const coherence = motifCoherence(store2, new Set(members.map((m) => m.id)), instances.map((m) => m.id));
       const d = motifDecision({
-        instances: members.map((m) => ({
-          confidence: m.extractionConfidence,
-          failed: false
-        })),
+        instances: members.map((m) => ({ confidence: m.extractionConfidence, failed: false })),
         memberCount: members.length,
         instanceCount,
-        priorSurvivedRuns: existing?.attrs["survivedRuns"] ?? 0
+        priorSurvivedRuns: prior?.node.attrs["survivedRuns"] ?? 0,
+        coherence
       });
-      if (!d.isCandidate) continue;
-      candidates++;
+      if (!d.isCandidate) {
+        if (members.length >= 5) report.incoherent++;
+        continue;
+      }
+      report.candidates++;
+      kept.add(motifId);
       const kind = classifyMotif(store2, instances, d.promoted);
+      const exemplar = exemplarOf(members);
       const motif = {
         id: motifId,
         label: kind,
         // Refresh the deterministic title every run (exemplar/count/kind drift),
         // but never clobber a distilled one — a distillation pass owns it then.
-        description: existing?.attrs["titleDistilled"] === true ? existing.description : motifTitle(members, layerOf(kind), instanceCount),
+        description: prior?.node.attrs["titleDistilled"] === true ? prior.node.description : motifTitle(exemplar, layerOf(kind), instanceCount),
         extractionConfidence: d.motifConfidence,
         extractionSource: "bko-inferred",
-        embedding: existing?.embedding ?? [],
-        cumulativeSurprise: existing?.cumulativeSurprise ?? 0,
-        peakSurprise: existing?.peakSurprise ?? 0,
+        embedding: prior?.node.embedding ?? [],
+        cumulativeSurprise: prior?.node.cumulativeSurprise ?? 0,
+        peakSurprise: prior?.node.peakSurprise ?? 0,
         cumulativeHits: instanceCount,
         lastUpdatedAt: t,
-        createdAt: existing?.createdAt ?? t,
-        memoryTier: existing?.memoryTier ?? "short-term",
-        pageRank: existing?.pageRank ?? 0,
+        createdAt: prior?.node.createdAt ?? t,
+        memoryTier: prior?.node.memoryTier ?? "short-term",
+        pageRank: prior?.node.pageRank ?? 0,
         isLandmark: d.promoted,
-        community: cid,
+        // The community column belongs to the joint pass alone; a motif names
+        // its community in attrs.communityId.
+        community: null,
         stability: d.stable ? "stable" : "forming",
         attrs: {
+          ...prior?.node.attrs ?? {},
           layer: layerOf(kind),
           communityId: cid,
           survivedRuns: d.survivedRuns,
           motifConfidence: d.motifConfidence,
           memberCount: members.length,
           instanceCount,
+          coherence: Math.round(coherence * 100) / 100,
+          memberIds: instances.map((m) => m.id),
+          ...exemplar ? { exemplarId: exemplar.id } : {},
+          missedRuns: 0,
           promoted: d.promoted
         }
       };
       store2.mergeNode(motif);
+      const now = new Set(instances.map((m) => m.id));
       for (const m of instances) {
         store2.mergeEdge({
           id: `edge_${digest({ from: m.id, type: "INSTANCE_OF", to: motifId })}`.slice(0, 24),
@@ -28802,12 +29028,33 @@ function promoteMotifs(store2, t) {
           attrs: {}
         });
       }
-      if (d.promoted) promoted++;
-      if (kind === "Technique") techniques++;
-      if (kind === "AntiPattern") antipatterns++;
+      for (const e of prior?.edges ?? []) {
+        if (now.has(e.from)) continue;
+        store2.closeEdge(e.id, t);
+        report.retracted++;
+      }
+      if (d.promoted) report.promoted++;
+      if (kind === "Technique") report.techniques++;
+      if (kind === "AntiPattern") report.antipatterns++;
+    }
+    for (const [motifId, m] of existing) {
+      if (kept.has(motifId)) continue;
+      for (const e of m.edges) {
+        store2.closeEdge(e.id, t);
+        report.retracted++;
+      }
+      const missedRuns = (m.node.attrs["missedRuns"] ?? 0) + 1;
+      const evidenced = store2.inEdges(motifId, ["INSTANCE_OF"]).some((e) => !isDerived(e));
+      if (missedRuns >= MOTIF_MIN_SURVIVED && !evidenced) {
+        for (const e of [...store2.outEdges(motifId), ...store2.inEdges(motifId)]) store2.closeEdge(e.id, t);
+        store2.closeNode(motifId, t);
+        report.retired++;
+      } else {
+        store2.updateNode(motifId, { attrs: { ...m.node.attrs, missedRuns, promoted: false } });
+      }
     }
   });
-  return { communities: byCommunity.size, candidates, promoted, techniques, antipatterns };
+  return report;
 }
 
 // ../../packages/generalizer/src/nightly.ts
@@ -29025,44 +29272,14 @@ function runFullRescore(store2) {
       landmarkFlips++;
     }
   });
-  const MOTIF_LABELS = /* @__PURE__ */ new Set(["Pattern", "Technique", "AntiPattern"]);
-  const semanticIds = /* @__PURE__ */ new Set();
-  for (const label of SEMANTIC_NODE_LABELS) {
-    if (MOTIF_LABELS.has(label)) continue;
-    for (const n of store2.findNodesByLabel(label)) semanticIds.add(n.id);
-  }
-  const semAdj = /* @__PURE__ */ new Map();
-  const protect = [];
-  const addAdj = (a, b, w) => {
-    const l = semAdj.get(a) ?? [];
-    l.push({ to: b, weight: w });
-    semAdj.set(a, l);
-  };
-  for (const id of semanticIds) {
-    for (const e of store2.outEdges(id)) {
-      if (!semanticIds.has(e.to)) continue;
-      const conf = e.confidence > 0 ? e.confidence : 0.5;
-      const w = Math.max(EDGE_WEIGHT[e.type] ?? 1, 0.1) * conf;
-      addAdj(id, e.to, w);
-      addAdj(e.to, id, w);
-      if (isCausalProtected(e.type)) protect.push([id, e.to]);
-    }
-  }
-  for (const { a, b, weight } of codeAnchorProjection(store2, semanticIds)) {
-    addAdj(a, b, weight);
-    addAdj(b, a, weight);
-  }
-  const comm = detectCommunitiesLeiden({ nodeIds: [...semanticIds], adj: semAdj }, { protect });
-  store2.transaction(() => {
-    for (const [id, c] of comm.community) store2.updateNode(id, { community: c });
-  });
+  const lc = detectLocalCommunities(store2);
   const motifs = promoteMotifs(store2, started);
   return {
     scoredNodes: scored,
     iterations: result.iterations,
     converged: result.converged,
     landmarks: allLandmarks.size,
-    communities: comm.count,
+    communities: lc.communities,
     motifsPromoted: motifs.promoted,
     techniques: motifs.techniques,
     antipatterns: motifs.antipatterns,
@@ -29121,28 +29338,6 @@ function runNightlyPipeline(store2) {
     durationMs: Date.now() - started
   };
 }
-function codeAnchorProjection(store2, semanticIds, opts = {}) {
-  const anchorToNodes = /* @__PURE__ */ new Map();
-  for (const id of semanticIds) {
-    for (const e of store2.outEdges(id, ["ANCHORED_AT"])) {
-      if (semanticIds.has(e.to)) continue;
-      const l = anchorToNodes.get(e.to) ?? [];
-      l.push(id);
-      anchorToNodes.set(e.to, l);
-    }
-  }
-  const hubCap = opts.hubCap ?? Math.max(8, Math.floor(semanticIds.size * 0.03));
-  const base = opts.weight ?? 1;
-  const out2 = [];
-  for (const nodes of anchorToNodes.values()) {
-    if (nodes.length < 2 || nodes.length > hubCap) continue;
-    const w = base / Math.log2(nodes.length + 1);
-    for (let i2 = 0; i2 < nodes.length; i2++) {
-      for (let j = i2 + 1; j < nodes.length; j++) out2.push({ a: nodes[i2], b: nodes[j], weight: w });
-    }
-  }
-  return out2;
-}
 
 // ../../packages/generalizer/src/embed-code.ts
 init_src();
@@ -29151,6 +29346,9 @@ init_src();
 init_src();
 var BURST_ANCHORED_AT_CONDUCTANCE = 1 / 3;
 
+// ../../packages/generalizer/src/motif-signal.ts
+var KNOWLEDGE_EDGES = [...JOINT_COMMUNITY_EDGES, "MAY_RESOLVE", "REGRESSION_OF", "BUILDS_ON"];
+
 // ../../packages/context-writer/src/agents-md.ts
 init_src();
 
@@ -29176,6 +29374,12 @@ var AGENTS_POINTER_BODY = [
 // ../../packages/context-writer/src/render.ts
 init_src2();
 init_src();
+var MOTIF_BAND = 10;
+var MOTIF_POOL = 1e3;
+function rankMotifs(pool, signal, k = MOTIF_BAND) {
+  if (!signal) return pool.slice(0, k);
+  return pool.filter((m) => (signal.get(m.id) ?? 0) > 0).sort((a, b) => signal.get(b.id) - signal.get(a.id) || b.pageRank - a.pageRank).slice(0, k);
+}
 function buildSnapshot(opts) {
   const problems = [...opts.store.findNodesByLabel("Problem"), ...opts.store.findNodesByLabel("Vulnerability")].filter((p) => p.attrs["mergedInto"] === void 0 && historyReadPolicy(p, { mode: "passive", atCommit: opts.atCommit }).allow);
   const stillOpen = problems.filter((p) => p.attrs["resolvedAt"] == null);
@@ -29206,11 +29410,12 @@ function buildSnapshot(opts) {
     return { node: p, ...solution ? { solution } : {} };
   });
   const recentResolved = resolvedPool.slice(0, RECENT_RESOLVED);
-  const motifs = [
+  const motifPool = [
     ...opts.store.findNodesByLabel("Pattern"),
     ...opts.store.findNodesByLabel("Technique"),
     ...opts.store.findNodesByLabel("AntiPattern")
-  ].filter((n) => historyReadPolicy(n, { mode: "passive", atCommit: opts.atCommit }).allow).sort((a, b) => b.pageRank - a.pageRank).slice(0, 10);
+  ].filter((n) => historyReadPolicy(n, { mode: "passive", atCommit: opts.atCommit }).allow).filter((n) => !(Number(n.attrs["missedRuns"] ?? 0) > 0)).sort((a, b) => b.pageRank - a.pageRank).slice(0, MOTIF_POOL).map((n) => n.embedding.length > 0 ? { ...n, embedding: [] } : n);
+  const motifs = rankMotifs(motifPool, void 0);
   const workingFile = opts.workingFile ? sliceForFile(opts.store, opts.workingFile, opts.atCommit) : void 0;
   const byEpisode = /* @__PURE__ */ new Map();
   for (const sol of opts.store.findNodesByLabel("Solution")) {
@@ -29277,6 +29482,7 @@ function buildSnapshot(opts) {
     ...opts.selfCiteSkips && opts.selfCiteSkips > 0 ? { selfCiteSkips: opts.selfCiteSkips } : {},
     ...domainNudge ? { domainNudge } : {},
     motifs,
+    motifPool,
     reviewCount: opts.reviewCount,
     reviewUiUrl: opts.reviewUiUrl,
     ...workingFile ? { workingFile } : {},

package/resources/claude-mods/errata-minimap/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "errata-minimap",
-  "version": "0.1.0",
+  "version": "0.3.1",
   "author": { "name": "inErrata", "url": "https://inerrata.ai" },
-  "description": "Side pane: an errata graph minimap of the latest burst neighborhood that entered the agent's context.",
+  "description": "The errata library: the causal chains of the latest burst that entered the agent's context, in bookcases by technology with a catalog card — and errata's inline tags, tidied in the chat.",
   "types": "./types/index.d.ts"
 }