@inerrata-corporation/errata 2.0.2-dev.1263 → 2.0.2-dev.1274

package/errata.mjs

@@ -18962,11 +18962,16 @@ function foldDuplicateProblem(store, dup, survivor, ts) {
   if (!surv) return;
   const sources = new Set(surv.attrs["sources"] ?? []);
   for (const s of dup.attrs["sources"] ?? []) sources.add(s);
+  const dupSeq = dup.attrs["createdAtSeq"] ?? store.currentIngestSeq();
+  const exposure = priorExposure(store, survivor.id, dupSeq);
+  const expField = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
   store.updateNode(survivor.id, {
     attrs: {
       ...surv.attrs,
       sources: [...sources],
-      corroborations: corroborations(surv) + corroborations(dup) + 1
+      corroborations: corroborations(surv) + corroborations(dup) + 1,
+      [expField]: (surv.attrs[expField] ?? 0) + 1,
+      lastReinforceExposure: exposure
     },
     cumulativeHits: (surv.cumulativeHits ?? 0) + (dup.cumulativeHits ?? 0),
     lastUpdatedAt: ts
@@ -19400,22 +19405,61 @@ function tokenJaccard(a, b) {
   return inter / (sa.size + sb.size - inter);
 }
 function reinforceSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind = "problem") {
+  return foldSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind).foldedId;
+}
+function foldSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind = "problem") {
+  const report = { ...EMPTY_FOLD_REPORT };
   const stmt = statement.trim();
-  if (!isAnchorableCodePath(relPath)) return null;
+  if (!isAnchorableCodePath(relPath)) {
+    report.noFile = true;
+    return report;
+  }
   const file2 = resolveFileNode(store, relPath, workspaceId2);
-  if (!file2) return null;
+  if (!file2) {
+    report.noFile = true;
+    return report;
+  }
   const selfId = identityId({ kind: "DesignProblem", statement: stmt });
+  let stmtVec = null;
   let best = null;
+  let bestScout = null;
   for (const e of store.inEdges(file2.id, ["ANCHORED_AT"])) {
     const cand = store.getNode(e.from);
     if (!cand || cand.label !== "Problem" || cand.attrs["resolvedAt"]) continue;
     if (cand.id === selfId) continue;
     const candKind = cand.attrs["kind"] === "constraint" ? "constraint" : "problem";
-    if (candKind !== (kind === "constraint" ? "constraint" : "problem")) continue;
+    if (candKind !== (kind === "constraint" ? "constraint" : "problem")) {
+      report.kindVetoed++;
+      continue;
+    }
+    report.candidates++;
     const score2 = tokenJaccard(stmt, cand.description);
+    if (score2 > report.bestJaccard) report.bestJaccard = score2;
     if (score2 >= SAME_ANCHOR_DEDUP_JACCARD && (!best || score2 > best.score)) best = { node: cand, score: score2 };
+    if (!best) {
+      stmtVec ??= embed(stmt);
+      const hc = cosine(stmtVec, embed(cand.description));
+      if (hc > report.bestHashCos) report.bestHashCos = hc;
+      if ((hc >= SAME_ANCHOR_SCOUT_MIN_COSINE || score2 >= SAME_ANCHOR_NOMINATE_JACCARD) && (!bestScout || hc > bestScout.hashCos)) {
+        bestScout = { node: cand, hashCos: hc, jaccard: score2 };
+      }
+    }
   }
-  if (!best) return null;
+  if (!best && bestScout && bestScout.hashCos >= SAME_ANCHOR_SCOUT_AUTO_COSINE) {
+    best = { node: bestScout.node, score: bestScout.jaccard };
+    report.foldedBy = "scout";
+  }
+  if (!best) {
+    if (bestScout) {
+      report.nominate = {
+        targetId: bestScout.node.id,
+        jaccard: bestScout.jaccard,
+        hashCos: bestScout.hashCos
+      };
+    }
+    return report;
+  }
+  report.foldedBy ??= "jaccard";
   const existing = best.node;
   const sources = existing.attrs["sources"] ?? [];
   if (!sources.includes(source)) {
@@ -19437,7 +19481,8 @@ function reinforceSameAnchorProblem(store, relPath, workspaceId2, statement, sou
       lastUpdatedAt: ts
     });
   }
