@inerrata-corporation/errata 2.0.0-dev.30 → 2.0.0-dev.32

package/errata.mjs

@@ -20,16 +20,51 @@ function pagerankEdgeTypes() {
     (e) => !PAGERANK_EXCLUSIONS.has(e)
   );
 }
+function isInferredSource(source) {
+  return source === "bko-inferred" || source === "cold-start-seed";
+}
+function normalizeExtractionSource(value) {
+  switch (value) {
+    case "agent-observed":
+    case "daemon-extracted":
+    case "bko-inferred":
+    case "cold-start-seed":
+    case "user-edited":
+      return value;
+    default:
+      return "cold-start-seed";
+  }
+}
+function isSemanticLabel(label) {
+  return SEMANTIC_NODE_LABELS.includes(label);
+}
 function isCodeLabel(label) {
   return CODE_NODE_LABELS.includes(label);
 }
+function isContextLabel(label) {
+  return CONTEXT_NODE_LABELS.includes(label);
+}
+function isValidEdgeType(type) {
+  return ALL_EDGE_TYPES.includes(type);
+}
 function isTestRelPath(relPath) {
   return TEST_PATH_RE.test(relPath);
 }
 function isTestScopeQname(qname) {
   return TEST_SCOPE_RE.test(qname);
 }
