@inerrata-corporation/errata 2.0.2-dev.245 → 2.0.2-dev.249

package/package.json

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

package/pass-worker.mjs

@@ -24081,7 +24081,22 @@ var LOCAL_RULE_OVERRIDES = {
   REVEALED_BY: null,
   PRODUCED: null
 };
-var SCHEMA_VERSION = 5;
+function localEdgeViolation(fromLabel, type, toLabel) {
+  if (type in LOCAL_RULE_OVERRIDES) {
+    const rule = LOCAL_RULE_OVERRIDES[type];
+    if (!rule) return null;
+    if (fromLabel && rule.from && !rule.from.includes(fromLabel)) {
+      return `${type} cannot originate from ${fromLabel} locally (allowed: ${rule.from.join(", ")})`;
+    }
+    if (toLabel && rule.to && !rule.to.includes(toLabel)) {
+      return `${type} cannot target ${toLabel} locally (allowed: ${rule.to.join(", ")})`;
+    }
+    return null;
+  }
+  const verdict = isValidEdge(fromLabel, type, toLabel);
+  return verdict.ok ? null : verdict.reason ?? "edge rule violation";
+}
+var SCHEMA_VERSION = 6;
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_version (
   version INTEGER PRIMARY KEY
@@ -24096,6 +24111,21 @@ CREATE TABLE IF NOT EXISTS store_meta (
   value TEXT NOT NULL
 );
 
+-- Durable ledger of edges the ontology gate REFUSED, keyed by edge type.
+-- Durable rather than in-memory for one specific reason: the status command runs
+-- in a SEPARATE process and opens its own store handle, so a counter living on
+-- the instance reads 0 there forever. That is exactly how a producer rejecting
+-- 100% of its output stayed invisible for 17 days. Persisting it also survives
+-- the daemon restart that would otherwise erase the evidence.
+-- Keyed by type because a systematic producer bug shows up as ONE type
+-- dominating; sample keeps the latest reason so the count is actionable.
+CREATE TABLE IF NOT EXISTS edge_rejections (
+  type TEXT PRIMARY KEY,
+  count INTEGER NOT NULL DEFAULT 0,
+  last_at INTEGER NOT NULL,
+  sample TEXT
+);
+
 CREATE TABLE IF NOT EXISTS nodes (
   id TEXT PRIMARY KEY,
   label TEXT NOT NULL,
@@ -24472,6 +24502,16 @@ var SqliteGraphStore = class {
           if (!cols.has(name2)) this.db.exec(ddl);
         }
       }
+      if (from < 6) {
+        this.db.exec(`
+          CREATE TABLE IF NOT EXISTS edge_rejections (
+            type TEXT PRIMARY KEY,
+            count INTEGER NOT NULL DEFAULT 0,
+            last_at INTEGER NOT NULL,
+            sample TEXT
+          )
+        `);
+      }
       this.db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
     });
   }