-  return existing.id;
+  report.foldedId = existing.id;
+  return report;
 }
 function findResolvedAnchorMatch(store, relPath, workspaceId2, statement, kind = "problem") {
   const stmt = statement.trim();
@@ -19911,7 +19956,7 @@ function priorExposure(store, nodeId, atSeq) {
   if ((n.attrs["evictedCount"] ?? 0) > 0) return "evicted";
   return "unshown";
 }
-var DESIGN_PROMOTE_AT, STATEMENT_ALIAS_CAP, RECURRENCE_DEBOUNCE_MS, PATTERN_DEDUP_COSINE, PATTERN_ALIAS_CAP, DEDUP_STOPWORDS, SAME_ANCHOR_DEDUP_JACCARD, REOPEN_MIN_SOURCES, RECURRENCE_SOURCES_CAP, CITABLE_PRIOR_LABELS, MAX_ANCHOR_FILES, AUTO_MINT_PREFIX, FIX_CANDIDATE_ASK_LIMIT;
+var DESIGN_PROMOTE_AT, STATEMENT_ALIAS_CAP, RECURRENCE_DEBOUNCE_MS, PATTERN_DEDUP_COSINE, PATTERN_ALIAS_CAP, DEDUP_STOPWORDS, SAME_ANCHOR_DEDUP_JACCARD, EMPTY_FOLD_REPORT, SAME_ANCHOR_SCOUT_AUTO_COSINE, SAME_ANCHOR_SCOUT_MIN_COSINE, SAME_ANCHOR_NOMINATE_JACCARD, REOPEN_MIN_SOURCES, RECURRENCE_SOURCES_CAP, CITABLE_PRIOR_LABELS, MAX_ANCHOR_FILES, AUTO_MINT_PREFIX, FIX_CANDIDATE_ASK_LIMIT;
 var init_design_problem = __esm({
   "../../packages/local-graph/src/design-problem.ts"() {
     "use strict";
@@ -19951,6 +19996,19 @@ var init_design_problem = __esm({
       "where"
     ]);
     SAME_ANCHOR_DEDUP_JACCARD = 0.6;
+    EMPTY_FOLD_REPORT = {
+      foldedId: null,
+      foldedBy: null,
+      noFile: false,
+      candidates: 0,
+      kindVetoed: 0,
+      bestJaccard: 0,
+      bestHashCos: 0,
+      nominate: null
+    };
+    SAME_ANCHOR_SCOUT_AUTO_COSINE = 0.85;
+    SAME_ANCHOR_SCOUT_MIN_COSINE = 0.5;
+    SAME_ANCHOR_NOMINATE_JACCARD = 0.3;
     REOPEN_MIN_SOURCES = 2;
     RECURRENCE_SOURCES_CAP = 8;
     CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
@@ -22195,6 +22253,160 @@ var init_community2 = __esm({
   }
 });
 
+// ../../packages/local-graph/src/fold-candidates.ts
+function markFoldCandidate(store, problemId, targetId, info2) {
+  if (problemId === targetId) return false;
+  const n = store.getNode(problemId);
+  if (!openProblem(n)) return false;
+  if (n.attrs["foldCandidate"] !== void 0) return false;
+  const rejected = n.attrs["foldRejected"] ?? [];
+  if (rejected.includes(targetId)) return false;
+  if (!openProblem(store.getNode(targetId))) return false;
+  const mark = {
+    targetId,
+    ...info2.hashCos !== void 0 ? { hashCos: info2.hashCos } : {},
+    ...info2.jaccard !== void 0 ? { jaccard: info2.jaccard } : {},
+    source: info2.source,
+    ts: info2.ts,
+    markedAtSeq: store.currentIngestSeq()
+  };
+  store.updateNode(problemId, { attrs: { ...n.attrs, foldCandidate: mark }, lastUpdatedAt: info2.ts });
+  return true;
+}
+function findWorkspaceFoldCandidate(store, workspaceId2, statement, kind, opts) {
+  const stmtVec = embed(statement);
+  const wantConstraint = kind === "constraint";
+  const open2 = store.findNodesByLabel("Problem").filter(
+    (p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0 && p.id !== opts?.excludeId && (p.attrs["workspaceId"] === void 0 || p.attrs["workspaceId"] === workspaceId2) && isConstraintProblem(p) === wantConstraint
+  ).sort((a, b) => (b.lastUpdatedAt ?? b.createdAt) - (a.lastUpdatedAt ?? a.createdAt)).slice(0, opts?.scanCap ?? WORKSPACE_SCAN_CAP);
+  let best = null;
+  for (const p of open2) {
+    const c = cosine(stmtVec, embed(p.description));
+    if (c >= FOLD_SCOUT_MIN_COSINE && (!best || c > best.hashCos)) best = { targetId: p.id, hashCos: c };
+  }
+  return best;
+}
+function followMerges(store, id) {
+  let cur = store.getNode(id);
+  for (let hop = 0; hop < 3 && cur && cur.attrs["mergedInto"] !== void 0; hop++) {
+    cur = store.getNode(String(cur.attrs["mergedInto"]));
+  }
+  return cur ?? null;
+}
+function clearCandidate(store, node2, ts, rejectTargetId) {
+  const attrs = { ...node2.attrs };
+  delete attrs["foldCandidate"];
+  if (rejectTargetId) {
+    const rejected = attrs["foldRejected"] ?? [];
+    if (!rejected.includes(rejectTargetId)) {
+      attrs["foldRejected"] = [...rejected, rejectTargetId].slice(-FOLD_REJECTED_CAP);
+    }
+  }
+  store.updateNode(node2.id, { attrs, lastUpdatedAt: ts });
+}
+async function resolveFoldCandidates(store, opts) {
+  const report = {
+    examined: 0,
+    folded: 0,
+    foldedEmbedding: 0,
+    foldedJudge: 0,
+    rejected: 0,
+    standing: 0,
+    judgeErrors: 0,
+    retargeted: 0
+  };
+  const limit = opts.limit ?? 8;
+  const marked = store.findNodesByLabel("Problem").filter((p) => openProblem(p) && p.attrs["foldCandidate"] !== void 0).sort((a, b) => {
+    const ma = a.attrs["foldCandidate"].ts ?? 0;
+    const mb = b.attrs["foldCandidate"].ts ?? 0;
+    return ma - mb;
+  }).slice(0, limit);
+  for (const node2 of marked) {
+    const fresh = store.getNode(node2.id);
+    if (!openProblem(fresh)) continue;
+    report.examined++;
+    const mark = fresh.attrs["foldCandidate"];
+    let target = followMerges(store, mark.targetId);
+    if (target && target.id !== mark.targetId) report.retargeted++;
+    if (!openProblem(target)) {
+      clearCandidate(store, fresh, opts.ts);
+      report.rejected++;
+      continue;
+    }
+    if (isConstraintProblem(fresh) !== isConstraintProblem(target)) {
+      clearCandidate(store, fresh, opts.ts, target.id);
+      report.rejected++;
+      continue;
+    }
+    let cos = null;
+    if (fresh.embedding.length > 0 && fresh.embedding.length === target.embedding.length && (fresh.attrs["embeddingVersion"] ?? "") === (target.attrs["embeddingVersion"] ?? "")) {
+      cos = cosine(fresh.embedding, target.embedding);
+    }
+    if (cos !== null && cos >= FOLD_EMBED_AUTO_COSINE) {
+      foldPair(store, fresh, target, opts.ts);
+      report.folded++;
+      report.foldedEmbedding++;
+      continue;
+    }
+    if (cos !== null && cos < FOLD_JUDGE_MIN_COSINE) {
+      clearCandidate(store, fresh, opts.ts, target.id);
+      report.rejected++;
+      continue;
+    }
+    if (!opts.judge) {
+      report.standing++;
+      continue;
+    }
+    let verdict = null;
+    try {
+      verdict = await opts.judge(fresh.description, target.description);
+    } catch {
+      verdict = null;
+    }
+    if (verdict === "same") {
+      foldPair(store, fresh, target, opts.ts);
+      report.folded++;
+      report.foldedJudge++;
+    } else if (verdict === "distinct") {
+      clearCandidate(store, fresh, opts.ts, target.id);
+      report.rejected++;
+    } else {
+      report.judgeErrors++;
+      report.standing++;
+    }
+  }
+  return report;
+}
+function foldPair(store, a, b, ts) {
+  const corro = (n) => Number(n.attrs["corroborations"] ?? 0);
+  const survivor = corro(a) !== corro(b) ? corro(a) > corro(b) ? a : b : a.createdAt <= b.createdAt ? a : b;
+  const dup = survivor === a ? b : a;
+  for (const n of [a, b]) {
+    if (n.attrs["foldCandidate"] !== void 0) clearCandidate(store, n, ts);
+  }
+  const freshSurvivor = store.getNode(survivor.id);
+  const freshDup = store.getNode(dup.id);
+  if (!freshSurvivor || !freshDup) return;
+  foldDuplicateProblem(store, freshDup, freshSurvivor, ts);
+}
+var FOLD_SCOUT_AUTO_COSINE, FOLD_SCOUT_MIN_COSINE, FOLD_SCOUT_MIN_JACCARD, FOLD_EMBED_AUTO_COSINE, FOLD_JUDGE_MIN_COSINE, FOLD_REJECTED_CAP, WORKSPACE_SCAN_CAP, openProblem;
+var init_fold_candidates = __esm({
+  "../../packages/local-graph/src/fold-candidates.ts"() {
+    "use strict";
+    init_src3();
+    init_design_problem();
+    init_problem_dedup();
+    FOLD_SCOUT_AUTO_COSINE = 0.85;
+    FOLD_SCOUT_MIN_COSINE = 0.5;
+    FOLD_SCOUT_MIN_JACCARD = 0.3;
+    FOLD_EMBED_AUTO_COSINE = 0.88;
+    FOLD_JUDGE_MIN_COSINE = 0.5;
+    FOLD_REJECTED_CAP = 8;
+    WORKSPACE_SCAN_CAP = 400;
+    openProblem = (n) => !!n && n.label === "Problem" && n.attrs["resolvedAt"] == null && n.attrs["mergedInto"] === void 0;
+  }
+});
+
 // ../../packages/local-graph/src/tools.ts
 function toolNodeId(name2) {
   return `tool:${name2}`;
@@ -22649,6 +22861,32 @@ var init_mechanism_liveness = __esm({
         backlogCounter: "anchorHintsStanding",
         note: "drains as hinted files change; contentChangedAt is forward-only so the backlog moves with real edits"
       },
+      {
+        id: "fold-candidate-resolve",
+        what: "resolves parked paraphrase-fold nominations (embedding-certain bands auto, ambiguous band via the equivalence judge)",
+        // The settle boundary's fold-judge pass is the sole consumer of
+        // attrs.foldCandidate; producers are the file/workspace scouts (capture)
+        // and the settle near-miss band (mergeProblemsByEmbedding).
+        pass: "fold-judge",
+        // Conditional mark, rare by design (a nomination is a near-miss event) —
+        // the bar is "the field is written at all", the revisit-sweep precedent.
+        fed: { labels: ["Problem"], attr: "foldCandidate", minFraction: 0 },
+        effectCounter: "folded",
+        // Standing nominations ARE the judge-less backlog — without the gauge a
+        // deployment with no judge configured reads as "nothing to fold".
+        backlogCounter: "standing",
+        note: "standing > 0 with folded 0 = the judge lane is unconfigured (ERRATA_FOLD_JUDGE / azure env), not an empty queue"
+      },
+      {
+        id: "cite-anchor-accrual",
+        what: "accrues cite-context anchor evidence on anchorless cited priors; two distinct sessions promote a cite-confirmed ANCHORED_AT",
+        pass: "capture",
+        // Conditional attr: only anchorless semantic priors cited from a known
+        // working file carry hints — "written at all" is the honest floor.
+        fed: { labels: ["Problem"], attr: "citeAnchorHints", minFraction: 0 },
+        effectCounter: "citeAnchorsPromoted",
+        note: "the supply-side fix for corroboration 0-for-8: promoted anchors are what the overlap gate intersects on the NEXT citation"
+      },
       {
         id: "wm-reinforce-exposure",
         what: "labels each paraphrase re-derivation with the prior's exposure (shown/evicted/unshown)",
@@ -22769,6 +23007,12 @@ __export(src_exports2, {
   CREDIT_FAMILY: () => CREDIT_FAMILY,
   DEFAULT_MIN_COVERAGE: () => DEFAULT_MIN_COVERAGE,
   FIX_CANDIDATE_ASK_LIMIT: () => FIX_CANDIDATE_ASK_LIMIT,
+  FOLD_EMBED_AUTO_COSINE: () => FOLD_EMBED_AUTO_COSINE,
+  FOLD_JUDGE_MIN_COSINE: () => FOLD_JUDGE_MIN_COSINE,
+  FOLD_REJECTED_CAP: () => FOLD_REJECTED_CAP,
+  FOLD_SCOUT_AUTO_COSINE: () => FOLD_SCOUT_AUTO_COSINE,
+  FOLD_SCOUT_MIN_COSINE: () => FOLD_SCOUT_MIN_COSINE,
+  FOLD_SCOUT_MIN_JACCARD: () => FOLD_SCOUT_MIN_JACCARD,
   JOINT_COMMUNITY_EDGES: () => JOINT_COMMUNITY_EDGES,
   JOINT_COMMUNITY_LABELS: () => JOINT_COMMUNITY_LABELS,
   MAX_ANCHOR_FILES: () => MAX_ANCHOR_FILES,
@@ -22781,10 +23025,14 @@ __export(src_exports2, {
   RECURRENCE_DEBOUNCE_MS: () => RECURRENCE_DEBOUNCE_MS,
   REOPEN_MIN_SOURCES: () => REOPEN_MIN_SOURCES,
   SAME_ANCHOR_DEDUP_JACCARD: () => SAME_ANCHOR_DEDUP_JACCARD,
+  SAME_ANCHOR_NOMINATE_JACCARD: () => SAME_ANCHOR_NOMINATE_JACCARD,
+  SAME_ANCHOR_SCOUT_AUTO_COSINE: () => SAME_ANCHOR_SCOUT_AUTO_COSINE,
+  SAME_ANCHOR_SCOUT_MIN_COSINE: () => SAME_ANCHOR_SCOUT_MIN_COSINE,
   STALL_MIN_RUNS: () => STALL_MIN_RUNS,
   STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
   SqliteGraphStore: () => SqliteGraphStore,
   WM_CALIBRATION_LABELS: () => WM_CALIBRATION_LABELS,
+  WORKSPACE_SCAN_CAP: () => WORKSPACE_SCAN_CAP,
   addDependency: () => addDependency,
   aggregateClaimConfidence: () => aggregateClaimConfidence,
   anchorProblemToDiff: () => anchorProblemToDiff,
@@ -22825,8 +23073,10 @@ __export(src_exports2, {
   findPath: () => findPath,
   findResolvedAnchorMatch: () => findResolvedAnchorMatch,
   findReusableSolution: () => findReusableSolution,
+  findWorkspaceFoldCandidate: () => findWorkspaceFoldCandidate,
   flattenCloudCounts: () => flattenCloudCounts,
   foldDuplicateProblem: () => foldDuplicateProblem,
+  foldSameAnchorProblem: () => foldSameAnchorProblem,
   formatMechanismStatus: () => formatMechanismStatus,
   getClaim: () => getClaim,
   harvestAbstractionFences: () => harvestAbstractionFences,
@@ -22846,6 +23096,7 @@ __export(src_exports2, {
   localEdgeViolation: () => localEdgeViolation,
   markDiscriminatorAsked: () => markDiscriminatorAsked,
   markFixCandidates: () => markFixCandidates,
+  markFoldCandidate: () => markFoldCandidate,
   markResolvedRecurrence: () => markResolvedRecurrence,
   markRevisit: () => markRevisit,
   matchLanguagesInText: () => matchLanguagesInText,
@@ -22887,6 +23138,7 @@ __export(src_exports2, {
   repairLegacyAnchorsFromStatement: () => repairLegacyAnchorsFromStatement,
   resolveDesignProblemById: () => resolveDesignProblemById,
   resolveDesignProblemByStatement: () => resolveDesignProblemByStatement,
+  resolveFoldCandidates: () => resolveFoldCandidates,
   resolveOsNode: () => resolveOsNode,
   retractDesignProblemById: () => retractDesignProblemById,
   retractDesignProblemByStatement: () => retractDesignProblemByStatement,
@@ -22925,6 +23177,7 @@ var init_src5 = __esm({
     init_community2();
     init_triage2();
     init_problem_dedup();
+    init_fold_candidates();
     init_problem_package_link();
     init_tools();
     init_principle_sync();
@@ -29579,7 +29832,8 @@ function rankOpenProblemNeighbors(store, embedding, limit = 5) {
 }
 function mergeProblemsByEmbedding(store, opts) {
   const minCosine = opts.minCosine ?? NEMORI_DEDUP_COSINE;
-  const report = { clusters: 0, merged: 0 };
+  const NEAR_MISS_FLOOR = 0.72;
+  const report = { clusters: 0, merged: 0, nearMissMarked: 0 };
   const open2 = store.findNodesByLabel("Problem").filter(
     (p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0 && p.embedding.length > 0
   );
@@ -29594,9 +29848,15 @@ function mergeProblemsByEmbedding(store, opts) {
         if (b.embedding.length !== a.embedding.length) continue;
         if ((a.attrs["embeddingVersion"] ?? "") !== (b.attrs["embeddingVersion"] ?? "")) continue;
         if (isConstraintProblem(a) !== isConstraintProblem(b)) continue;
-        if (cosine(a.embedding, b.embedding) >= minCosine) {
+        const cos = cosine(a.embedding, b.embedding);
+        if (cos >= minCosine) {
           cluster.push(b);
           consumed.add(b.id);
+        } else if (cos >= NEAR_MISS_FLOOR) {
+          const [younger, elder] = a.createdAt >= b.createdAt ? [a, b] : [b, a];
+          if (markFoldCandidate(store, younger.id, elder.id, { hashCos: cos, source: "settle-nearmiss", ts: opts.ts })) {
+            report.nearMissMarked = (report.nearMissMarked ?? 0) + 1;
+          }
         }
       }
       if (cluster.length < 2) continue;
@@ -53256,6 +53516,91 @@ function openEventLog(opts) {
   return new EventLog(opts);
 }
 
+// src/llm-provider.ts
+function chatProvider() {
+  return (process.env["EXTRACTION_PROVIDER"] ?? "azure").toLowerCase() === "anthropic" ? "anthropic" : "azure";
+}
+function deploymentFor(model) {
+  const key = `MODEL_${model.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_OPENAI`;
+  return process.env[key] ?? process.env["AZURE_OPENAI_DEPLOYMENT"];
+}
+function isChatConfigured(model) {
+  if (chatProvider() === "azure") {
+    return Boolean(
+      process.env["AZURE_OPENAI_API_KEY"] && process.env["AZURE_OPENAI_ENDPOINT"] && deploymentFor(model)
+    );
+  }
+  return Boolean(process.env["ANTHROPIC_API_KEY"]);
+}
+async function chat(req) {
+  const provider = chatProvider();
+  try {
+    if (provider === "azure") {
+      const endpoint = (process.env["AZURE_OPENAI_ENDPOINT"] ?? "").replace(/\/+$/, "");
+      const version2 = process.env["AZURE_OPENAI_API_VERSION"] ?? "2024-10-21";
+      const deployment = deploymentFor(req.model);
+      if (!endpoint || !deployment) {
+        console.warn("[errata] llm: azure selected but endpoint/deployment missing \u2014 skipping");
+        return null;
+      }
+      const resp2 = await fetch(
+        `${endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${version2}`,
+        {
+          method: "POST",
+          headers: {
+            "api-key": process.env["AZURE_OPENAI_API_KEY"] ?? "",
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            messages: [
+              ...req.system ? [{ role: "system", content: req.system }] : [],
+              { role: "user", content: req.user }
+            ],
+            // `max_completion_tokens`: the newer deployments reject `max_tokens`.
+            max_completion_tokens: req.maxTokens
+          })
+        }
+      );
+      if (!resp2.ok) {
+        console.warn(
+          `[errata] llm: azure ${resp2.status} \u2014 ${(await resp2.text().catch(() => "")).slice(0, 200)}`
+        );
+        return null;
+      }
+      const json3 = await resp2.json();
+      return json3.choices?.[0]?.message?.content ?? null;
+    }
+    const resp = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": process.env["ANTHROPIC_API_KEY"] ?? "",
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: req.model,
+        max_tokens: req.maxTokens,
+        ...req.system ? { system: req.system } : {},
+        messages: [{ role: "user", content: req.user }]
+      })
+    });
+    if (!resp.ok) {
+      console.warn(
+        `[errata] llm: anthropic ${resp.status} \u2014 ${(await resp.text().catch(() => "")).slice(0, 200)}`
+      );
+      return null;
+    }
+    const json2 = await resp.json();
+    return json2.content?.find((c) => c.type === "text")?.text ?? null;
+  } catch (err2) {
+    console.warn(
+      `[errata] llm: ${provider} transport failed \u2014`,
+      err2 instanceof Error ? err2.message : err2
+    );
+    return null;
+  }
+}
+
 // src/engine.ts
 init_src11();
 init_src6();
@@ -54478,7 +54823,52 @@ function readPrimingHandles(path2) {
 function resolveHandle(store, handle2, handleMap) {
   return handleMap[handle2]?.id ?? (store.getNode(handle2) ? handle2 : void 0);
 }
-function mintPriorEdge(store, source, target, sentence, touched, ts) {
+var CITE_ANCHOR_LABELS = /* @__PURE__ */ new Set(["Problem", "Solution", "RootCause", "Pattern", "Claim", "Technique", "AntiPattern"]);
+var CITE_ANCHOR_PROMOTE_SESSIONS = 2;
+var CITE_ANCHOR_MAX_FILES = 4;
+var CITE_ANCHOR_MAX_SESSIONS = 6;
+function accrueCiteAnchor(store, targetId, touched, sessionId, ts) {
+  let fileId;
+  for (const tid of touched) {
+    if (store.getNode(tid)?.label === "File") {
+      fileId = tid;
+      break;
+    }
+  }
+  if (!fileId) return { accrued: false, promoted: false };
+  const node2 = store.getNode(targetId);
+  if (!node2) return { accrued: false, promoted: false };
+  const hints = { ...node2.attrs["citeAnchorHints"] ?? {} };
+  const entry = hints[fileId] ?? [];
+  if (entry.includes(sessionId)) return { accrued: false, promoted: false };
+  if (hints[fileId] === void 0 && Object.keys(hints).length >= CITE_ANCHOR_MAX_FILES) {
+    return { accrued: false, promoted: false };
+  }
+  const grown = [...entry, sessionId].slice(-CITE_ANCHOR_MAX_SESSIONS);
+  let promoted = false;
+  if (grown.length >= CITE_ANCHOR_PROMOTE_SESSIONS) {
+    store.mergeEdge({
+      id: `edge_${digest({ from: targetId, type: "ANCHORED_AT", to: fileId })}`.slice(0, 24),
+      from: targetId,
+      to: fileId,
+      type: "ANCHORED_AT",
+      confidence: 0.3,
+      extractionSource: "agent-observed",
+      createdAt: ts,
+      lastSeenAt: ts,
+      navSuccesses: 0,
+      navFailures: 0,
+      attrs: { provisional: true, captureTime: true, anchorProvenance: "cite-confirmed", citeSessions: grown }
+    });
+    delete hints[fileId];
+    promoted = true;
+  } else {
+    hints[fileId] = grown;
+  }
+  store.updateNode(targetId, { attrs: { ...node2.attrs, citeAnchorHints: hints }, lastUpdatedAt: ts });
+  return { accrued: true, promoted };
+}
+function mintPriorEdge(store, source, target, sentence, touched, ts, sessionId) {
   if (target.id === source.id) return false;
   const type = typePriorEdge(source.label, target.label, sentence);
   const anchorIds = new Set(
@@ -54522,13 +54912,24 @@ function mintPriorEdge(store, source, target, sentence, touched, ts) {
     } catch {
     }
   }
-  return { corroborated };
+  let citeAnchorAccrued = false;
+  let citeAnchorPromoted = false;
+  if (!corroborated && sessionId && CITE_ANCHOR_LABELS.has(target.label)) {
+    try {
+      const acc = accrueCiteAnchor(store, target.id, touched, sessionId, ts);
+      citeAnchorAccrued = acc.accrued;
+      citeAnchorPromoted = acc.promoted;
+    } catch (err2) {
+      console.warn("[errata] cite-anchor accrual failed (citation kept):", err2 instanceof Error ? err2.message : err2);
+    }
+  }
+  return { corroborated, citeAnchorAccrued, citeAnchorPromoted };
 }
 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, corroboratedEdges: 0, exposureShown: 0, exposureEvicted: 0, exposureUnshown: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], unresolvedHandles: [], priorEdgesSuppressed: { flagOff: 0, noSource: 0 }, dispositions: emptyTagDispositions(), transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
+  const plan = { priorEdges: 0, corroboratedEdges: 0, citeAnchorsAccrued: 0, citeAnchorsPromoted: 0, exposureShown: 0, exposureEvicted: 0, exposureUnshown: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], unresolvedHandles: [], priorEdgesSuppressed: { flagOff: 0, noSource: 0 }, dispositions: emptyTagDispositions(), transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
   const parsed = parseInlineTagsWithDispositions(text);
   const tags = parsed.tags;
   plan.dispositions = parsed.dispositions;
@@ -54756,10 +55157,12 @@ function harvestInlineTags(store, text, opts) {
         }
       }
       if (mintPriors && source && target) {
-        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
+        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts, opts.sessionId);
         if (m) {
           plan.priorEdges++;
           if (m.corroborated) plan.corroboratedEdges++;
+          if (m.citeAnchorAccrued) plan.citeAnchorsAccrued++;
+          if (m.citeAnchorPromoted) plan.citeAnchorsPromoted++;
         }
       } else if (target) {
         if (!mintPriors) plan.priorEdgesSuppressed.flagOff++;
@@ -54769,10 +55172,12 @@ function harvestInlineTags(store, text, opts) {
       const targetId = resolveCited(tag.kind, tag.handle);
       const target = targetId ? store.getNode(targetId) : null;
       if (target) {
-        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
+        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts, opts.sessionId);
         if (m) {
           plan.priorEdges++;
           if (m.corroborated) plan.corroboratedEdges++;
+          if (m.citeAnchorAccrued) plan.citeAnchorsAccrued++;
+          if (m.citeAnchorPromoted) plan.citeAnchorsPromoted++;
         }
       }
     } else if (tag.handle) {
@@ -57323,7 +57728,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.1263" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.1274" : "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;
@@ -58169,6 +58574,17 @@ function createWorkspaceEngine(opts) {
     let touchedFileTurns = 0;
     let touchedToolTurns = 0;
     let anchorHintsUpgraded = 0;
+    let foldAttempts = 0;
+    let foldNoFile = 0;
+    let foldNoCandidates = 0;
+    let foldKindVeto = 0;
+    let foldJaccardHit = 0;
+    let foldScoutHit = 0;
+    let foldNearMiss30 = 0;
+    let foldNearMiss45 = 0;
+    let foldCandidatesMarked = 0;
+    let citeAnchorsAccrued = 0;
+    let citeAnchorsPromoted = 0;
     let linked = 0;
     const t = Date.now();
     let processedTurns = 0;
@@ -58312,10 +58728,16 @@ function createWorkspaceEngine(opts) {
           handleMap,
           ts: t,
           mintPriors: elicit,
+          // WM-fold phase 3: cite-time anchor accrual keys on the session — two
+          // DISTINCT sessions co-citing a prior from the same file promote a
+          // real anchor; one session, or none, accrues silently.
+          sessionId,
           ...touched.size > 0 ? { sessionTouchedIds: touched } : {}
         });
         priorEdges += plan.priorEdges;
         corroboratedEdges += plan.corroboratedEdges;
+        citeAnchorsAccrued += plan.citeAnchorsAccrued;
+        citeAnchorsPromoted += plan.citeAnchorsPromoted;
         const refuteResult = applyLocalRefutations(store, plan.refutes, t);
         refutesStamped += refuteResult.stamped;
         for (const c of plan.corroborations) {
@@ -58361,21 +58783,43 @@ function createWorkspaceEngine(opts) {
           const anchorProvenance = p.location?.path ? "witnessed" : "edited";
           const hintPath = anchorPath ? void 0 : turnFile ?? wf;
           const dedupPath = anchorPath ?? hintPath;
+          let pendingNomination = null;
           if (dedupPath) {
             try {
-              const dupId = reinforceSameAnchorProblem(store, dedupPath, profile.id, p.statement, sessionId, t, p.kind);
-              if (dupId) {
+              foldAttempts++;
+              const fold = foldSameAnchorProblem(store, dedupPath, profile.id, p.statement, sessionId, t, p.kind);
+              if (fold.noFile) foldNoFile++;
+              else if (fold.candidates === 0) foldNoCandidates++;
+              foldKindVeto += fold.kindVetoed;
+              if (!fold.foldedId) {
+                if (fold.bestJaccard >= 0.45) foldNearMiss45++;
+                else if (fold.bestJaccard >= 0.3) foldNearMiss30++;
+                if (fold.nominate) {
+                  pendingNomination = { ...fold.nominate, source: "file-scout" };
+                }
+              }
+              if (fold.foldedId) {
+                if (fold.foldedBy === "scout") foldScoutHit++;
+                else foldJaccardHit++;
                 minted++;
                 if (p.kind !== "constraint") {
-                  sessionLastProblem.set(sessionId, dupId);
-                  inScopeProblemId = dupId;
+                  sessionLastProblem.set(sessionId, fold.foldedId);
+                  inScopeProblemId = fold.foldedId;
                 }
-                if (p.threadId) threads.set(p.threadId, dupId);
+                if (p.threadId) threads.set(p.threadId, fold.foldedId);
                 continue;
               }
             } catch {
             }
           }
+          if (!pendingNomination) {
+            try {
+              const ws = findWorkspaceFoldCandidate(store, profile.id, p.statement, p.kind);
+              if (ws) pendingNomination = { ...ws, source: "workspace-scout" };
+            } catch (err2) {
+              console.warn("[errata] workspace fold scout failed (mint unaffected):", err2 instanceof Error ? err2.message : err2);
+            }
+          }
           const r = ingestDesignProblem(store, { problem: p.statement, kind: p.kind }, {
             workspaceId: profile.id,
             source: sessionId,
@@ -58413,6 +58857,19 @@ function createWorkspaceEngine(opts) {
               );
             }
           }
+          if (r.created && pendingNomination) {
+            try {
+              const marked = markFoldCandidate(store, r.problemId, pendingNomination.targetId, {
+                ...pendingNomination.hashCos !== void 0 ? { hashCos: pendingNomination.hashCos } : {},
+                ...pendingNomination.jaccard !== void 0 ? { jaccard: pendingNomination.jaccard } : {},
+                source: pendingNomination.source,
+                ts: t
+              });
+              if (marked) foldCandidatesMarked++;
+            } catch (err2) {
+              console.warn("[errata] fold nomination failed (mint unaffected):", err2 instanceof Error ? err2.message : err2);
+            }
+          }
           if (r.created || r.corroborated) {
             minted++;
             if (p.kind !== "constraint") {
@@ -58834,6 +59291,20 @@ function createWorkspaceEngine(opts) {
         exposureOutcomes: exposureShown + exposureEvicted + exposureUnshown,
         // AC-hint-upgrade (harvest seam): edited-this-turn hint promotions.
         anchorHintsUpgraded,
+        // WM-fold funnel (phase 0) — which gate of the same-anchor fold
+        // conjunction eats the mass, and the near-miss bands under the bars.
+        foldAttempts,
+        foldNoFile,
+        foldNoCandidates,
+        foldKindVeto,
+        foldJaccardHit,
+        foldScoutHit,
+        foldNearMiss30,
+        foldNearMiss45,
+        foldCandidatesMarked,
+        // WM-fold phase 3 — cite-time anchor accrual on cited priors.
+        citeAnchorsAccrued,
+        citeAnchorsPromoted,
         touchedFileTurns,
         touchedToolTurns,
         // Seam diagnostic: sessions holding tool-run records at harvest time.
@@ -59006,6 +59477,22 @@ function createWorkspaceEngine(opts) {
     });
   };
   const designRollup = opts.designRollup ?? (process.env["ERRATA_ROLLUP"] === "1" ? haikuDesignRollup(process.env["ANTHROPIC_API_KEY"] ?? null) : void 0);
+  const foldJudgeModel = process.env["ERRATA_FOLD_JUDGE_MODEL"] ?? "gpt-5-mini";
+  const foldJudge = process.env["ERRATA_FOLD_JUDGE"] === "1" && isChatConfigured(foldJudgeModel) ? async (a, b) => {
+    const out2 = await chat({
+      model: foldJudgeModel,
+      system: "You judge whether two independently-written one-line problem reports from the same codebase describe the SAME underlying problem. Reworded restatements of one problem are SAME; related-but-different defects, or a defect vs a design constraint, are DISTINCT. Answer with exactly one word: SAME or DISTINCT.",
+      user: `A: ${a}
+B: ${b}`,
+      maxTokens: 8
+    });
+    if (!out2) return null;
+    const same = /\bSAME\b/i.test(out2);
+    const distinct = /\bDISTINCT\b/i.test(out2);
+    if (same && !distinct) return "same";
+    if (distinct && !same) return "distinct";
+    return null;
+  } : void 0;
   const onSessionEnd = (e) => {
     if (!designRollup) return;
     setImmediate(() => {
@@ -59297,6 +59784,27 @@ function createWorkspaceEngine(opts) {
           console.warn(`[errata] REGRESSION: bound ${rg.bound} open problem(s) to resolved predecessors${rg.full ? " (first full sweep)" : ""}`);
           refreshContextNow();
         }
+        const fjStart = Date.now();
+        const fj = await resolveFoldCandidates(store, {
+          ts: fjStart,
+          ...foldJudge ? { judge: foldJudge } : {}
+        });
+        if (fj.examined > 0) {
+          appendPassLedger(paths.configDir, "fold-judge", Date.now() - fjStart, {
+            examined: fj.examined,
+            folded: fj.folded,
+            foldedEmbedding: fj.foldedEmbedding,
+            foldedJudge: fj.foldedJudge,
+            rejected: fj.rejected,
+            standing: fj.standing,
+            judgeErrors: fj.judgeErrors,
+            retargeted: fj.retargeted
+          });
+          if (fj.folded > 0) {
+            console.log(`[errata] fold-judge: folded ${fj.folded} paraphrase pair(s) (${fj.foldedEmbedding} by embedding, ${fj.foldedJudge} by judge), ${fj.standing} standing`);
+            refreshContextNow();
+          }
+        }
         return { embedded: sem.embedded };
       } catch (err2) {
         console.warn("[errata] settled embed failed:", err2);

package/package.json

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

package/pass-worker.mjs

@@ -25734,11 +25734,16 @@ function foldDuplicateProblem(store2, dup, survivor, ts) {
   if (!surv) return;
   const sources = new Set(surv.attrs["sources"] ?? []);
   for (const s of dup.attrs["sources"] ?? []) sources.add(s);
+  const dupSeq = dup.attrs["createdAtSeq"] ?? store2.currentIngestSeq();
+  const exposure = priorExposure(store2, survivor.id, dupSeq);
+  const expField = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
   store2.updateNode(survivor.id, {
     attrs: {
       ...surv.attrs,
       sources: [...sources],
-      corroborations: corroborations(surv) + corroborations(dup) + 1
+      corroborations: corroborations(surv) + corroborations(dup) + 1,
+      [expField]: (surv.attrs[expField] ?? 0) + 1,
+      lastReinforceExposure: exposure
     },
     cumulativeHits: (surv.cumulativeHits ?? 0) + (dup.cumulativeHits ?? 0),
     lastUpdatedAt: ts
@@ -25954,6 +25959,16 @@ function clearSettledFixCandidates(store2, t) {
   }
   return report;
 }
+function priorExposure(store2, nodeId, atSeq) {
+  const n = store2.getNode(nodeId);
+  if (!n || !n.attrs) return "unshown";
+  const shownSeq = n.attrs["lastShownAtSeq"];
+  if (shownSeq !== void 0 && shownSeq <= atSeq) return "shown";
+  const evictedSeq = n.attrs["lastEvictedAtSeq"];
+  if (evictedSeq !== void 0 && evictedSeq <= atSeq) return "evicted";
+  if ((n.attrs["evictedCount"] ?? 0) > 0) return "evicted";
+  return "unshown";
+}
 
 // ../../packages/local-graph/src/intent.ts
 init_src();