-var SEMANTIC_NODE_LABELS, CONTEXT_NODE_LABELS, CODE_NODE_LABELS, ALL_NODE_LABELS, STRUCTURAL_EDGES, CAUSAL_EDGES, RESOLUTION_EDGES, CONCEPTUAL_EDGES, EVIDENCE_EDGES, CODE_EDGES, BRIDGE_EDGES, IDENTITY_EDGES, JUSTIFICATION_EDGES, BELIEF_EDGES, ABSTRACTION_EDGES, DECOMPOSITION_EDGES, TAXONOMY_EDGES, TRIAGE_EDGES, GIT_EDGES, ALL_EDGE_TYPES, PAGERANK_EXCLUSIONS, EDGE_WEIGHT, CAUSAL_PROTECT_EDGES, VALIDATION_SOURCES, ABSTRACTION_LEVEL, PROBLEM_RESOLUTION, DRIFT_KIND, TEST_PATH_RE, TEST_SCOPE_RE;
+function toCloudAttrs(attrs) {
+  const rest2 = { ...attrs };
+  delete rest2["confidence"];
+  const scope = rest2["scope"];
+  if (scope && typeof scope === "object" && !Array.isArray(scope)) {
+    const scopeCopy = { ...scope };
+    delete scopeCopy["codebase"];
+    rest2["scope"] = scopeCopy;
+  }
+  return rest2;
+}
+var SEMANTIC_NODE_LABELS, CONTEXT_NODE_LABELS, CODE_NODE_LABELS, ALL_NODE_LABELS, STRUCTURAL_EDGES, CAUSAL_EDGES, RESOLUTION_EDGES, CONCEPTUAL_EDGES, EVIDENCE_EDGES, CODE_EDGES, BRIDGE_EDGES, IDENTITY_EDGES, JUSTIFICATION_EDGES, BELIEF_EDGES, ABSTRACTION_EDGES, DECOMPOSITION_EDGES, TRANSFER_EDGES, TAXONOMY_EDGES, TRIAGE_EDGES, GIT_EDGES, ALL_EDGE_TYPES, PAGERANK_EXCLUSIONS, EDGE_WEIGHT, CAUSAL_PROTECT_EDGES, VALIDATION_SOURCES, TRUTH_KIND, ABSTRACTION_LEVEL, PROBLEM_RESOLUTION, DRIFT_KIND, TEST_PATH_RE, TEST_SCOPE_RE;
 var init_castalia = __esm({
   "../../packages/shared/src/castalia.ts"() {
     "use strict";
@@ -179,6 +214,7 @@ var init_castalia = __esm({
     BELIEF_EDGES = ["CORROBORATES"];
     ABSTRACTION_EDGES = ["GENERALIZES", "DERIVED_FROM"];
     DECOMPOSITION_EDGES = ["SPLIT_INTO"];
+    TRANSFER_EDGES = ["MAY_RESOLVE"];
     TAXONOMY_EDGES = ["IS_A"];
     TRIAGE_EDGES = ["TRIAGED_BY", "CONFIRMS", "INDICATES", "ROUTES_TO"];
     GIT_EDGES = ["POINTS_AT", "PARENT", "AUTHORED_BY"];
@@ -193,6 +229,7 @@ var init_castalia = __esm({
       ...IDENTITY_EDGES,
       ...JUSTIFICATION_EDGES,
       ...BELIEF_EDGES,
+      ...TRANSFER_EDGES,
       ...ABSTRACTION_EDGES,
       ...DECOMPOSITION_EDGES,
       ...TAXONOMY_EDGES,
@@ -319,6 +356,10 @@ var init_castalia = __esm({
       INDICATES: 0.4,
       ROUTES_TO: 1,
       TRIAGED_BY: 0,
+      // Transfer — a witnessed could-aid hypothesis (Solution → Problem). Discounted like
+      // INDICATES: real signal, but a candidate must not form a hub; promotion mints the
+      // full-weight SOLVED_BY/MITIGATES instead of upgrading this edge.
+      MAY_RESOLVE: 0.3,
       // Git — topology/authorship, weightless (not domain signal-flow)
       POINTS_AT: 0,
       PARENT: 0,
@@ -331,6 +372,11 @@ var init_castalia = __esm({
       "agent-observed",
       "machine-derived"
     ];
+    TRUTH_KIND = {
+      OBJECTIVE: "objective",
+      CONTEXTUAL: "contextual",
+      TASTE: "taste"
+    };
     ABSTRACTION_LEVEL = { CONCRETE: 1, PRINCIPLE: 2 };
     PROBLEM_RESOLUTION = {
       FIXED: "fixed",
@@ -478,6 +524,9 @@ function canonicalizeError(raw2) {
   const sig = { ...canonical, digest: digest(canonical) };
   return sig;
 }
+function errorSignatureEqual(a, b) {
+  return a.digest === b.digest;
+}
 function problemIdFromError(sig) {
   return `prob_${sha256(sig.digest).slice(0, 16)}`;
 }
@@ -498,6 +547,9 @@ function resolveCanonical(label) {
 function resolveCanonicalId(label) {
   return resolveCanonical(label)?.id;
 }
+function allEntities() {
+  return REGISTRY;
+}
 function aliasesLongestFirst() {
   const out2 = [];
   for (const e of REGISTRY) for (const a of e.aliases) out2.push({ alias: a.toLowerCase(), entity: e });
@@ -796,6 +848,26 @@ function genericCanonicalId(prefix, content) {
 function languageCanonicalId(name2) {
   return genericCanonicalId("Language", { name: name2.trim().toLowerCase() });
 }
+function packageCanonicalId(p) {
+  const eco = p.ecosystem.toLowerCase();
+  const name2 = eco === "npm" ? p.name.toLowerCase() : p.name;
+  return `pkg:${eco}/${name2}${p.version ? `@${p.version}` : ""}`;
+}
+function parsePackageRef(ref) {
+  let rest2 = ref.trim();
+  if (rest2.startsWith("pkg:")) {
+    rest2 = rest2.slice(4);
+    const slash = rest2.indexOf("/");
+    if (slash !== -1) rest2 = rest2.slice(slash + 1);
+    const q = rest2.search(/[?#]/);
+    if (q !== -1) rest2 = rest2.slice(0, q);
+  }
+  const at = rest2.lastIndexOf("@");
+  const name2 = at > 0 ? rest2.slice(0, at) : rest2;
+  const version2 = at > 0 ? rest2.slice(at + 1) || null : null;
+  const slug2 = (version2 ? `${name2}@${version2}` : name2).toLowerCase();
+  return { name: name2, version: version2, slug: slug2 };
+}
 var DESIGN_PROBLEM_PREFIX, DESIGN_PROBLEM_ID_LENGTH, DIAGNOSTIC_PROBLEM_PREFIX, DIAGNOSTIC_HASH_LENGTH, TRIAGE_PREFIX, TRIAGE_ID_LENGTH;
 var init_identity = __esm({
   "../../packages/shared/src/identity.ts"() {
@@ -15128,13 +15200,113 @@ var init_zod = __esm({
 });
 
 // ../../packages/shared/src/edge-rules.ts
+function isValidEdge(from, type, to) {
+  const rule = EDGE_RULES[type];
+  if (!rule) return { ok: true };
+  if (from && rule.from && !rule.from.includes(from)) {
+    return {
+      ok: false,
+      reason: `${type} cannot originate from ${from} (allowed: ${rule.from.join(", ")})`
+    };
+  }
+  if (to && rule.to && !rule.to.includes(to)) {
+    return {
+      ok: false,
+      reason: `${type} cannot target ${to} (allowed: ${rule.to.join(", ")})`
+    };
+  }
+  return { ok: true };
+}
+var EDGE_RULES;
 var init_edge_rules = __esm({
   "../../packages/shared/src/edge-rules.ts"() {
     "use strict";
+    EDGE_RULES = {
+      // ── Security spine (v1 taxonomy.ts SECURITY_FORWARD_ONLY commentary) ──
+      TARGETS: { from: ["Exploit"], to: ["Vulnerability"] },
+      ENABLES: { from: ["AntiPattern"], to: ["Vulnerability"] },
+      MITIGATES: { from: ["Solution"], to: ["Vulnerability"] },
+      PRESENTS: { from: ["Solution"], to: ["Problem", "Vulnerability"] },
+      // SOLVED_BY sources: Vulnerability (v1 comment) + Problem/RootCause
+      // (upstream design-problem.ts + triage.ts mint both).
+      SOLVED_BY: { from: ["Vulnerability", "Problem", "RootCause"], to: ["Solution"] },
+      FIXED_BY: { to: ["Solution"] },
+      // ── Triage family (upstream castalia.ts: Problem —TRIAGED_BY→ Triage —{INDICATES|CONFIRMS}→ cause) ──
+      // Two-edge differential model (T3-rename): INDICATES = provisional candidate,
+      // CONFIRMS = promoted router (a discriminator exists). Same endpoint matrix.
+      // ROUTES_TO is the deprecated pre-split alias, kept readable during migration.
+      TRIAGED_BY: { from: ["Problem"], to: ["Triage"] },
+      CONFIRMS: { from: ["Triage"], to: ["RootCause", "Problem"] },
+      INDICATES: { from: ["Triage"], to: ["RootCause", "Problem"] },
+      ROUTES_TO: { from: ["Triage"], to: ["RootCause", "Problem"] },
+      // ── Context grounding (v1 taxonomy.ts comments) ──
+      WRITTEN_IN: { from: ["Component", "Package"], to: ["Language"] },
+      OCCURS_IN: { to: ["Language"] },
+      OCCURS_ON: { to: ["OperatingSystem"] },
+      RUNS_ON: { to: ["OperatingSystem"] },
+      OPERATES_ON: { from: ["Algorithm"], to: ["DataStructure"] },
+      INVOLVES: { from: ["Problem", "Solution"], to: ["DataStructure"] },
+      // ── Taxonomy (Track 4 Stream C: MITRE CWE `ChildOf` → `Weakness —IS_A→ Weakness`) ──
+      IS_A: { from: ["Weakness"], to: ["Weakness"] },
+      // ── Conceptual (v1 taxonomy.ts: instance → motif/pattern reference) ──
+      INSTANCE_OF: { to: ["Pattern", "Weakness", "Technique"] },
+      IMPLEMENTS: { from: ["Solution", "Language", "Component"], to: ["Pattern", "Technique"] },
+      MATCHES: { to: ["Pattern"] },
+      // ── Artifact evidence (v1 taxonomy.ts artifact rows) ──
+      PRODUCED: { from: ["Report"], to: ["Artifact"] },
+      MANIFESTED_IN: { from: ["Problem"], to: ["Artifact"] },
+      REVEALED_BY: { from: ["RootCause"], to: ["Artifact"] },
+      // ── Belief / abstraction gradients (upstream castalia.ts) ──
+      CORROBORATES: { from: ["Claim"], to: ["Claim"] },
+      GENERALIZES: { from: ["Claim"] },
+      DERIVED_FROM: { from: ["Claim"] },
+      // ── Decomposition (castalia.ts: a Problem fans out into independent root
+      // problems; §5.1 also attaches SPLIT_INTO to Claim when one conflates two).
+      // `to` left unconstrained — the replacement set's labels vary by case. ──
+      SPLIT_INTO: { from: ["Problem", "Claim"] }
+    };
   }
 });
 
 // ../../packages/shared/src/wire.ts
+function provenanceBand(source) {
+  switch (source) {
+    case "agent-observed":
+    case "user-edited":
+      return "validated";
+    case "daemon-extracted":
+    case "bko-inferred":
+      return "derived";
+    case "cold-start-seed":
+      return "seed";
+    // Unknown/absent provenance is treated as the weakest band — a node with no
+    // recorded source must never be mistaken for validated knowledge.
+    default:
+      return "seed";
+  }
+}
+function isSeedProvenance(source) {
+  return provenanceBand(source) === "seed";
+}
+function validateCastaliaPayload(p) {
+  const errors = [];
+  const labelByCid = /* @__PURE__ */ new Map();
+  for (const n of p.nodes) {
+    if (labelByCid.has(n.canonicalId)) errors.push(`duplicate node canonicalId '${n.canonicalId}'`);
+    labelByCid.set(n.canonicalId, n.label);
+  }
+  for (const e of p.edges) {
+    if (e.fromCanonicalId === e.toCanonicalId) {
+      errors.push(`self-loop edge ${e.type} on '${e.fromCanonicalId}'`);
+      continue;
+    }
+    const verdict = isValidEdge(labelByCid.get(e.fromCanonicalId), e.type, labelByCid.get(e.toCanonicalId));
+    if (!verdict.ok) {
+      errors.push(`edge ${e.fromCanonicalId} -${e.type}\u2192 ${e.toCanonicalId}: ${verdict.reason}`);
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
 function summarizeIngestResult(r) {
   const all = [...r.nodes, ...r.edges];
   const rejectedItems = all.filter((x) => x.decision === "rejected");
@@ -15145,7 +15317,7 @@ function summarizeIngestResult(r) {
     ...r.patternReconciliation ? { patternReconciliation: r.patternReconciliation } : {}
   };
 }
-var CLOUD_NODE_LABELS, CLOUD_EDGE_TYPES, INGEST_SOURCES, INGEST_EXTRACTION_SOURCES, MAX_EDGES_PER_PAYLOAD, CastaliaIngestNodeSchema, RouteContextCountWireSchema, CastaliaIngestEdgeSchema, CastaliaIngestPayloadSchema;
+var CLOUD_NODE_LABELS, CLOUD_EDGE_TYPES, INGEST_SOURCES, INGEST_EXTRACTION_SOURCES, MAX_NODES_PER_PAYLOAD, MAX_EDGES_PER_PAYLOAD, CastaliaIngestNodeSchema, RouteContextCountWireSchema, CastaliaIngestEdgeSchema, CastaliaIngestPayloadSchema;
 var init_wire = __esm({
   "../../packages/shared/src/wire.ts"() {
     "use strict";
@@ -15167,6 +15339,7 @@ var init_wire = __esm({
       "cold-start-seed",
       "user-edited"
     ];
+    MAX_NODES_PER_PAYLOAD = 200;
     MAX_EDGES_PER_PAYLOAD = 500;
     CastaliaIngestNodeSchema = external_exports.object({
       /** Deterministic content id from identity.ts — the cross-stratum merge key. */
@@ -15211,6 +15384,9 @@ var init_wire = __esm({
 });
 
 // ../../packages/shared/src/nlp/canonicalize.ts
+function canonicalize(value) {
+  return value.normalize("NFC").trim().toLowerCase().replace(/\s+/g, " ");
+}
 var init_canonicalize = __esm({
   "../../packages/shared/src/nlp/canonicalize.ts"() {
     "use strict";
@@ -15236,6 +15412,91 @@ var init_triage_canon = __esm({
 });
 
 // ../../packages/shared/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ABSTRACTION_EDGES: () => ABSTRACTION_EDGES,
+  ABSTRACTION_LEVEL: () => ABSTRACTION_LEVEL,
+  ALL_EDGE_TYPES: () => ALL_EDGE_TYPES,
+  ALL_NODE_LABELS: () => ALL_NODE_LABELS,
+  BELIEF_EDGES: () => BELIEF_EDGES,
+  BRIDGE_EDGES: () => BRIDGE_EDGES,
+  CAUSAL_EDGES: () => CAUSAL_EDGES,
+  CAUSAL_PROTECT_EDGES: () => CAUSAL_PROTECT_EDGES,
+  CLOUD_EDGE_TYPES: () => CLOUD_EDGE_TYPES,
+  CLOUD_NODE_LABELS: () => CLOUD_NODE_LABELS,
+  CODE_EDGES: () => CODE_EDGES,
+  CODE_NODE_LABELS: () => CODE_NODE_LABELS,
+  CONCEPTUAL_EDGES: () => CONCEPTUAL_EDGES,
+  CONTEXT_NODE_LABELS: () => CONTEXT_NODE_LABELS,
+  CastaliaIngestEdgeSchema: () => CastaliaIngestEdgeSchema,
+  CastaliaIngestNodeSchema: () => CastaliaIngestNodeSchema,
+  CastaliaIngestPayloadSchema: () => CastaliaIngestPayloadSchema,
+  DECOMPOSITION_EDGES: () => DECOMPOSITION_EDGES,
+  DRIFT_KIND: () => DRIFT_KIND,
+  EDGE_RULES: () => EDGE_RULES,
+  EDGE_WEIGHT: () => EDGE_WEIGHT,
+  EVIDENCE_EDGES: () => EVIDENCE_EDGES,
+  GIT_EDGES: () => GIT_EDGES,
+  IDENTITY_EDGES: () => IDENTITY_EDGES,
+  INGEST_EXTRACTION_SOURCES: () => INGEST_EXTRACTION_SOURCES,
+  INGEST_SOURCES: () => INGEST_SOURCES,
+  JUSTIFICATION_EDGES: () => JUSTIFICATION_EDGES,
+  MAX_EDGES_PER_PAYLOAD: () => MAX_EDGES_PER_PAYLOAD,
+  MAX_NODES_PER_PAYLOAD: () => MAX_NODES_PER_PAYLOAD,
+  PAGERANK_EXCLUSIONS: () => PAGERANK_EXCLUSIONS,
+  PROBLEM_RESOLUTION: () => PROBLEM_RESOLUTION,
+  RESOLUTION_EDGES: () => RESOLUTION_EDGES,
+  RouteContextCountWireSchema: () => RouteContextCountWireSchema,
+  SEMANTIC_NODE_LABELS: () => SEMANTIC_NODE_LABELS,
+  STRUCTURAL_EDGES: () => STRUCTURAL_EDGES,
+  TAXONOMY_EDGES: () => TAXONOMY_EDGES,
+  TRANSFER_EDGES: () => TRANSFER_EDGES,
+  TRIAGE_EDGES: () => TRIAGE_EDGES,
+  TRUTH_KIND: () => TRUTH_KIND,
+  VALIDATION_SOURCES: () => VALIDATION_SOURCES,
+  aliasesLongestFirst: () => aliasesLongestFirst,
+  allEntities: () => allEntities,
+  canonicalClaimId: () => canonicalClaimId,
+  canonicalJSON: () => canonicalJSON,
+  canonicalize: () => canonicalize,
+  canonicalizeContext: () => canonicalizeContext,
+  canonicalizeError: () => canonicalizeError,
+  canonicalizeToken: () => canonicalizeToken,
+  claimStructure: () => claimStructure,
+  conceptBag: () => conceptBag,
+  conceptTokens: () => conceptTokens,
+  detectStance: () => detectStance,
+  digest: () => digest,
+  errorSignatureEqual: () => errorSignatureEqual,
+  genericCanonicalId: () => genericCanonicalId,
+  identityId: () => identityId,
+  isCausalProtected: () => isCausalProtected,
+  isCodeLabel: () => isCodeLabel,
+  isContextLabel: () => isContextLabel,
+  isInferredSource: () => isInferredSource,
+  isSeedProvenance: () => isSeedProvenance,
+  isSemanticLabel: () => isSemanticLabel,
+  isTestRelPath: () => isTestRelPath,
+  isTestScopeQname: () => isTestScopeQname,
+  isValidEdge: () => isValidEdge,
+  isValidEdgeType: () => isValidEdgeType,
+  languageCanonicalId: () => languageCanonicalId,
+  normalizeExtractionSource: () => normalizeExtractionSource,
+  normalizePredicate: () => normalizePredicate,
+  packageCanonicalId: () => packageCanonicalId,
+  pagerankEdgeTypes: () => pagerankEdgeTypes,
+  parsePackageRef: () => parsePackageRef,
+  prefilterEntities: () => prefilterEntities,
+  problemIdFromError: () => problemIdFromError,
+  provenanceBand: () => provenanceBand,
+  resolveCanonical: () => resolveCanonical,
+  resolveCanonicalId: () => resolveCanonicalId,
+  sha256: () => sha256,
+  sha256Short: () => sha256Short,
+  summarizeIngestResult: () => summarizeIngestResult,
+  toCloudAttrs: () => toCloudAttrs,
+  validateCastaliaPayload: () => validateCastaliaPayload
+});
 var init_src = __esm({
   "../../packages/shared/src/index.ts"() {
     "use strict";
@@ -17312,6 +17573,16 @@ function ingestDesignProblem(store, flag, opts) {
   const linkedPackages = linkProblemToPackages(store, problemId, linkText, opts.ts).linked;
   return { problemId, created, corroborated, rootCauseId, solutionId, anchored, linkedPackages };
 }
+function mintPatternNode(store, name2, ts) {
+  const display = name2.replace(/\s+/g, " ").trim();
+  const id = `pat_${digest({ pattern: display.toLowerCase() })}`.slice(0, 56);
+  if (!store.getNode(id)) {
+    store.mergeNode(
+      buildNode(id, "Pattern", display, ts, { source: "convo", provisional: true })
+    );
+  }
+  return id;
+}
 function resolveFileNode(store, path2, workspaceId2) {
   const want = path2.trim().replace(/^\.?\//, "");
   for (const n of store.findNodesByLabel("File")) {
@@ -17513,12 +17784,14 @@ function resolveDesignProblems(store, t) {
     if (!p.id.startsWith("dprob_")) continue;
     if (p.attrs["resolvedAt"]) continue;
     let symName = "";
+    let symRelPath;
     let edited = false;
     for (const e of store.outEdges(p.id, ["ANCHORED_AT"])) {
       const sym = store.getNode(e.to);
       if (sym && sym.lastUpdatedAt > p.createdAt) {
         edited = true;
         symName = sym.description;
+        symRelPath = sym.attrs["relPath"] ?? void 0;
         break;
       }
     }
@@ -17528,7 +17801,11 @@ function resolveDesignProblems(store, t) {
       store.mergeNode(
         buildNode(solId, "Solution", `addressed by an edit to ${symName}`, t, {
           source: "convo",
-          provisional: false
+          provisional: false,
+          // AC-resolution-attrs: the resolving symbol/file as STRUCTURED data, not
+          // just prose — the F2 join key downstream backfills and the viz read.
+          resolvedSymbols: [symName],
+          ...symRelPath ? { resolvedRelPath: symRelPath } : {}
         })
       );
       mergeEdge(store, p.id, solId, "SOLVED_BY", t);
@@ -19503,8 +19780,8 @@ var init_principle_sync = __esm({
 });
 
 // ../../packages/local-graph/src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var src_exports2 = {};
+__export(src_exports2, {
   CAUSAL_FAMILY: () => CAUSAL_FAMILY,
   CITABLE_PRIOR_LABELS: () => CITABLE_PRIOR_LABELS,
   CODE_REACH_EDGES: () => CODE_REACH_EDGES,
@@ -19558,6 +19835,7 @@ __export(src_exports, {
   matchPackagesInText: () => matchPackagesInText,
   mergeCloudCounts: () => mergeCloudCounts,
   mergeDuplicateProblems: () => mergeDuplicateProblems,
+  mintPatternNode: () => mintPatternNode,
   openGraphStore: () => openGraphStore,
   parseAbstractionFences: () => parseAbstractionFences,
   parseSemver: () => parseSemver,
@@ -23176,6 +23454,18 @@ function triageBullet(ref) {
     "    you? bind by its handle/id directly: (cause:#the-shown-handle \u2026) / (fix:#dprob_\u2026 \u2026)."
   ].join("\n");
 }
+function linkBullet(ref) {
+  return [
+    "  \u2022 a problem you flagged resembles prior knowledge \u2014 LINK it to the canonical priors, not just one:",
+    `    \xB7 (instance:[${ref}],[another-prior],\u2026) \u2014 the priors this problem is an instance of.`,
+    "      Aim for ~3 DIFFERENT relevant priors; one link is weak, three triangulate it.",
+    `    \xB7 ${TAG_EXAMPLE.pattern()} \u2014 name the general shape it instantiates (e.g. (pattern: unbounded`,
+    "      queue growth under backpressure)) \u2014 this works with NO code anchor, and two agents naming",
+    "      the same pattern converge on one node. Cite a shown Pattern by handle: (pattern:[handle]).",
+    `    \xB7 (aids:[${ref}],\u2026) \u2014 your FIX could also help these other, even unrelated, problems.`,
+    "      A hypothesis, not a claim \u2014 it's recorded as may-resolve and checked by whoever tries it."
+  ].join("\n");
+}
 function attemptBullet() {
   return [
     "  \u2022 you're attempting an approach to a flagged problem, or an attempt didn't pan out:",
@@ -23186,15 +23476,15 @@ function attemptBullet() {
   ].join("\n");
 }
 function buildAgentInstruction(opts = {}) {
-  const signals = opts.signals ?? ["prior", "problem", "fix", "constraint", "triage", "attempt"];
+  const signals = opts.signals ?? ["prior", "problem", "fix", "constraint", "triage", "attempt", "link"];
   const ref = opts.referent ?? "its-handle";
-  const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : TAG_EXAMPLE[s](ref);
+  const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : s === "link" ? TAG_EXAMPLE.pattern() : TAG_EXAMPLE[s](ref);
   const head2 = `We tag the priors we show you with a short handle like [${opts.handleExample ?? "chokidar-glob"}]. This is a capture protocol, not optional notes: what you DON'T tag is silently lost \u2014 the tag is the ONLY thing recorded. Whenever one of these is true, wrap it inline in your prose (no fences, no extra calls). Tag every one you state; we filter downstream, so don't self-censor or batch:`;
   const tail = "Mid-turn text (between tool calls) can be dropped by the harness \u2014 if a tag above appeared only mid-turn, RESTATE it in your final message of the turn; the final message always survives.";
   return [
     head2,
     ...signals.map(
-      (s) => s === "triage" ? triageBullet(ref) : s === "attempt" ? attemptBullet() : `  \u2022 ${GLOSS[s]} \u2192 ${token(s)}`
+      (s) => s === "triage" ? triageBullet(ref) : s === "attempt" ? attemptBullet() : s === "link" ? linkBullet(ref) : `  \u2022 ${GLOSS[s]} \u2192 ${token(s)}`
     ),
     tail
   ].join("\n");
@@ -23230,7 +23520,13 @@ var init_agent_signals = __esm({
       // ATTEMPT arc — what's being tried and what didn't work. A failed attempt is a
       // witnessed NEGATIVE result: it saves the next agent the same dead end.
       tried: () => `(tried: the approach you're attempting)`,
-      failed: () => `(failed: what didn't work and the dead end it rules out)`
+      failed: () => `(failed: what didn't work and the dead end it rules out)`,
+      // LINK verbs (AC epic) — bind the problem in scope to CANONICAL priors and
+      // abstractions. Multi-target by design: single links are weak; ~3 links to 3
+      // DIFFERENT relevant priors is the target shape (see linkBullet).
+      instance: (ref) => `(instance:[${ref}],[another],[a-third])`,
+      pattern: () => `(pattern: name the general shape)`,
+      aids: (ref) => `(aids:[${ref}])`
     };
     GLOSS = {
       prior: "a prior we showed you helped \u2014 or this work sits in a primed language/package",
@@ -23238,7 +23534,8 @@ var init_agent_signals = __esm({
       fix: "your edit fixes a problem \u2014 cite the one we showed you, or just say how you fixed one you found yourself: (fix: what you changed)",
       constraint: "you made a design decision because requirements conflict or something's constrained \u2014 tag the tension, ESPECIALLY when your fix makes it 'only look' contradictory (a clean solution still hides a real trap the next agent needs)",
       triage: "you diagnosed a bug \u2014 SPLIT the symptom (what breaks \u2192 [!\u2026]) from the cause (the mechanism you'd change \u2192 (cause:\u2026)); if the line says WHY it breaks, it's a cause, not a problem",
-      attempt: "you're attempting an approach, or an attempt didn't pan out \u2014 (tried: \u2026) / (failed: \u2026); a failed attempt rules out a path for the next agent"
+      attempt: "you're attempting an approach, or an attempt didn't pan out \u2014 (tried: \u2026) / (failed: \u2026); a failed attempt rules out a path for the next agent",
+      link: "the problem you flagged is an instance of priors/abstractions you can name \u2014 (instance:[h1],[h2],\u2026) / (pattern: \u2026) / (aids:[h]); rendered whole via linkBullet"
     };
   }
 });
@@ -23534,8 +23831,8 @@ var init_recheck = __esm({
 });
 
 // ../../packages/canonical/src/index.ts
-var src_exports2 = {};
-__export(src_exports2, {
+var src_exports3 = {};
+__export(src_exports3, {
   detectViolations: () => detectViolations,
   hashIdentifier: () => hashIdentifier,
   recheck: () => recheck,
@@ -24325,6 +24622,47 @@ function mergeProblemsByEmbedding(store, opts) {
   });
   return report;
 }
+function bindCanonicalNeighbors(store, opts) {
+  const k = opts.k ?? 3;
+  const live = (n) => n.attrs["mergedInto"] === void 0;
+  const problems = store.findNodesByLabel("Problem").filter((p) => p.embedding.length > 0 && live(p));
+  const patterns = store.findNodesByLabel("Pattern").filter((p) => p.embedding.length > 0);
+  const candidates = [...problems, ...patterns];
+  let bound = 0;
+  for (const p of problems) {
+    const existing = new Set(
+      store.outEdges(p.id, ["MATCHES", "INSTANCE_OF"]).map((e) => e.to)
+    );
+    if (existing.size >= k) continue;
+    const ranked = candidates.filter(
+      (c) => c.id !== p.id && !existing.has(c.id) && c.embedding.length === p.embedding.length && (c.attrs["embeddingVersion"] ?? "") === (p.attrs["embeddingVersion"] ?? "")
+    ).map((c) => ({ c, s: cosine(p.embedding, c.embedding) })).filter((x) => x.s >= CANONICAL_BIND_MIN && x.s < NEMORI_DEDUP_COSINE).sort((a, b) => b.s - a.s);
+    const picked = [];
+    for (const cand of ranked) {
+      if (picked.length + existing.size >= k) break;
+      if (picked.some((q) => cosine(q.c.embedding, cand.c.embedding) >= NEMORI_DEDUP_COSINE)) continue;
+      picked.push(cand);
+    }
+    for (const { c, s } of picked) {
+      const type = c.label === "Pattern" ? "INSTANCE_OF" : "MATCHES";
+      store.mergeEdge({
+        id: `edge_${digest({ from: p.id, type, to: c.id, k: "canonBind" })}`.slice(0, 24),
+        from: p.id,
+        to: c.id,
+        type,
+        confidence: 0.3,
+        extractionSource: "daemon-extracted",
+        createdAt: opts.ts,
+        lastSeenAt: opts.ts,
+        navSuccesses: 0,
+        navFailures: 0,
+        attrs: { provisional: true, machineProposed: true, cosine: Math.round(s * 100) / 100 }
+      });
+      bound++;
+    }
+  }
+  return { bound, scanned: problems.length };
+}
 async function ingestErrorSignature(opts, sig, commandSig) {
   const candidateId = identityId({ kind: "RuntimeProblem", error: sig });
   const now = Date.now();
@@ -25043,7 +25381,7 @@ function reconcileDiagnostics(store, workspaceId2, relPath, diags, t, command) {
   }
   return { opened, resolved };
 }
-var GENERALIZER_CURSOR, GENERALIZER_KINDS, GENERALIZER_BATCH, ANCHOR_LABELS, DIAG_SEVERITY_ERROR;
+var GENERALIZER_CURSOR, GENERALIZER_KINDS, GENERALIZER_BATCH, CANONICAL_BIND_MIN, ANCHOR_LABELS, DIAG_SEVERITY_ERROR;
 var init_generalizer = __esm({
   "../../packages/generalizer/src/generalizer.ts"() {
     "use strict";
@@ -25063,6 +25401,7 @@ var init_generalizer = __esm({
       "harness.error"
     ];
     GENERALIZER_BATCH = 500;
+    CANONICAL_BIND_MIN = 0.78;
     ANCHOR_LABELS = ["Function", "Method", "Class"];
     DIAG_SEVERITY_ERROR = 1;
   }
@@ -25439,6 +25778,21 @@ function scoreCandidate(candidate, ctx = {}, weights) {
     weights
   );
 }
+function rankByRelevance(store, seedId, candidateIds, opts = {}) {
+  const seed = store.getNode(seedId);
+  const ctx = {
+    ...seed && seed.embedding.length > 0 ? { seedEmbedding: seed.embedding, seedEmbeddingVersion: seed.attrs["embeddingVersion"] } : {},
+    ...opts.hops !== void 0 ? { hops: opts.hops } : {}
+  };
+  const nodes = candidateIds.map((id) => store.getNode(id)).filter((n) => n != null);
+  const maxPr = Math.max(1e-9, ...nodes.map((n) => n.pageRank));
+  const weights = { centralityScale: maxPr, ...opts.weights };
+  const now = store.currentIngestSeq();
+  return nodes.map((node2) => {
+    const r = scoreCandidate(node2, { ...ctx, decay: nodeFreshness(node2, now) }, weights);
+    return { id: node2.id, score: r.score, components: r.components, node: node2 };
+  }).sort((a, b) => b.score - a.score);
+}
 function localBurst(store, seedId, opts = {}) {
   const maxHops = opts.maxHops ?? 2;
   const limit = opts.limit ?? 20;
@@ -25483,6 +25837,36 @@ var init_relevance_rank = __esm({
 });
 
 // ../../packages/generalizer/src/index.ts
+var src_exports4 = {};
+__export(src_exports4, {
+  anchorByLine: () => anchorByLine,
+  anchorCandidates: () => anchorCandidates,
+  anchorProblemToCode: () => anchorProblemToCode,
+  annotateResolution: () => annotateResolution,
+  attributeRootCause: () => attributeRootCause,
+  bindCanonicalNeighbors: () => bindCanonicalNeighbors,
+  closeProblem: () => closeProblem,
+  codeAnchorProjection: () => codeAnchorProjection,
+  commandSignature: () => commandSignature,
+  embedCodeNodes: () => embedCodeNodes,
+  embedSemanticNodes: () => embedSemanticNodes,
+  evaluateForReview: () => evaluateForReview,
+  extractDiagnostics: () => extractDiagnostics,
+  extractErrorSignature: () => extractErrorSignature,
+  ingestErrorSignature: () => ingestErrorSignature,
+  localBurst: () => localBurst,
+  mergeProblemsByEmbedding: () => mergeProblemsByEmbedding,
+  nemoriDecide: () => nemoriDecide,
+  promoteMotifs: () => promoteMotifs,
+  rankByRelevance: () => rankByRelevance,
+  rankOpenProblemNeighbors: () => rankOpenProblemNeighbors,
+  reconcileDiagnostics: () => reconcileDiagnostics,
+  resolveProblem: () => resolveProblem,
+  runGeneralizer: () => runGeneralizer,
+  runNightlyPipeline: () => runNightlyPipeline,
+  scoreCandidate: () => scoreCandidate,
+  selectAnchorFrame: () => selectAnchorFrame
+});
 var init_src10 = __esm({
   "../../packages/generalizer/src/index.ts"() {
     "use strict";
@@ -25857,7 +26241,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
       continuations: []
     };
   }
-  const { defaultProviders: defaultProviders2 } = await Promise.resolve().then(() => (init_src11(), src_exports3));
+  const { defaultProviders: defaultProviders2 } = await Promise.resolve().then(() => (init_src11(), src_exports5));
   const providers = defaultProviders2();
   for (const p of providers) if (p.preload) await p.preload();
   const before = /* @__PURE__ */ new Map();
@@ -26207,8 +26591,8 @@ async function runIndexer(store, opts) {
     if (reExports.length > 0) reExportsByFile.set(f.relPath, reExports);
     report.filesParsed++;
     report.byLanguage[f.provider.id] = (report.byLanguage[f.provider.id] ?? 0) + 1;
-    if (report.filesParsed % 250 === 0) {
-      perf(`parse @ ${report.filesParsed}/${files.length}`);
+    if (report.filesParsed % 250 === 0) perf(`parse @ ${report.filesParsed}/${files.length}`);
+    if (report.filesParsed % 25 === 0) {
       await new Promise((r) => setImmediate(r));
     }
   }
@@ -26370,7 +26754,12 @@ async function runIndexer(store, opts) {
   const pendingEdges = [];
   perf("index-build (exports/imports/workspace-pkgs/re-export-fixpoint)");
   const providerByRel = new Map(files.map((x) => [x.relPath, x.provider]));
+  let emittedFiles = 0;
   for (const [relPath, symbols] of symbolsByFile) {
+    if (emittedFiles > 0 && emittedFiles % 50 === 0) {
+      await new Promise((r) => setImmediate(r));
+    }
+    emittedFiles++;
     store.transaction(() => {
       const fileId = fileNodeId(opts.workspaceId, relPath);
       const langProvider = providerByRel.get(relPath);
@@ -26565,6 +26954,7 @@ async function runIndexer(store, opts) {
   if (pendingEdges.length > 0) {
     const EDGE_BATCH = 5e3;
     for (let ei = 0; ei < pendingEdges.length; ei += EDGE_BATCH) {
+      if (ei > 0) await new Promise((r) => setImmediate(r));
       const slice = pendingEdges.slice(ei, ei + EDGE_BATCH);
       store.transaction(() => {
         for (const e of slice) {
@@ -34000,8 +34390,8 @@ var init_csharp_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/index.ts
-var src_exports3 = {};
-__export(src_exports3, {
+var src_exports5 = {};
+__export(src_exports5, {
   DRIFT_FORK_RATIO: () => DRIFT_FORK_RATIO,
   TreeSitterCSharpProvider: () => TreeSitterCSharpProvider,
   TreeSitterCppProvider: () => TreeSitterCppProvider,
@@ -39742,6 +40132,10 @@ var FIX_PREFIX = /^\s*fix:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var CONSTRAINT_RE = /\(\s*constraint:\s*([^()\n]{8,}?)\s*\)/gi;
 var CAUSE_PREFIX = /^\s*cause:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var ATTEMPT_RE = /\(\s*(tried|failed):(?:#([a-z][\w-]{0,63}))?\s*((?:[^()\n]|\([^()\n]*\)){8,}?)\s*\)/gi;
+var AIDS_PREFIX = /^\s*aids:(?:#([a-z][\w-]{0,63}))?\s*/i;
+var INSTANCE_PREFIX = /^\s*instance:\s*/i;
+var PATTERN_RE = /\(\s*pattern:\s*([^()\n]{3,}?)\s*\)/gi;
+var PATTERN_TEXT_MAX = 120;
 var CAUSE_TEXT_MIN = 8;
 var CAUSE_TEXT_MAX = 200;
 var FLAG_RE = /\[([!?])(?:#([a-z][\w-]{0,63})\s+)?\s*([^\]\n]{8,}?)\s*(?:@\s*([^\s\]]+?)(?::(\d+))?\s*)?\]/g;
@@ -39777,10 +40171,32 @@ function parseInlineTags(text) {
     let g;
     while ((g = CITE_GROUP_RE.exec(sentence)) !== null) {
       let content = g[1];
+      if (/^\s*pattern:/i.test(content)) continue;
       const fixM = FIX_PREFIX.exec(content);
       const causeM = fixM ? null : CAUSE_PREFIX.exec(content);
+      const aidsM = fixM || causeM ? null : AIDS_PREFIX.exec(content);
+      const instM = fixM || causeM || aidsM ? null : INSTANCE_PREFIX.exec(content);
       const isFix = fixM !== null;
       const isCause = causeM !== null;
+      if (aidsM || instM) {
+        const body2 = content.replace(aidsM ? AIDS_PREFIX : INSTANCE_PREFIX, "");
+        const handles = [];
+        HANDLE_RE.lastIndex = 0;
+        let hh;
+        while ((hh = HANDLE_RE.exec(body2)) !== null) {
+          const handle2 = hh[1] ?? hh[2];
+          if (handle2 && !handles.includes(handle2)) handles.push(handle2);
+        }
+        if (handles.length > 0) {
+          out2.push({
+            kind: aidsM ? "transfer" : "instance",
+            handles,
+            sentence: sfield,
+            ...aidsM?.[1] ? { threadId: aidsM[1] } : {}
+          });
+        }
+        continue;
+      }
       const verbThread = fixM?.[1] ?? causeM?.[1] ?? void 0;
       if (isFix) content = content.replace(FIX_PREFIX, "");
       else if (isCause) content = content.replace(CAUSE_PREFIX, "");
@@ -39866,6 +40282,23 @@ function parseInlineTags(text) {
         });
       }
     }
+    PATTERN_RE.lastIndex = 0;
+    let pm;
+    while ((pm = PATTERN_RE.exec(sentence)) !== null) {
+      const body2 = pm[1].trim();
+      HANDLE_RE.lastIndex = 0;
+      const ph = HANDLE_RE.exec(body2);
+      const handle2 = ph ? ph[1] ?? ph[2] : void 0;
+      if (handle2) {
+        out2.push({ kind: "pattern", handle: handle2, sentence: sfield });
+      } else {
+        const raw3 = body2.replace(/\s+/g, " ").trim();
+        if (raw3.length >= 3) {
+          const patternText = raw3.length > PATTERN_TEXT_MAX ? `${raw3.slice(0, PATTERN_TEXT_MAX - 1).trimEnd()}\u2026` : raw3;
+          out2.push({ kind: "pattern", patternText, sentence: sfield });
+        }
+      }
+    }
     CONSTRAINT_RE.lastIndex = 0;
     let c;
     while ((c = CONSTRAINT_RE.exec(sentence)) !== null) {
@@ -39986,7 +40419,7 @@ function harvestInlineTags(store, text, opts) {
   const source = opts.sourceId ? store.getNode(opts.sourceId) : null;
   const mintPriors = opts.mintPriors ?? true;
   const touched = opts.sessionTouchedIds ?? /* @__PURE__ */ new Set();
-  const plan = { priorEdges: 0, problems: [], fixes: [], triages: [], attempts: [], unresolvedFixes: [] };
+  const plan = { priorEdges: 0, problems: [], fixes: [], triages: [], attempts: [], unresolvedFixes: [], transfers: [], instances: [], patterns: [] };
   const tags = parseInlineTags(text);
   const symptomSeqs = tags.filter((t) => (t.kind === "problem" || t.kind === "todo" || t.kind === "constraint") && t.statement).map((t) => ({ seq: t.seq ?? -1, statement: t.statement, threadId: t.threadId })).sort((a, b) => a.seq - b.seq);
   const bindSymptom = (seq, threadId) => {
@@ -40052,6 +40485,50 @@ function harvestInlineTags(store, text, opts) {
         const causeId = `dcause_${digest({ statement: tag.causeText })}`.slice(0, 56);
         plan.triages.push({ causeId, causeDescription: tag.causeText, ...bound });
       }
+    } else if (tag.kind === "transfer") {
+      const targetIds = [];
+      for (const h of tag.handles ?? []) {
+        const id = resolveHandle(store, h, opts.handleMap);
+        if (id && !targetIds.includes(id)) targetIds.push(id);
+      }
+      if (targetIds.length > 0) {
+        const b = bindSymptom(tag.seq, tag.threadId);
+        plan.transfers.push({
+          targetIds,
+          ...tag.threadId ? { threadId: tag.threadId } : {},
+          ...b.statement ? { boundStatement: b.statement } : {}
+        });
+      }
+    } else if (tag.kind === "instance") {
+      const targetIds = [];
+      for (const h of tag.handles ?? []) {
+        const id = resolveHandle(store, h, opts.handleMap);
+        if (id && !targetIds.includes(id)) targetIds.push(id);
+      }
+      if (targetIds.length > 0) {
+        const b = bindSymptom(tag.seq, tag.threadId);
+        plan.instances.push({
+          targetIds,
+          ...b.statement ? { boundStatement: b.statement } : {},
+          ...b.problemId ? { problemId: b.problemId } : {},
+          ...tag.threadId ? { threadId: tag.threadId } : {},
+          evidence: b.evidence
+        });
+      }
+    } else if (tag.kind === "pattern") {
+      const b = bindSymptom(tag.seq, tag.threadId);
+      const bound = {
+        ...b.statement ? { boundStatement: b.statement } : {},
+        ...b.problemId ? { problemId: b.problemId } : {},
+        ...tag.threadId ? { threadId: tag.threadId } : {},
+        evidence: b.evidence
+      };
+      if (tag.handle) {
+        const patternId = resolveHandle(store, tag.handle, opts.handleMap);
+        if (patternId) plan.patterns.push({ patternId, ...bound });
+      } else if (tag.patternText) {
+        plan.patterns.push({ patternText: tag.patternText, ...bound });
+      }
     } else if (tag.kind === "attempt" || tag.kind === "failure") {
       const b = bindSymptom(tag.seq, tag.threadId);
       const outcome = tag.kind === "attempt" ? "tried" : "failed";
@@ -40284,6 +40761,12 @@ var PassWorker = class {
   snapshot(opts) {
     return this.call("snapshot", opts);
   }
+  /** Run an fs/git incremental reindex on the worker — `incrementalReindex`
+   *  embeds a full-workspace `runIndexer` (cross-file re-resolution), which held
+   *  the main loop ~30s+ per saved file when run inline (HZ-reindex-offload). */
+  reindex(opts) {
+    return this.call("reindex", opts);
+  }
   call(kind, payload) {
     if (this.stopped) return Promise.reject(new Error("pass worker stopped"));
     this.ensureWorker();
@@ -41363,7 +41846,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.0-dev.30" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.0-dev.32" : "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;
@@ -41485,6 +41968,36 @@ function createWorkspaceEngine(opts) {
     watcher.on("add", onFs("fs.add"));
     watcher.on("change", onFs("fs.change"));
     watcher.on("unlink", onFs("fs.unlink"));
+    const auditIdentity = (t, e) => {
+      appendIdentityAudit(identityAuditPath, e, JSON.stringify({ t, ...e }) + "\n");
+    };
+    const runReindexPass = async (passName, changed, t, declaredRenames) => {
+      if (passWorker) {
+        try {
+          const { identityEvaluations, ...r } = await passWorker.reindex({
+            changedAbsPaths: changed,
+            t,
+            ...declaredRenames !== void 0 ? { declaredRenames } : {}
+          });
+          for (const e of identityEvaluations) auditIdentity(t, e);
+          return r;
+        } catch (err2) {
+          console.warn(
+            "[errata] reindex worker unavailable, running inline:",
+            err2 instanceof Error ? err2.message : err2
+          );
+        }
+      }
+      const done = markPass(passName);
+      try {
+        return await incrementalReindex(store, opts.workspaceRoot, profile.id, changed, t, {
+          onIdentityEvaluate: (e) => auditIdentity(t, e),
+          ...declaredRenames !== void 0 ? { declaredRenames } : {}
+        });
+      } finally {
+        done();
+      }
+    };
     const dirty = /* @__PURE__ */ new Set();
     let gitOpMuteUntil = 0;
     const scheduleFlush = () => {
@@ -41496,13 +42009,12 @@ function createWorkspaceEngine(opts) {
         const t = Date.now();
         const relChanged = changed.map((p) => relative6(opts.workspaceRoot, p).split(sep4).join("/"));
         const causal = causalBuffer.correlate(relChanged, t) ?? void 0;
-        const doneReindex = markPass(`fs-reindex:${profile.name} (${changed.length} files)`);
-        void incrementalReindex(store, opts.workspaceRoot, profile.id, changed, t, {
-          onIdentityEvaluate: (e) => {
-            appendIdentityAudit(identityAuditPath, e, JSON.stringify({ t, ...e }) + "\n");
-          },
-          declaredRenames: causal?.declaredRenames
-        }).finally(doneReindex).then((r) => {
+        void runReindexPass(
+          `fs-reindex:${profile.name} (${changed.length} files)`,
+          changed,
+          t,
+          causal?.declaredRenames
+        ).then((r) => {
           if (r.filesReindexed > 0) {
             console.log(
               `[errata] incremental reindex: ${r.filesReindexed} file(s), +${r.nodesEmitted} nodes / +${r.edgesEmitted} edges`
@@ -41560,9 +42072,13 @@ function createWorkspaceEngine(opts) {
       let episodeId2;
       if (srcPaths.length > 0) {
         const abs = srcPaths.map((p) => join19(opts.workspaceRoot, p));
-        const doneReindex = markPass(`git-reindex:${profile.name} (${abs.length} files)`);
         try {
-          const r = await incrementalReindex(store, opts.workspaceRoot, profile.id, abs, t, { declaredRenames });
+          const r = await runReindexPass(
+            `git-reindex:${profile.name} (${abs.length} files)`,
+            abs,
+            t,
+            declaredRenames
+          );
           if (r.filesReindexed > 0) {
             const epId = recordEpisode(store, profile.id, t, r.delta, void 0);
             if (epId) {
@@ -41573,8 +42089,6 @@ function createWorkspaceEngine(opts) {
           }
         } catch (err2) {
           console.warn("[errata] git reindex failed:", err2);
-        } finally {
-          doneReindex();
         }
       }
       recordGitCommit(store, {
@@ -41845,6 +42359,7 @@ function createWorkspaceEngine(opts) {
     let abstracted = 0;
     let triaged = 0;
     let priorEdges = 0;
+    let linked = 0;
     const t = Date.now();
     let processedTurns = 0;
     const elicit = isEdgeElicitationEnabled();
@@ -42075,6 +42590,65 @@ function createWorkspaceEngine(opts) {
             console.warn("[errata] attempt journal failed:", err2);
           }
         }
+        const bindPid = (tag) => {
+          const pid = tag.problemId ?? (tag.threadId ? threads.get(tag.threadId) : void 0) ?? (tag.boundStatement ? designProblemId(tag.boundStatement) : void 0) ?? inScopeProblemId ?? sessionLastProblem.get(sessionId);
+          return pid && store.getNode(pid) ? pid : void 0;
+        };
+        const mintCiteEdge = (from, to, type, confidence, extraAttrs) => {
+          store.mergeEdge({
+            id: `edge_${digest({ from, type, to })}`.slice(0, 24),
+            from,
+            to,
+            type,
+            confidence,
+            extractionSource: "agent-observed",
+            createdAt: t,
+            lastSeenAt: t,
+            navSuccesses: 0,
+            navFailures: 0,
+            attrs: { provisional: true, session: sessionId, ...extraAttrs }
+          });
+          linked++;
+        };
+        for (const pt of plan.patterns) {
+          const pid = bindPid(pt);
+          if (!pid) continue;
+          let patternId = pt.patternId;
+          if (patternId) {
+            const node2 = store.getNode(patternId);
+            if (!node2 || node2.label !== "Pattern") continue;
+          } else if (pt.patternText) {
+            patternId = mintPatternNode(store, pt.patternText, t);
+          }
+          if (!patternId || patternId === pid) continue;
+          mintCiteEdge(pid, patternId, "INSTANCE_OF", pt.evidence === "witnessed" ? 0.4 : 0.3, { patternCite: true, evidence: pt.evidence });
+        }
+        for (const inst of plan.instances) {
+          const pid = bindPid(inst);
+          if (!pid) continue;
+          for (const targetId of inst.targetIds) {
+            if (targetId === pid) continue;
+            const target = store.getNode(targetId);
+            if (!target) continue;
+            const fallback = typePriorEdge("Problem", target.label);
+            const type = target.label === "Pattern" ? "INSTANCE_OF" : target.label === "Problem" ? "MATCHES" : fallback === "SUPERSEDES" ? "RELATES_TO" : fallback;
+            mintCiteEdge(pid, targetId, type, inst.evidence === "witnessed" ? 0.4 : 0.3, { instanceCite: true, evidence: inst.evidence });
+          }
+        }
+        for (const tf of plan.transfers) {
+          const pid = bindPid(tf);
+          const solId = pid ? solutionForProblem(store, pid) : void 0;
+          if (!solId) {
+            console.warn("[errata] aids tag dropped: no solution in scope to hypothesize from \u2014 state it beside its (fix:\u2026)");
+            continue;
+          }
+          for (const targetId of tf.targetIds) {
+            if (targetId === solId) continue;
+            const target = store.getNode(targetId);
+            if (!target || target.label !== "Problem") continue;
+            mintCiteEdge(solId, targetId, "MAY_RESOLVE", 0.3, { transfer: true, hypothesis: true });
+          }
+        }
       } catch (err2) {
         console.warn("[errata] inline-tag harvest failed:", err2);
       }
@@ -42083,6 +42657,10 @@ function createWorkspaceEngine(opts) {
       console.log(`[errata] edge-elicitation: +${priorEdges} soft prior-tag edge(s)`);
       contextDirty = true;
     }
+    if (linked > 0) {
+      console.log(`[errata] canonical-bind: +${linked} abstraction link(s) (pattern/instance/aids)`);
+      contextDirty = true;
+    }
     if (minted > 0 || resolved > 0) {
       console.log(
         `[errata] design: +${minted} flagged, ${resolved} resolved from the conversation`
@@ -42309,6 +42887,10 @@ function createWorkspaceEngine(opts) {
           if (e.merged > 0) {
             console.log(`[errata] dedup: merged ${e.merged} paraphrased problem(s) by embedding across ${e.clusters} cluster(s)`);
           }
+          const cb = bindCanonicalNeighbors(store, { ts: Date.now() });
+          if (cb.bound > 0) {
+            console.log(`[errata] canonical-bind: +${cb.bound} machine-proposed link(s) across ${cb.scanned} problem(s)`);
+          }
           refreshContextNow();
         }
         return { embedded: sem.embedded };
@@ -42345,6 +42927,10 @@ function createWorkspaceEngine(opts) {
             console.log(`[errata] dedup: merged ${e.merged} paraphrased problem(s) by embedding across ${e.clusters} cluster(s)`);
             refreshContextNow();
           }
+          const cb = bindCanonicalNeighbors(store, { ts: Date.now() });
+          if (cb.bound > 0) {
+            console.log(`[errata] canonical-bind: +${cb.bound} machine-proposed link(s) across ${cb.scanned} problem(s)`);
+          }
         } catch (err2) {
           console.warn("[errata] embedding problem dedup failed:", err2);
         }
@@ -44135,6 +44721,8 @@ async function main() {
       return cmdDash(rest);
     case "notify-test":
       return cmdNotifyTest();
+    case "backfill-anchors":
+      return cmdBackfillAnchors();
     case "help":
     case "--help":
     case "-h":
@@ -44172,6 +44760,9 @@ Commands:
                       --no-embed skips the code-node embedding pass
                       (~minutes on first run; incremental after).
   review              Print the pending review queue
+  backfill-anchors    Retro-anchor resolved problems whose fix location lives only
+                      in prose ("addressed by an edit to \u2026") + run the canonical
+                      binder over the embedded backlog. Idempotent.
   locate <path>       Print the File node + immediate symbols for a path
   neighbors <id>      Walk the graph from a node (BFS depth 2)
                       Flags: --depth N (1..5)
@@ -44720,7 +45311,7 @@ async function cmdLocate(relPath) {
     process.exit(2);
   }
   await ensureProfile();
-  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const { workspacePaths: workspacePaths2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   const paths = workspacePaths2(ROOT);
   const store = openGraphStore2({ path: paths.castalia });
@@ -44772,7 +45363,7 @@ async function cmdNeighbors(args2) {
   const depthIdx = args2.indexOf("--depth");
   const depth = depthIdx >= 0 && args2[depthIdx + 1] ? Math.max(1, Math.min(5, Number(args2[depthIdx + 1]))) : 2;
   await ensureProfile();
-  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const { workspacePaths: workspacePaths2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   const paths = workspacePaths2(ROOT);
   const store = openGraphStore2({ path: paths.castalia });
@@ -44820,7 +45411,7 @@ async function cmdNeighbors(args2) {
 }
 async function cmdTodos() {
   await ensureProfile();
-  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const { workspacePaths: workspacePaths2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   const paths = workspacePaths2(ROOT);
   const store = openGraphStore2({ path: paths.castalia });
@@ -44856,9 +45447,86 @@ async function cmdTodos() {
     store.close();
   }
 }
+async function cmdBackfillAnchors() {
+  const profile = loadProfile(ROOT);
+  await ensureProfile();
+  const { anchorSolutionToDiff: anchorSolutionToDiff2, anchorProblemToDiff: anchorProblemToDiff2, deriveContextFromAnchors: deriveContextFromAnchors2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
+  const { bindCanonicalNeighbors: bindCanonicalNeighbors2 } = await Promise.resolve().then(() => (init_src10(), src_exports4));
+  const { digest: digest2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  await withStore(async (store) => {
+    const ts = Date.now();
+    const wsId = profile.id;
+    const PROSE = /^addressed by an edit to (.+)$/;
+    let anchored = 0;
+    let skipped = 0;
+    for (const sol of store.findNodesByLabel("Solution")) {
+      const m = PROSE.exec(sol.description.trim());
+      if (!m) continue;
+      if (store.outEdges(sol.id, ["ANCHORED_AT"]).length > 0) {
+        skipped++;
+        continue;
+      }
+      const target = m[1].trim();
+      const problemIds = store.inEdges(sol.id, ["SOLVED_BY"]).map((e) => e.from).filter((id) => store.getNode(id)?.label === "Problem");
+      const isPath = target.includes("/") || target.includes("\\");
+      if (isPath) {
+        anchorSolutionToDiff2(store, sol.id, [target], wsId, ts);
+        for (const pid of problemIds) {
+          anchorProblemToDiff2(store, pid, [target], wsId, ts);
+          deriveContextFromAnchors2(store, pid, ts);
+        }
+      } else {
+        const bare = target.includes(".") ? target.slice(target.lastIndexOf(".") + 1) : target;
+        let sym = null;
+        outer: for (const label of ["Function", "Method", "Class"]) {
+          for (const n of store.findNodesByLabel(label)) {
+            if (n.attrs["workspaceId"] && n.attrs["workspaceId"] !== wsId) continue;
+            const qname = String(n.attrs["qname"] ?? "");
+            if (qname === target || n.description === target) {
+              sym = n;
+              break outer;
+            }
+            if (!sym && (qname.endsWith(`.${bare}`) || n.description === bare)) sym = n;
+          }
+        }
+        if (!sym) continue;
+        for (const from of [sol.id, ...problemIds]) {
+          store.mergeEdge({
+            id: `edge_${digest2({ from, type: "ANCHORED_AT", to: sym.id })}`.slice(0, 24),
+            from,
+            to: sym.id,
+            type: "ANCHORED_AT",
+            confidence: 0.6,
+            extractionSource: "daemon-extracted",
+            createdAt: ts,
+            lastSeenAt: ts,
+            navSuccesses: 0,
+            navFailures: 0,
+            attrs: { provisional: true, backfill: true }
+          });
+        }
+        for (const pid of problemIds) deriveContextFromAnchors2(store, pid, ts);
+      }
+      if (store.outEdges(sol.id, ["ANCHORED_AT"]).length > 0) {
+        anchored++;
+        store.updateNode(sol.id, {
+          attrs: {
+            ...sol.attrs,
+            ...isPath ? { resolvedRelPath: target } : { resolvedSymbols: [target] }
+          },
+          lastUpdatedAt: ts
+        });
+      }
+    }
+    const cb = bindCanonicalNeighbors2(store, { ts });
+    console.log(
+      `backfill: anchored ${anchored} resolution(s) from prose (${skipped} already anchored); canonical-bind: +${cb.bound} machine link(s) across ${cb.scanned} embedded problem(s)`
+    );
+  });
+}
 async function withStore(fn) {
   await ensureProfile();
-  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const { workspacePaths: workspacePaths2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   const paths = workspacePaths2(ROOT);
   const store = openGraphStore2({ path: paths.castalia });
@@ -45233,7 +45901,7 @@ async function gatherRepo(store, ws) {
 }
 async function gatherReportData(generatedAt) {
   const { existsSync: existsSync20 } = await import("node:fs");
-  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
   const repos = [];
@@ -45964,7 +46632,7 @@ async function cmdFeedback(args2) {
     console.error('usage: errata feedback [up|down] "<message>"');
     process.exit(2);
   }
-  const { scrub: scrub2 } = await Promise.resolve().then(() => (init_src7(), src_exports2));
+  const { scrub: scrub2 } = await Promise.resolve().then(() => (init_src7(), src_exports3));
   const scrubbed = scrub2(message).text;
   const c = authedCloudClient(cfg);
   try {