@inerrata-corporation/errata 2.0.2-dev.261 → 2.0.2-dev.282

package/errata.mjs

@@ -20500,6 +20500,56 @@ function induceTriage(l2, opts) {
   }
   return report;
 }
+function pendingDiscriminators(l2, opts = {}) {
+  const minSources = opts.minSources ?? 1;
+  const minObservations = opts.minObservations ?? 2;
+  const out2 = [];
+  for (const triage of l2.findNodesByLabel("Triage")) {
+    for (const e of l2.outEdges(triage.id, [...ROUTE_EDGE_TYPES])) {
+      if (isRouterRoute(e)) continue;
+      if (typeof e.attrs["discriminator"] === "string") continue;
+      if (opts.onlyUnsurfaced && e.attrs["discriminatorAsked"] === true) continue;
+      const perContext = e.attrs["perContext"] ?? {};
+      const global2 = perContext[TRIAGE_GLOBAL_BUCKET] ?? {};
+      const observations = Number(global2.confirmed ?? 0);
+      const sources = new Set(global2.contributors ?? []).size;
+      if (sources < minSources || observations < minObservations) continue;
+      out2.push({ route: e.id, presenting: triage.description, cause: "", sources, observations, causeId: e.to });
+    }
+  }
+  out2.sort((a, b) => b.sources - a.sources || b.observations - a.observations);
+  const top = typeof opts.limit === "number" ? out2.slice(0, opts.limit) : out2;
+  for (const p of top) p.cause = l2.getNode(p.causeId)?.description ?? "(missing cause)";
+  return top;
+}
+function markDiscriminatorAsked(l2, routeIds, ts) {
+  for (const id of routeIds) {
+    const e = l2.getEdge(id);
+    if (!e) continue;
+    l2.updateEdge(id, { attrs: { ...e.attrs, discriminatorAsked: true }, lastSeenAt: ts });
+  }
+}
+function promoteRouteWithDiscriminator(l2, routeId, discriminator, ts, source) {
+  const test = discriminator.trim();
+  if (!test) return false;
+  const existing = l2.getEdge(routeId);
+  if (!existing || !ROUTE_EDGE_TYPES.includes(existing.type)) return false;
+  const attrs = {
+    ...existing.attrs,
+    discriminator: test,
+    provisional: false,
+    ...source ? { discriminatorSource: source } : {}
+  };
+  delete attrs["discriminatorAsked"];
+  const wantType = routeTypeFor(false);
+  if (existing.type === wantType) {
+    l2.updateEdge(routeId, { attrs, lastSeenAt: ts });
+    return true;
+  }
+  l2.deleteEdge(routeId);
+  l2.mergeEdge({ ...existing, type: wantType, attrs, lastSeenAt: ts });
+  return true;
+}
 function revisitStaleRoutes(l2, ts, opts = {}) {
   const minNavFailures = opts.minNavFailures ?? 3;
   const report = { flagged: 0, demoted: 0 };
@@ -20560,15 +20610,20 @@ function parseTriageFences(text) {
   while ((m = block.exec(text)) !== null) {
     const fields = {};
     for (const line of m[1].split(/\r?\n/)) {
-      const kv = /^\s*(presenting|cause|test|fix|drift)\s*:\s*(.+?)\s*$/i.exec(line);
+      const kv = /^\s*(presenting|cause|test|fix|drift|route)\s*:\s*(.+?)\s*$/i.exec(line);
       if (kv) fields[kv[1].toLowerCase()] = kv[2].trim();
     }
+    if (fields["route"] && fields["test"]) {
+      out2.push({ presenting: "", cause: "", route: fields["route"], test: fields["test"] });
+      continue;
+    }
     if (!fields["presenting"] || !fields["cause"]) continue;
     const drift = fields["drift"]?.toLowerCase();
     out2.push({
       presenting: fields["presenting"],
       cause: fields["cause"],
       ...fields["test"] ? { test: fields["test"] } : {},
+      ...fields["route"] ? { route: fields["route"] } : {},
       ...fields["fix"] ? { fix: fields["fix"] } : {},
       ...drift && DRIFT_VALUES.has(drift) ? { drift } : {}
     });
@@ -20577,7 +20632,12 @@ function parseTriageFences(text) {
 }
 function harvestTriageFences(l2, text, opts) {
   let recorded = 0;
+  let promoted = 0;
   for (const f of parseTriageFences(text)) {
+    if (f.route && f.test) {
+      if (promoteRouteWithDiscriminator(l2, f.route.trim(), f.test, opts.ts, opts.contributor)) promoted++;
+      continue;
+    }
     const cause = f.cause.trim();
     const causeId = `dcause_${digest({ statement: cause })}`.slice(0, 56);
     recordTriageObservation(
@@ -20608,7 +20668,7 @@ function harvestTriageFences(l2, text, opts) {
     }
     recorded++;
   }
-  return { recorded };
+  return { recorded, promoted };
 }
 var COOCCUR_BONUS, routeEdgeId, ROUTE_EDGE_TYPES, routeTypeFor, isRouterRoute, INDUCTED_MARK, DRIFT_VALUES;
 var init_triage2 = __esm({
@@ -20981,6 +21041,7 @@ __export(src_exports2, {
   linkProblemToSymbols: () => linkProblemToSymbols,
   listNeedsRevisit: () => listNeedsRevisit,
   localEdgeViolation: () => localEdgeViolation,
+  markDiscriminatorAsked: () => markDiscriminatorAsked,
   markRevisit: () => markRevisit,
   matchLanguagesInText: () => matchLanguagesInText,
   matchPackagesInText: () => matchPackagesInText,
@@ -20997,8 +21058,10 @@ __export(src_exports2, {
   parseSemver: () => parseSemver,
   parseTriageFences: () => parseTriageFences,
   pendingAbstractions: () => pendingAbstractions,
+  pendingDiscriminators: () => pendingDiscriminators,
   percolate: () => percolate,
   priorsForFile: () => priorsForFile,
+  promoteRouteWithDiscriminator: () => promoteRouteWithDiscriminator,
   propagateFactChange: () => propagateFactChange,
   propagateVersionChange: () => propagateVersionChange,
   rankToolsForHandles: () => rankToolsForHandles,
@@ -36969,6 +37032,36 @@ function takeEnrichmentNudge(store) {
   return `\u26A1 errata \u2014 ${pulls.length} recent fix(es) await a one-line root cause (optional, answer in-flow):
 ` + items;
 }
+function takeDiscriminatorNudge(path2) {
+  if (!path2 || !existsSync10(path2)) return null;
+  let shared;
+  try {
+    shared = openGraphStore({ path: path2 });
+  } catch {
+    return null;
+  }
+  try {
+    const pending = pendingDiscriminators(shared, { limit: 1, onlyUnsurfaced: true });
+    const top = pending[0];
+    if (!top) return null;
+    markDiscriminatorAsked(shared, [top.route], Date.now());
+    return [
+      `\u26A1 errata \u2014 a known wrong-door is one field from ranking: "${top.presenting.slice(0, 90)}"`,
+      `  usually turns out to be: ${top.cause.slice(0, 90)}  (seen ${top.observations}x)`,
+      "  Know a CHEAP check that confirms it? Answer in-flow \u2014 it promotes the route so the",
+      "  next agent gets it first. Only if you actually know one: a guessed test ranks first",
+      "  and misroutes everyone after you.",
+      "  ```errata-triage",
+      `  route: ${top.route}`,
+      "  test: <the cheap check>",
+      "  ```"
+    ].join("\n");
+  } catch {
+    return null;
+  } finally {
+    shared.close();
+  }
+}
 function commentAnchorId(store, commentId) {
   const out2 = store.outEdges(commentId, ["EXPLAINS", "ANNOTATES"]);
   if (out2.length > 0) return out2[0].to;
@@ -37176,6 +37269,7 @@ function createMcpHandler(store, ctx = {}) {
   let auditReadRun = 0;
   let toolCallIndex = 0;
   let lastAuditNudgeAt = Number.NEGATIVE_INFINITY;
+  let lastDiscriminatorNudgeAt = Number.NEGATIVE_INFINITY;
   return async function handle2(req) {
     const id = req.id ?? null;
     const isNotification = req.id === void 0;
@@ -37222,6 +37316,7 @@ function createMcpHandler(store, ctx = {}) {
             { type: "text", text: JSON.stringify(out2, null, 2) }
           ];
           const isEnrichmentTool = params.name === "errata.pending_enrichment" || params.name === "errata.annotate_resolution";
+          const isTriageTool = params.name === "errata.pending_discriminators" || params.name === "errata.triage";
           toolCallIndex++;
           auditReadRun = isEnrichmentTool ? 0 : auditReadRun + 1;
           if (!isEnrichmentTool) {
@@ -37233,6 +37328,13 @@ function createMcpHandler(store, ctx = {}) {
             lastAuditNudgeAt = toolCallIndex;
             auditReadRun = 0;
           }
+          if (!isTriageTool && content.length === 1 && toolCallIndex - lastDiscriminatorNudgeAt >= DISCRIMINATOR_NUDGE_COOLDOWN) {
+            const disc = takeDiscriminatorNudge(ctx.sharedDbPath);
+            if (disc) {
+              content.push({ type: "text", text: disc });
+              lastDiscriminatorNudgeAt = toolCallIndex;
+            }
+          }
           return { jsonrpc: "2.0", id, result: { content } };
         }
         default:
@@ -37282,7 +37384,11 @@ async function runMcpServer(workspaceRoot) {
     }
     return summariesMemo.map;
   };
-  const handle2 = createMcpHandler(store, { ...buildToolContext(), symbolSummaries });
+  const handle2 = createMcpHandler(store, {
+    ...buildToolContext(),
+    symbolSummaries,
+    sharedDbPath: sharedStorePath()
+  });
   process.stdin.setEncoding("utf8");
   let buffer = "";
   process.stdin.on("data", (chunk) => {
@@ -37310,7 +37416,7 @@ async function runMcpServer(workspaceRoot) {
     if (resp) process.stdout.write(JSON.stringify(resp) + "\n");
   }
 }
-var INSTRUCTIONS, AUDIT_RUN_THRESHOLD, AUDIT_NUDGE_COOLDOWN, AUDIT_FLAG_NUDGE, TOOLS;
+var INSTRUCTIONS, AUDIT_RUN_THRESHOLD, AUDIT_NUDGE_COOLDOWN, DISCRIMINATOR_NUDGE_COOLDOWN, AUDIT_FLAG_NUDGE, TOOLS;
 var init_mcp = __esm({
   "src/mcp.ts"() {
     "use strict";
@@ -37371,6 +37477,7 @@ var init_mcp = __esm({
     ].join("\n");
     AUDIT_RUN_THRESHOLD = 5;
     AUDIT_NUDGE_COOLDOWN = 12;
+    DISCRIMINATOR_NUDGE_COOLDOWN = 40;
     AUDIT_FLAG_NUDGE = "\u26A1 errata \u2014 reading/auditing? anything you notice that's off, flag it inline as `[!one line]` (`[?\u2026]` = TODO) \u2014 no tool call, we harvest it.";
     TOOLS = [
       {
@@ -38396,6 +38503,47 @@ var init_mcp = __esm({
           }
         }
       },
+      {
+        name: "errata.pending_discriminators",
+        description: "Routes awaiting the ONE field that promotes them to routers (PLAN_TRIAGE). A route is a known wrong-door \u2014 symptom S usually turns out to be cause C \u2014 but it only ranks as a ROUTER once someone supplies its `discriminator`: the cheap ante-hoc test that confirms C before you commit. Returns provisional routes corroborated by 2+ DISTINCT CONTRIBUTORS, most-corroborated first; these are one field away from ranking every future `errata.triage` on that symptom. Answer only where you actually know a cheap check \u2014 a guessed test is worse than none, because it ranks first and sends the next agent down it. Empty = nothing awaiting. Reads the machine-wide shared store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "number", description: "Max routes to return (default 10)." },
+            minSources: { type: "number", description: "Min distinct contributors behind the route (default 2)." }
+          }
+        },
+        handler: (args2) => {
+          const path2 = sharedStorePath();
+          if (!existsSync10(path2)) return { count: 0, pending: [] };
+          const shared = openGraphStore({ path: path2 });
+          try {
+            const pending = pendingDiscriminators(shared, {
+              limit: typeof args2?.limit === "number" ? args2.limit : 10,
+              ...typeof args2?.minSources === "number" ? { minSources: args2.minSources } : {}
+            });
+            return {
+              count: pending.length,
+              pending,
+              ...pending.length > 0 ? {
+                howToAnswer: [
+                  "For each route you know a cheap test for, emit an errata-triage fence",
+                  "carrying its `route` id and the `test` \u2014 no presenting/cause needed, the",
+                  "route id identifies both endpoints. Attaching a test does NOT count as",
+                  "another sighting, so it cannot inflate the route's evidence.",
+                  "",
+                  "```errata-triage",
+                  "route: <route id from above>",
+                  "test: <the cheap check that confirms this cause>",
+                  "```"
+                ].join("\n")
+              } : {}
+            };
+          } finally {
+            shared.close();
+          }
+        }
+      },
       {
         name: "errata.triage",
         description: "Before you chase a problem, TRIAGE it \u2014 is it a known wrong-door? (PLAN_TRIAGE). Pass the problem you're about to work on (`problem`: a one-line statement, or `id`: a dprob_\u2026 id) and YOUR context (`stack`, `domain`) so the probabilities are conditioned on it \u2014 a symptom routes to different causes on different stacks. Returns the differential: candidate causes ranked router-first then by context-conditioned probability \u2014 {route, cause:{description}, probability, sampleSize, trust, router, discriminator, solutions:[\u2026]}. `probability` is P(cause | symptom, your context); `trust`/`sampleSize` tell you how much evidence stands behind it. Run the top router's `discriminator` (a cheap check) before committing. Empty = not a known wrong-door. Reads the machine-wide shared store.",
@@ -52664,7 +52812,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.261" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.282" : "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;
@@ -54537,8 +54685,8 @@ function contributedWireId(n) {
   return isMembraneSaltedId(cloudId) ? cloudId : n.id;
 }
 var WIRE_CANONICAL_ID_MIN = 6;
-function unshippableReason(n) {
-  const canonical = typeof n.attrs?.["canonicalId"] === "string" ? n.attrs["canonicalId"] : n.id;
+function unshippableReason(canonical, label) {
+  void label;
   if (canonical.length < WIRE_CANONICAL_ID_MIN) {
     return `canonicalId "${canonical}" is ${canonical.length} chars; the door requires >= ${WIRE_CANONICAL_ID_MIN}`;
   }
@@ -54552,6 +54700,9 @@ function wireContextId(n) {
   if (n.label === "Domain" && n.attrs["source"] !== "cloud") {
     return String(n.attrs["canonicalId"] ?? n.id);
   }
+  if (n.label === "Component" && n.attrs["source"] !== "cloud") {
+    return String(n.attrs["canonicalId"] ?? n.id);
+  }
   return n.id;
 }
 function langAnchor(t) {
@@ -54621,7 +54772,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
       }
       if (label === "Solution" && n.description.startsWith(AUTO_MINT_PREFIX)) continue;
       if (!noveltyAgainst(n, ref, noveltyOpts).ready) continue;
-      const reject = unshippableReason(n);
+      const reject = unshippableReason(n.id, n.label);
       if (reject) {
         console.warn(`[errata] skipping unshippable node ${n.id} (${n.label}): ${reject}`);
         continue;
@@ -54675,7 +54826,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     anchorDigests[sourceId] = dg;
     const wireFrom = seen.has(sourceId) || !sourceNode ? sourceId : contributedWireId(sourceNode);
     for (const { e, t, wireId } of targets) {
-      const reject = unshippableReason({ id: wireId, label: t.label, attrs: t.attrs });
+      const reject = unshippableReason(wireId, t.label);
       if (reject) {
         console.warn(`[errata] skipping unshippable anchor ${wireId} (${t.label}): ${reject}`);
         continue;

package/package.json

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