@inerrata-corporation/errata 2.0.0-dev.86 → 2.0.0-dev.88

package/package.json

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

package/pass-worker.mjs

@@ -24787,6 +24787,13 @@ function addDependency(store2, opts) {
   store2.mergeEdge(edge);
   return edge;
 }
+function markRevisit(store2, node, reason, ts) {
+  const fresh = store2.getNode(node.id) ?? node;
+  store2.updateNode(node.id, {
+    attrs: { ...fresh.attrs, revisit: true, revisitReason: reason, revisitSinceTs: ts },
+    lastUpdatedAt: ts
+  });
+}
 function listNeedsRevisit(store2, asOf) {
   return store2.nodesAsOf(asOf).filter((n) => n.attrs["revisit"] === true).map((n) => ({
     id: n.id,
@@ -25190,6 +25197,15 @@ function priorsForFile(store2, relPath) {
   openProblems.sort((a, b) => (b.lastUpdatedAt ?? 0) - (a.lastUpdatedAt ?? 0));
   return { file: file2, openProblems, related: [...related.values()], solutionsByProblem };
 }
+function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
+  const p = store2.getNode(problemId);
+  if (!p || p.label !== "Problem") return false;
+  if (p.attrs["anchorHint"]) return false;
+  store2.updateNode(problemId, {
+    attrs: { ...p.attrs, anchorHint: { path: relPath, provenance, ts } }
+  });
+  return true;
+}
 function resolveDesignProblems(store2, t) {
   let resolved = 0;
   for (const p of store2.findNodesByLabel("Problem")) {
@@ -25233,6 +25249,69 @@ function resolveDesignProblems(store2, t) {
   return resolved;
 }
 
+// ../../packages/local-graph/src/anchor-backfill.ts
+var AUTO_MINT_PREFIX = "addressed by an edit to ";
+function isLegacyAnchor(attrs) {
+  return attrs?.["captureTime"] === true && attrs["anchorProvenance"] === void 0;
+}
+function backfillLegacyAnchors(store2, ts) {
+  const report = {
+    demotedEdges: 0,
+    demotedProblems: 0,
+    labeledEdges: 0,
+    suspects: []
+  };
+  for (const p of store2.findNodesByLabel("Problem")) {
+    const legacy = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => isLegacyAnchor(e.attrs));
+    if (legacy.length === 0) continue;
+    const resolved = p.attrs["resolvedAt"] !== void 0;
+    try {
+      if (!resolved) {
+        for (const e of legacy) {
+          const file2 = store2.getNode(e.to);
+          const path = String(file2?.attrs["relPath"] ?? file2?.description ?? "");
+          if (path) recordAnchorHint(store2, p.id, path, "legacy", ts);
+          store2.deleteEdge(e.id);
+          report.demotedEdges++;
+        }
+        report.demotedProblems++;
+        continue;
+      }
+      for (const e of legacy) {
+        store2.mergeEdge({ ...e, attrs: { ...e.attrs, anchorProvenance: "legacy" }, lastSeenAt: ts });
+        report.labeledEdges++;
+      }
+      for (const se of store2.outEdges(p.id, ["SOLVED_BY"])) {
+        const sol = store2.getNode(se.to);
+        if (!sol || !sol.description.startsWith(AUTO_MINT_PREFIX)) continue;
+        const guessedAnchor = sol.description.slice(AUTO_MINT_PREFIX.length);
+        store2.updateNode(sol.id, {
+          attrs: { ...sol.attrs, provisional: true, resolutionSuspect: true },
+          lastUpdatedAt: ts
+        });
+        markRevisit(
+          store2,
+          sol,
+          `auto-closed off a pre-provenance anchor (guessed ${guessedAnchor}) \u2014 confirm the problem is really fixed, or reopen it`,
+          ts
+        );
+        store2.updateNode(p.id, {
+          attrs: { ...p.attrs, resolutionSuspect: true },
+          lastUpdatedAt: ts
+        });
+        report.suspects.push({
+          problemId: p.id,
+          problem: p.description,
+          solutionId: sol.id,
+          guessedAnchor
+        });
+      }
+    } catch {
+    }
+  }
+  return report;
+}
+
 // ../../packages/local-graph/src/percolate.ts
 init_src2();
 
@@ -25976,9 +26055,11 @@ function buildSnapshot(opts) {
   };
   const langNodes = opts.store.findNodesByLabel("Language");
   const pkgNodes = opts.store.findNodesByLabel("Package");
+  const toolNodes = opts.store.findNodesByLabel("Tool").sort((a, b) => (b.cumulativeHits ?? 0) - (a.cumulativeHits ?? 0)).slice(0, 5);
   const profileContext = {
     languages: opts.profile.languages.map((name2) => ({ name: name2, node: matchNode(langNodes, name2) })),
-    packages: opts.profile.stack.map((name2) => ({ name: name2, node: matchNode(pkgNodes, pkgBase(name2)) }))
+    packages: opts.profile.stack.map((name2) => ({ name: name2, node: matchNode(pkgNodes, pkgBase(name2)) })),
+    tools: toolNodes.map((node) => ({ name: String(node.attrs["name"] ?? node.description), node }))
   };
   const causalNudge = recent.length >= 2 && recent.every(
     (r) => opts.store.outEdges(r.node.id, ["CAUSED_BY"]).length === 0 && opts.store.inEdges(r.node.id, ["CAUSED_BY"]).length === 0
@@ -26234,6 +26315,14 @@ async function runReindex(p) {
   return { ...r, identityEvaluations };
 }
 function runNightly() {
+  let anchorsDemoted = 0;
+  let resolutionsSuspect = 0;
+  try {
+    const a = backfillLegacyAnchors(store, Date.now());
+    anchorsDemoted = a.demotedEdges;
+    resolutionsSuspect = a.suspects.length;
+  } catch {
+  }
   const report = runNightlyPipeline(store);
   let merged = 0;
   let clusters = 0;
@@ -26251,6 +26340,6 @@ function runNightly() {
     backfillProblemContext(store, Date.now());
   } catch {
   }
-  return { report, merged, clusters, localSkills: 0, skillsWritten: 0, skillsPruned: 0 };
+  return { report, merged, clusters, localSkills: 0, skillsWritten: 0, skillsPruned: 0, anchorsDemoted, resolutionsSuspect };
 }
 port.postMessage({ ready: true });