@@ -24553,6 +24593,7 @@ var SqliteGraphStore = class {
     const violation = this.edgeRuleViolation(edge);
     if (violation) {
       this.rejectedEdgeCount++;
+      this.recordEdgeRejection(edge.type, violation, edge.lastSeenAt || edge.createdAt || 0);
       console.warn(`[local-graph] rejected edge ${edge.from}-[:${edge.type}]->${edge.to}: ${violation}`);
       return;
     }
@@ -24577,22 +24618,51 @@ var SqliteGraphStore = class {
    *  overlay consulted first. Returns the reason string on a documented-
    *  forbidden combination, else null. Point lookups on the id PK — negligible
    *  next to the insert itself. */
-  edgeRuleViolation(edge) {
-    const fromLabel = this.getNode(edge.from)?.label;
-    const toLabel = this.getNode(edge.to)?.label;
-    if (edge.type in LOCAL_RULE_OVERRIDES) {
-      const rule = LOCAL_RULE_OVERRIDES[edge.type];
-      if (!rule) return null;
-      if (fromLabel && rule.from && !rule.from.includes(fromLabel)) {
-        return `${edge.type} cannot originate from ${fromLabel} locally (allowed: ${rule.from.join(", ")})`;
-      }
-      if (toLabel && rule.to && !rule.to.includes(toLabel)) {
-        return `${edge.type} cannot target ${toLabel} locally (allowed: ${rule.to.join(", ")})`;
-      }
-      return null;
+  /** Upsert one refusal into the durable ledger. Best-effort: a bookkeeping
+   *  failure must never turn a refused edge into a thrown write. */
+  recordEdgeRejection(type, reason, at) {
+    try {
+      this.db.prepare(
+        `INSERT INTO edge_rejections (type, count, last_at, sample) VALUES (?, 1, ?, ?)
+           ON CONFLICT(type) DO UPDATE SET
+             count = count + 1, last_at = excluded.last_at, sample = excluded.sample`
+      ).run(type, at, reason.slice(0, 200));
+    } catch {
+    }
+  }
+  /** Refusals recorded by the ontology gate, per edge type, newest activity first.
+   *  Durable across restarts and readable from any process (see the table note). */
+  edgeRejections() {
+    try {
+      return this.db.prepare(
+        "SELECT type, count, last_at AS lastAt, sample FROM edge_rejections ORDER BY count DESC, last_at DESC"
+      ).all();
+    } catch {
+      return [];
+    }
+  }
+  /** Drop ledger entries whose last refusal predates `cutoff`. A still-misbehaving
+   *  producer keeps refreshing `last_at` and survives; a fixed one fades out. */
+  pruneEdgeRejections(cutoff) {
+    try {
+      this.db.prepare("DELETE FROM edge_rejections WHERE last_at < ?").run(cutoff);
+    } catch {
     }
-    const verdict = isValidEdge(fromLabel, edge.type, toLabel);
-    return verdict.ok ? null : verdict.reason ?? "edge rule violation";
+  }
+  /** Clear the ledger outright, whole or per type — operator escape hatch. */
+  clearEdgeRejections(type) {
+    try {
+      if (type) this.db.prepare("DELETE FROM edge_rejections WHERE type = ?").run(type);
+      else this.db.exec("DELETE FROM edge_rejections");
+    } catch {
+    }
+  }
+  edgeRuleViolation(edge) {
+    return localEdgeViolation(
+      this.getNode(edge.from)?.label,
+      edge.type,
+      this.getNode(edge.to)?.label
+    );
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -24729,6 +24799,32 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare("SELECT from_id, to_id, type FROM edges WHERE valid_to IS NULL").all();
     return rows.map((r) => ({ from: r.from_id, to: r.to_id, type: r.type }));
   }
+  /**
+   * Live edges WITH their endpoint labels and ids, resolved in ONE join.
+   *
+   * The ontology sweep needs (id, type, fromLabel, toLabel) for every live edge.
+   * Doing that as `scanLiveEdges()` + two `getNode()` calls is 2N node reads —
+   * 550,000 on this store — and each one deserializes the node's embedding blob.
+   * Measured: the sweep did not finish in 10 minutes. As a single join it is one
+   * query over an index-covered scan. Labels only; nothing here touches embeddings.
+   */
+  scanLiveEdgeRows() {
+    const rows = this.db.prepare(
+      `SELECT e.id, e.from_id, e.to_id, e.type, a.label AS from_label, b.label AS to_label
+         FROM edges e
+         LEFT JOIN nodes a ON a.id = e.from_id AND a.valid_to IS NULL
+         LEFT JOIN nodes b ON b.id = e.to_id   AND b.valid_to IS NULL
+         WHERE e.valid_to IS NULL`
+    ).all();
+    return rows.map((r) => ({
+      id: r.id,
+      from: r.from_id,
+      to: r.to_id,
+      type: r.type,
+      fromLabel: r.from_label ?? void 0,
+      toLabel: r.to_label ?? void 0
+    }));
+  }
   /** Live nodes whose attrs.relPath is one of `relPaths`. Uses the nodes_relpath
    *  expression index so the incremental reindex fetches only the changed files'
    *  symbols instead of scanning every versioned node. */