@inerrata-corporation/errata 2.0.2-dev.227 → 2.0.2-dev.247

package/errata.mjs

@@ -16410,6 +16410,21 @@ var init_src2 = __esm({
 });
 
 // ../../packages/local-graph/src/store.ts
+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";
+}
 function encodeEmbedding(emb) {
   if (!emb || emb.length === 0) return null;
   const f = Float32Array.from(emb);
@@ -16484,7 +16499,7 @@ var init_store = __esm({
       REVEALED_BY: null,
       PRODUCED: null
     };
-    SCHEMA_VERSION = 5;
+    SCHEMA_VERSION = 6;
     SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_version (
   version INTEGER PRIMARY KEY
@@ -16499,6 +16514,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,
@@ -16818,6 +16848,16 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
               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);
         });
       }
@@ -16899,6 +16939,7 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         const violation = this.edgeRuleViolation(edge2);
         if (violation) {
           this.rejectedEdgeCount++;
+          this.recordEdgeRejection(edge2.type, violation, edge2.lastSeenAt || edge2.createdAt || 0);
           console.warn(`[local-graph] rejected edge ${edge2.from}-[:${edge2.type}]->${edge2.to}: ${violation}`);
           return;
         }
@@ -16923,22 +16964,51 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
        *  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(edge2) {
-        const fromLabel = this.getNode(edge2.from)?.label;
-        const toLabel = this.getNode(edge2.to)?.label;
-        if (edge2.type in LOCAL_RULE_OVERRIDES) {
-          const rule = LOCAL_RULE_OVERRIDES[edge2.type];
-          if (!rule) return null;
-          if (fromLabel && rule.from && !rule.from.includes(fromLabel)) {
-            return `${edge2.type} cannot originate from ${fromLabel} locally (allowed: ${rule.from.join(", ")})`;
-          }
-          if (toLabel && rule.to && !rule.to.includes(toLabel)) {
-            return `${edge2.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 {
+        }
+      }
+      /** 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 {
         }
-        const verdict = isValidEdge(fromLabel, edge2.type, toLabel);
-        return verdict.ok ? null : verdict.reason ?? "edge rule violation";
+      }
+      edgeRuleViolation(edge2) {
+        return localEdgeViolation(
+          this.getNode(edge2.from)?.label,
+          edge2.type,
+          this.getNode(edge2.to)?.label
+        );
       }
       updateEdge(id, patch) {
         this.stmts.updateEdge.run({
@@ -17075,6 +17145,32 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         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. */
@@ -20879,6 +20975,7 @@ __export(src_exports2, {
   linkProblemToPackages: () => linkProblemToPackages,
   linkProblemToSymbols: () => linkProblemToSymbols,
   listNeedsRevisit: () => listNeedsRevisit,
+  localEdgeViolation: () => localEdgeViolation,
   markRevisit: () => markRevisit,
   matchLanguagesInText: () => matchLanguagesInText,
   matchPackagesInText: () => matchPackagesInText,
@@ -21643,6 +21740,7 @@ var init_oauth = __esm({
 
 // ../../packages/cloud-client/src/client.ts
 import { randomUUID } from "node:crypto";
+import { gzipSync } from "node:zlib";
 function wirePerContext(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const out2 = {};
@@ -21840,6 +21938,11 @@ function normalizeSolution(input) {
     validationSource: input.validationSource
   };
 }
+function isIntermediaryRejection(err2) {
+  if (!(err2 instanceof CloudError)) return false;
+  if (err2.status < 400 || err2.status >= 500) return false;
+  return /<!DOCTYPE html|<html/i.test(err2.message);
+}
 function chunkArray(items, size) {
   if (items.length <= size) return items.length ? [[...items]] : [];
   const out2 = [];
@@ -21857,7 +21960,7 @@ function provenanceHeaders(provenance) {
     ...provenance.agentModel ? { "x-inerrata-agent-model": provenance.agentModel } : {}
   };
 }
-var asWireCount, INGEST_NODE_CHUNK, CloudClient, CloudError;
+var asWireCount, INGEST_NODE_CHUNK, COMPRESS_MIN_BYTES, CloudClient, CloudError;
 var init_client = __esm({
   "../../packages/cloud-client/src/client.ts"() {
     "use strict";
@@ -21865,6 +21968,7 @@ var init_client = __esm({
     init_src();
     asWireCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : null;
     INGEST_NODE_CHUNK = 8;
+    COMPRESS_MIN_BYTES = 4096;
     CloudClient = class {
       baseUrl;
       apiKey;
@@ -21879,6 +21983,8 @@ var init_client = __esm({
       daemonVersion;
       daemonChannel;
       provenance;
+      /** Cleared for the process once a server proves it cannot inflate (see `json`). */
+      compressRequests;
       constructor(opts) {
         this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
         if (opts.apiKey !== void 0) this.apiKey = opts.apiKey;
@@ -21892,6 +21998,7 @@ var init_client = __esm({
         this.timeoutMs = opts.timeoutMs ?? 15e3;
         this.daemonVersion = opts.daemonVersion;
         this.daemonChannel = opts.daemonChannel;
+        this.compressRequests = opts.compressRequests ?? true;
         this.provenance = opts.provenance ?? {
           clientProduct: "inerrata_cloud_client",
           clientKind: "sdk",
@@ -22029,18 +22136,24 @@ var init_client = __esm({
         const startedAt = Date.now();
         const totalChunks = Math.max(1, Math.ceil(batch.nodes.length / INGEST_NODE_CHUNK)) + Math.ceil(Math.max(0, batch.edges.length - MAX_EDGES_PER_PAYLOAD) / MAX_EDGES_PER_PAYLOAD);
         let chunkIndex = 0;
+        const blocked = [];
         const emit = (nodeIds, accepted) => {
           chunkIndex++;
+          const refused = blocked.splice(0, blocked.length);
+          const refusedSet = new Set(refused);
           opts.onChunk?.({
             chunkIndex,
             totalChunks,
-            nodeIds,
+            // Watermark only what actually landed — a blocked node never reached the
+            // door, and marking it contributed would lose it permanently and silently.
+            nodeIds: refusedSet.size ? nodeIds.filter((id) => !refusedSet.has(id)) : nodeIds,
             accepted,
-            elapsedMs: Date.now() - startedAt
+            elapsedMs: Date.now() - startedAt,
+            ...refused.length ? { blockedNodeIds: refused } : {}
           });
         };
         if (batch.nodes.length <= INGEST_NODE_CHUNK && batch.edges.length <= MAX_EDGES_PER_PAYLOAD) {
-          const result = await this.ingestWithSplit(batch, batch.nodes, batch.edges);
+          const result = await this.ingestWithSplit(batch, batch.nodes, batch.edges, blocked);
           const summary = summarizeIngestResult(result);
           emit(batch.nodes.map((n) => n.id), summary.accepted);
           return { ...summary, result };
@@ -22055,7 +22168,7 @@ var init_client = __esm({
             const shipped = new Set(inChunk);
             pendingEdges = pendingEdges.filter((e) => !shipped.has(e));
           }
-          const r = await this.ingestWithSplit(batch, nodeChunk, inChunk);
+          const r = await this.ingestWithSplit(batch, nodeChunk, inChunk, blocked);
           emit(nodeChunk.map((n) => n.id), summarizeIngestResult(r).accepted);
           merged.nodes.push(...r.nodes);
           merged.edges.push(...r.edges);
@@ -22098,16 +22211,21 @@ var init_client = __esm({
        * a verdict about the payload — splitting it would just re-send a rejected batch
        * N more times — and a 409/413 has its own handling upstream.
        */
-      async ingestWithSplit(batch, nodes, edges) {
+      async ingestWithSplit(batch, nodes, edges, blocked) {
         try {
           return await this.ingestWire(toWirePayload({ ...batch, nodes, edges }, randomUUID()));
         } catch (err2) {
           const status = err2 instanceof CloudError ? err2.status : 0;
           const timedOut = status === 502 || status === 504 || status === 408 || status === 0;
-          if (!timedOut || nodes.length <= 1) throw err2;
+          const refusedAtEdge = blocked !== void 0 && isIntermediaryRejection(err2);
+          if (refusedAtEdge && nodes.length === 1 && nodes[0]) {
+            blocked.push(nodes[0].id);
+            return { runId: randomUUID(), nodes: [], edges: [] };
+          }
+          if (!timedOut && !refusedAtEdge || nodes.length <= 1) throw err2;
           const mid = Math.ceil(nodes.length / 2);
-          const a = await this.ingestWithSplit(batch, nodes.slice(0, mid), edges);
-          const b = await this.ingestWithSplit(batch, nodes.slice(mid), []);
+          const a = await this.ingestWithSplit(batch, nodes.slice(0, mid), edges, blocked);
+          const b = await this.ingestWithSplit(batch, nodes.slice(mid), [], blocked);
           return {
             runId: a.runId,
             nodes: [...a.nodes, ...b.nodes],
@@ -22409,15 +22527,43 @@ var init_client = __esm({
           const token = opts?.bearerToken ?? await this.authToken();
           if (token) headers["authorization"] = `Bearer ${token}`;
         }
+        let payload;
+        if (body2 !== void 0) {
+          const raw2 = JSON.stringify(body2);
+          if (this.compressRequests && Buffer.byteLength(raw2) >= COMPRESS_MIN_BYTES) {
+            payload = gzipSync(Buffer.from(raw2));
+            headers["content-encoding"] = "gzip";
+          } else {
+            payload = raw2;
+          }
+        }
         const ac = new AbortController();
         const tid = setTimeout(() => ac.abort(), this.timeoutMs);
         try {
           const res = await this.fetchFn(url2, {
             method,
             headers,
-            body: body2 === void 0 ? void 0 : JSON.stringify(body2),
+            body: payload,
             signal: ac.signal
           });
+          if (res.status === 400 && headers["content-encoding"] === "gzip") {
+            delete headers["content-encoding"];
+            const retry = await this.fetchFn(url2, {
+              method,
+              headers,
+              body: JSON.stringify(body2),
+              signal: ac.signal
+            });
+            if (!retry.ok) {
+              const text = await retry.text();
+              throw new CloudError(
+                `${method} ${path2} failed: HTTP ${retry.status} ${text.slice(0, 200)}`,
+                retry.status
+              );
+            }
+            this.compressRequests = false;
+            return await retry.json();
+          }
           if (!res.ok) {
             const text = await res.text();
             throw new CloudError(
@@ -47262,12 +47408,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src5();
-import { closeSync as closeSync2, existsSync as existsSync25, openSync as openSync2, readFileSync as readFileSync24, renameSync as renameSync4, statSync as statSync6 } from "node:fs";
-import { join as join28 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync26, openSync as openSync2, readFileSync as readFileSync25, renameSync as renameSync4, statSync as statSync6 } from "node:fs";
+import { join as join29 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync20, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync21, writeFileSync as writeFileSync18 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.8/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -47847,8 +47993,8 @@ init_config();
 
 // src/engine.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync19, statSync as statSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync9, renameSync as renameSync3, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join24, relative as relative6, sep as sep4 } from "node:path";
+import { existsSync as existsSync20, statSync as statSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync9, renameSync as renameSync3, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join25, relative as relative6, sep as sep4 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -50292,6 +50438,10 @@ function tagEdgeCorroborated(targetAnchorIds, sessionTouchedNodeIds, independent
   for (const a of targetAnchorIds) if (sessionTouchedNodeIds.has(a)) return true;
   return false;
 }
+function citeEdgeType(targetLabel2) {
+  const t = typePriorEdge("Problem", targetLabel2);
+  return t === "SUPERSEDES" ? "RELATES_TO" : t;
+}
 function typePriorEdge(sourceLabel, targetLabel2, sentence = "") {
   const direct = LABEL_PAIR[`${sourceLabel}>${targetLabel2}`];
   if (direct) return direct;
@@ -50838,6 +50988,90 @@ function backfillConstraintKind(store, opts) {
   return report;
 }
 
+// src/edge-repair.ts
+init_src();
+init_src4();
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join17 } from "node:path";
+function citeEdgeId(from, type, to) {
+  return `edge_${digest({ from, type, to })}`.slice(0, 24);
+}
+var EDGE_REPAIR_VERSION = 1;
+var REJECTION_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var EMPTY2 = {
+  skipped: true,
+  scanned: 0,
+  invalid: 0,
+  retyped: 0,
+  closed: 0,
+  byType: {}
+};
+function markerPath2(configDir) {
+  return join17(configDir, "edge-repair.json");
+}
+function alreadyDone2(configDir) {
+  const p = markerPath2(configDir);
+  if (!existsSync14(p)) return false;
+  try {
+    return JSON.parse(readFileSync12(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
+  } catch {
+    return false;
+  }
+}
+function repairInvalidEdges(store, opts) {
+  if (!opts.force && !opts.dryRun && alreadyDone2(opts.configDir)) return EMPTY2;
+  const report = {
+    skipped: false,
+    scanned: 0,
+    invalid: 0,
+    retyped: 0,
+    closed: 0,
+    byType: {}
+  };
+  const work = [];
+  for (const e of store.scanLiveEdgeRows()) {
+    report.scanned++;
+    if (!localEdgeViolation(e.fromLabel, e.type, e.toLabel)) continue;
+    report.invalid++;
+    const candidate = e.toLabel ? citeEdgeType(e.toLabel) : null;
+    const retype = candidate && candidate !== e.type && !localEdgeViolation(e.fromLabel, candidate, e.toLabel) ? candidate : null;
+    work.push({ edge: { id: e.id, from: e.from, to: e.to, type: e.type }, retype });
+    report.byType[e.type] = (report.byType[e.type] ?? 0) + 1;
+    if (retype) report.retyped++;
+    else report.closed++;
+  }
+  if (opts.dryRun) return report;
+  store.transaction(() => {
+    for (const w of work) {
+      const prior = store.getEdge(w.edge.id);
+      store.closeEdge(w.edge.id, opts.now);
+      if (!w.retype || !prior) continue;
+      store.mergeEdge({
+        ...prior,
+        id: citeEdgeId(w.edge.from, w.retype, w.edge.to),
+        type: w.retype,
+        validFrom: opts.now,
+        validTo: null,
+        lastSeenAt: opts.now,
+        // Mark the provenance of the rewrite so a later audit can tell a repaired
+        // edge from one captured natively — without which this sweep would be
+        // indistinguishable from the agent having witnessed it post-fix.
+        attrs: { ...prior.attrs ?? {}, retypedFrom: w.edge.type, retypedBy: `edge-repair:v${EDGE_REPAIR_VERSION}` }
+      });
+    }
+  });
+  store.pruneEdgeRejections(opts.now - REJECTION_RETENTION_MS);
+  try {
+    writeFileSync12(
+      markerPath2(opts.configDir),
+      JSON.stringify({ version: EDGE_REPAIR_VERSION, at: opts.now, ...report }, null, 2),
+      "utf8"
+    );
+  } catch {
+  }
+  return report;
+}
+
 // src/engine.ts
 init_symbol_summaries();
 init_reconcile();
@@ -51036,11 +51270,11 @@ init_outbox();
 init_src8();
 init_src();
 init_src2();
-import { readFileSync as readFileSync12 } from "node:fs";
-import { join as join17 } from "node:path";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { join as join18 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync12(join17(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync13(join18(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -51401,22 +51635,22 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, watch as fsWatch } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync14, watch as fsWatch } from "node:fs";
+import { join as join19 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync13(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync14(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join18(gitDir, "HEAD"));
+  const head2 = readFirstLine(join19(gitDir, "HEAD"));
   const m = head2 ? /^ref:\s*refs\/heads\/(.+)$/.exec(head2) : null;
   const branch = m ? m[1] : null;
   let sha2 = null;
   if (branch) {
-    sha2 = readFirstLine(join18(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join19(gitDir, "refs", "heads", branch));
     if (!sha2) sha2 = shaFromPackedRefs(gitDir, `refs/heads/${branch}`);
   } else if (head2 && /^[0-9a-f]{7,40}$/i.test(head2)) {
     sha2 = head2;
@@ -51424,13 +51658,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync14(join18(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync14(join18(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync15(join19(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync15(join19(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync13(join18(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync14(join19(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -51464,7 +51698,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync14(join18(gitDir, "index.lock"))) {
+      if (existsSync15(join19(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -51475,7 +51709,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join18(gitDir, sub);
+    const p = join19(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -51700,21 +51934,21 @@ var TelemetryRecorder = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { basename as basename4, join as join19 } from "node:path";
+import { basename as basename4, join as join20 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync15(manifestPath)) return [];
+  if (!existsSync16(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync14(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync15(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -51738,7 +51972,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync12(join19(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync13(join20(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -51751,7 +51985,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync12(join19(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync13(join20(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -51765,13 +51999,13 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename4(f))) continue;
     try {
-      unlinkSync2(join19(paths.skillsDir, f));
+      unlinkSync2(join20(paths.skillsDir, f));
       pruned++;
     } catch {
     }
   }
   rows.sort((a, b) => a.id.localeCompare(b.id));
-  writeFileSync12(
+  writeFileSync13(
     paths.skillsManifest,
     JSON.stringify({ generatedAt: Date.now(), skills: rows }, null, 2),
     "utf8"
@@ -51783,22 +52017,22 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   lstatSync,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync8,
   rmSync as rmSync2,
   symlinkSync,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join20(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join21(".claude", "skills") },
   // Cursor adopted the standard; its exact project dir is still moving — kept
   // best-effort and gated on `.cursor/` presence so we never create it blind.
-  { configDir: ".cursor", skillsDir: join20(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join21(".cursor", "skills") }
 ];
 function skillSlug(title, id) {
   const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "skill";
@@ -51843,12 +52077,12 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync16(dir)) return 0;
+  if (!existsSync17(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync8(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync2(join20(dir, name2), { recursive: true, force: true });
+      rmSync2(join21(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -51857,7 +52091,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync16(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
+    if (existsSync17(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -51878,7 +52112,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join20(root, ".agents", "skills");
+  const agentsSkillsDir = join21(root, ".agents", "skills");
   mkdirSync7(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -51886,7 +52120,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync15(s.bodyPath, "utf8");
+      body2 = readFileSync16(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -51895,9 +52129,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync7(join20(agentsSkillsDir, slug2), { recursive: true });
-    writeFileSync13(
-      join20(agentsSkillsDir, slug2, "SKILL.md"),
+    mkdirSync7(join21(agentsSkillsDir, slug2), { recursive: true });
+    writeFileSync14(
+      join21(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -51906,11 +52140,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync16(join20(root, h.configDir))) continue;
-    const dir = join20(root, h.skillsDir);
+    if (!existsSync17(join21(root, h.configDir))) continue;
+    const dir = join21(root, h.skillsDir);
     mkdirSync7(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join20(dir, slug2), join20(agentsSkillsDir, slug2));
+      linkOrCopy(join21(dir, slug2), join21(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -51919,15 +52153,15 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync16(manifestPath)) return [];
+  if (!existsSync17(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync15(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync16(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
       layer: s.layer ?? "technique",
       confidence: s.confidence ?? 0,
-      bodyPath: join20(erretaDir, s.file)
+      bodyPath: join21(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -51941,17 +52175,17 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path2 = join20(root, ".gitignore");
+  const path2 = join21(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync16(path2) ? readFileSync15(path2, "utf8") : "";
+    current = existsSync17(path2) ? readFileSync16(path2, "utf8") : "";
   } catch {
     return;
   }
   if (current.includes(GITIGNORE_MARK)) return;
   const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
   try {
-    writeFileSync13(path2, `${current}${prefix}
+    writeFileSync14(path2, `${current}${prefix}
 ${GITIGNORE_LINES.join("\n")}
 `, "utf8");
   } catch {
@@ -52012,20 +52246,20 @@ init_paths();
 // src/profile.ts
 init_src2();
 init_paths();
-import { existsSync as existsSync18, readFileSync as readFileSync17, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "node:fs";
 import { createHash as createHash12 } from "node:crypto";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 
 // src/git-remote.ts
 init_src();
-import { existsSync as existsSync17, readFileSync as readFileSync16, statSync as statSync4 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join21, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync17, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join22, resolve as resolve5 } from "node:path";
 function resolveGitDir(root) {
-  const dotGit = join21(root, ".git");
+  const dotGit = join22(root, ".git");
   try {
     const st = statSync4(dotGit);
     if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync16(dotGit, "utf8"));
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync17(dotGit, "utf8"));
     if (!m) return null;
     const dir = m[1];
     return isAbsolute3(dir) ? dir : resolve5(root, dir);
@@ -52034,22 +52268,22 @@ function resolveGitDir(root) {
   }
 }
 function gitConfigPath(gitDir) {
-  const commondirFile = join21(gitDir, "commondir");
-  if (existsSync17(commondirFile)) {
-    const common = readFileSync16(commondirFile, "utf8").trim();
+  const commondirFile = join22(gitDir, "commondir");
+  if (existsSync18(commondirFile)) {
+    const common = readFileSync17(commondirFile, "utf8").trim();
     const commonDir = isAbsolute3(common) ? common : resolve5(gitDir, common);
-    return join21(commonDir, "config");
+    return join22(commonDir, "config");
   }
-  return join21(gitDir, "config");
+  return join22(gitDir, "config");
 }
 function readRemotes(root) {
   const gitDir = resolveGitDir(root);
   if (!gitDir) return [];
   const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync17(cfgPath)) return [];
+  if (!existsSync18(cfgPath)) return [];
   let txt;
   try {
-    txt = readFileSync16(cfgPath, "utf8");
+    txt = readFileSync17(cfgPath, "utf8");
   } catch {
     return [];
   }
@@ -52085,13 +52319,13 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync18(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync17(p.workspaceJson, "utf8"));
+  if (!existsSync19(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync18(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
   ensureDir(p.configDir);
-  writeFileSync14(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
+  writeFileSync15(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
 }
 function autodetectProfile(root) {
   const id = workspaceId(root);
@@ -52099,10 +52333,10 @@ function autodetectProfile(root) {
   const p = emptyProfile(id, name2);
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
-  const pkgPath = join22(root, "package.json");
-  if (existsSync18(pkgPath)) {
+  const pkgPath = join23(root, "package.json");
+  if (existsSync19(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
       p.languages.push("typescript", "javascript");
       const nodeVer = pkg.engines?.node ?? "node";
       p.stack.push(`node@${nodeVer}`);
@@ -52123,10 +52357,10 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const pyproject = join22(root, "pyproject.toml");
-  if (existsSync18(pyproject)) {
+  const pyproject = join23(root, "pyproject.toml");
+  if (existsSync19(pyproject)) {
     try {
-      const txt = readFileSync17(pyproject, "utf8");
+      const txt = readFileSync18(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -52137,16 +52371,16 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const reqs = join22(root, "requirements.txt");
-  if (existsSync18(reqs)) {
+  const reqs = join23(root, "requirements.txt");
+  if (existsSync19(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync18(join22(root, "go.mod"))) {
+  if (existsSync19(join23(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync18(join22(root, "Cargo.toml"))) {
+  if (existsSync19(join23(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -52156,17 +52390,17 @@ function autodetectProfile(root) {
 }
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync18, renameSync as renameSync2, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname9, join as join23 } from "node:path";
+import { readFileSync as readFileSync19, renameSync as renameSync2, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname9, join as join24 } from "node:path";
 var WITNESS_QUEUE_CAP = 500;
 var WITNESS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var WITNESS_MAX_ATTEMPTS = 5;
 function witnessQueuePath(workspaceConfigDir) {
-  return join23(workspaceConfigDir, "witness-queue.json");
+  return join24(workspaceConfigDir, "witness-queue.json");
 }
 function loadWitnessQueue(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync18(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync19(path2, "utf8"));
     if (!Array.isArray(raw2)) return [];
     return raw2.filter(
       (w) => !!w && typeof w === "object" && typeof w.nodeId === "string" && typeof w.witnessKey === "string"
@@ -52177,8 +52411,8 @@ function loadWitnessQueue(path2) {
 }
 function saveWitnessQueue(path2, queue) {
   try {
-    const tmp = join23(dirname9(path2), `.${Date.now()}.witness-queue.tmp`);
-    writeFileSync15(tmp, JSON.stringify(queue), "utf8");
+    const tmp = join24(dirname9(path2), `.${Date.now()}.witness-queue.tmp`);
+    writeFileSync16(tmp, JSON.stringify(queue), "utf8");
     renameSync2(tmp, path2);
   } catch {
   }
@@ -52458,7 +52692,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.227" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.247" : "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;
@@ -52468,7 +52702,7 @@ var TURN_REPLAY_LOOKBACK_MS = 7 * 24 * 60 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync19(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync20(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync3(path2, `${path2}.1`);
     }
     appendFileSync2(path2, line);
@@ -52478,7 +52712,7 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync19(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync20(path2, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -52488,7 +52722,7 @@ function loadTurnCursors(path2) {
 }
 function loadTurnOffsets(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync19(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync20(path2, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -52504,7 +52738,7 @@ function saveTurnCursors(path2, cursors, offsets) {
     const merged = {};
     for (const [k, uuid3] of cursors) merged[k] = { uuid: uuid3, offset: offsets.get(k) ?? 0 };
     for (const [k, offset] of offsets) if (!merged[k]) merged[k] = { uuid: "", offset };
-    writeFileSync16(path2, JSON.stringify(merged), "utf8");
+    writeFileSync17(path2, JSON.stringify(merged), "utf8");
   } catch {
   }
 }
@@ -52526,7 +52760,7 @@ function gitSourceWatchTargets(root) {
         ["-C", root, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"],
         { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
       );
-      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join24(root, d) + sep4));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join25(root, d) + sep4));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -52538,19 +52772,19 @@ function gitSourceWatchTargets(root) {
         if (!f.startsWith(prefix)) continue;
         const rest2 = f.slice(prefix.length);
         if (rest2.includes("/")) children.add(dir === "" ? rest2.slice(0, rest2.indexOf("/")) : dir + "/" + rest2.slice(0, rest2.indexOf("/")));
-        else targets.add(join24(root, f));
+        else targets.add(join25(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join24(root, c) + sep4)) continue;
+        if (IGNORED_PATH.test(join25(root, c) + sep4)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join24(root, c));
+        else targets.add(join25(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync9(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join24(root, String(e.name)) + sep4)).map((e) => join24(root, String(e.name)));
+  return readdirSync9(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join25(root, String(e.name)) + sep4)).map((e) => join25(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -52708,7 +52942,7 @@ function createWorkspaceEngine(opts) {
       const srcPaths = diff.changedPaths.filter((p) => /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i.test(p));
       let episodeId2;
       if (srcPaths.length > 0) {
-        const abs = srcPaths.map((p) => join24(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join25(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -52744,8 +52978,8 @@ function createWorkspaceEngine(opts) {
         `[errata] git: ${ev.kind} ${ev.newSha.slice(0, 7)} by ${meta3.authorName} \u2014 ${diff.changedPaths.length} file(s), ${diff.renames.length} rename(s)`
       );
     };
-    const gitDir = join24(opts.workspaceRoot, ".git");
-    if (existsSync19(gitDir)) {
+    const gitDir = join25(opts.workspaceRoot, ".git");
+    if (existsSync20(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -52815,10 +53049,10 @@ function createWorkspaceEngine(opts) {
     });
     doneRender?.();
     writeContextFile(opts.workspaceRoot, body2);
-    const target = join24(opts.workspaceRoot, "AGENTS.md");
+    const target = join25(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join24(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join25(paths.configDir, "priming-handles.json"), [
         ...snapshot.recentProblems.map((r) => r.node),
         // Resolved-band handles: the ✓ problem AND its Solution are citable
         // (a fix tag on an already-resolved problem no-ops idempotently; the
@@ -52909,6 +53143,17 @@ function createWorkspaceEngine(opts) {
     } catch (err2) {
       console.warn("[errata] anchor backfill failed:", err2);
     }
+    try {
+      const r = repairInvalidEdges(store, { configDir: paths.configDir, now: Date.now() });
+      if (!r.skipped && r.invalid > 0) {
+        console.log(
+          `[errata] edge repair: ${r.retyped} edge(s) retyped, ${r.closed} closed (${Object.entries(r.byType).map(([t, n]) => `${t}x${n}`).join(", ")})`
+        );
+        refreshContextNow();
+      }
+    } catch (err2) {
+      console.warn("[errata] edge repair failed:", err2);
+    }
     try {
       const c = backfillConstraintKind(store, {
         root: opts.workspaceRoot,
@@ -53023,7 +53268,7 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join24(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = join25(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
   const sessionLastProblem = /* @__PURE__ */ new Map();
@@ -53047,7 +53292,7 @@ function createWorkspaceEngine(opts) {
     const t = Date.now();
     let processedTurns = 0;
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join24(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join25(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -53356,9 +53601,7 @@ function createWorkspaceEngine(opts) {
             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 });
+            mintCiteEdge(pid, targetId, citeEdgeType(target.label), inst.evidence === "witnessed" ? 0.4 : 0.3, { instanceCite: true, evidence: inst.evidence });
           }
         }
         for (const tf of plan.transfers) {
@@ -53658,7 +53901,7 @@ function createWorkspaceEngine(opts) {
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join24(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join25(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -53845,7 +54088,7 @@ function createWorkspaceEngine(opts) {
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync19(paths.outbox) ? readdirSync9(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync20(paths.outbox) ? readdirSync9(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -53932,7 +54175,7 @@ async function startDaemon(opts) {
     reviewUrl: () => webUiUrl + "/review"
   });
   const writeLockFile = (url2) => {
-    writeFileSync17(
+    writeFileSync18(
       engine.paths.daemonLock,
       JSON.stringify({ pid: process.pid, webUiUrl: url2, startedAt: Date.now() }),
       "utf8"
@@ -53975,7 +54218,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync20(engine.paths.daemonLock)) {
+        if (existsSync21(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -53992,16 +54235,16 @@ async function listenServer(fetchFn, port) {
 
 // src/registry.ts
 init_paths();
-import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join26 } from "node:path";
 function registryPath() {
-  return process.env["ERRATA_REGISTRY_PATH"] ?? join25(globalDir(), "workspaces.json");
+  return process.env["ERRATA_REGISTRY_PATH"] ?? join26(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync21(p)) return { version: 1, workspaces: {} };
+  if (!existsSync22(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync20(p, "utf8"));
+    const parsed = JSON.parse(readFileSync21(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -54009,7 +54252,7 @@ function read() {
 }
 function write(reg) {
   ensureDir(globalDir());
-  writeFileSync18(registryPath(), JSON.stringify(reg, null, 2), "utf8");
+  writeFileSync19(registryPath(), JSON.stringify(reg, null, 2), "utf8");
 }
 function registerWorkspace(profile, root, now = Date.now()) {
   const reg = read();
@@ -54026,7 +54269,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync21(entry.path)) {
+    if (!existsSync22(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -54035,13 +54278,13 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync21(entry.path);
+  const missing = !existsSync22(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync21(lockPath)) {
+  if (existsSync22(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync20(lockPath, "utf8"));
+      const lock = JSON.parse(readFileSync21(lockPath, "utf8"));
       if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
         running = true;
         webUiUrl = lock.webUiUrl;
@@ -54069,7 +54312,7 @@ function pidAlive(pid) {
 // src/multi.ts
 init_dist();
 init_src4();
-import { readFileSync as readFileSync23, unlinkSync as unlinkSync3, writeFileSync as writeFileSync19 } from "node:fs";
+import { readFileSync as readFileSync24, unlinkSync as unlinkSync3, writeFileSync as writeFileSync20 } from "node:fs";
 
 // src/principle-sync.ts
 init_src4();
@@ -54097,8 +54340,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync22, readFileSync as readFileSync21 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync22 } from "node:fs";
+import { join as join27 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -54247,11 +54490,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join26(opts.root, c.file);
-    if (!existsSync22(p)) continue;
+    const p = join27(opts.root, c.file);
+    if (!existsSync23(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync21(p, "utf8"));
+      sbom = c.parse(readFileSync22(p, "utf8"));
     } catch {
       continue;
     }
@@ -54699,7 +54942,7 @@ var ConsolidateWorker = class {
 init_paths();
 
 // src/lock.ts
-import { existsSync as existsSync23, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync23 } from "node:fs";
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
   try {
@@ -54710,9 +54953,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync23(lockPath)) return null;
+  if (!existsSync24(lockPath)) return null;
   try {
-    const lock = JSON.parse(readFileSync22(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync23(lockPath, "utf8"));
     return typeof lock.pid === "number" ? lock : null;
   } catch {
     return null;
@@ -54729,6 +54972,39 @@ init_config();
 // src/update.ts
 import { spawn as spawn2 } from "node:child_process";
 var PACKAGE_NAME = "@inerrata-corporation/errata";
+function parse3(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z][0-9A-Za-z.-]*))?/.exec(v.trim());
+  if (!m) return null;
+  return {
+    base: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] === void 0 ? null : m[4].split(/[.-]/).map((p) => /^\d+$/.test(p) ? Number(p) : p)
+  };
+}
+function compareVersions(a, b) {
+  const pa = parse3(a);
+  const pb = parse3(b);
+  if (!pa || !pb) return 0;
+  const [aMaj, aMin, aPatch] = pa.base;
+  const [bMaj, bMin, bPatch] = pb.base;
+  if (aMaj !== bMaj) return aMaj - bMaj;
+  if (aMin !== bMin) return aMin - bMin;
+  if (aPatch !== bPatch) return aPatch - bPatch;
+  if (pa.pre === null && pb.pre === null) return 0;
+  if (pa.pre === null) return 1;
+  if (pb.pre === null) return -1;
+  for (let i2 = 0; i2 < Math.max(pa.pre.length, pb.pre.length); i2++) {
+    const x = pa.pre[i2];
+    const y = pb.pre[i2];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (x === y) continue;
+    if (typeof x === "number" && typeof y === "number") return x - y;
+    if (typeof x === "number") return -1;
+    if (typeof y === "number") return 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
 async function latestPublished(channel, timeoutMs = 4e3) {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -54748,10 +55024,14 @@ async function latestPublished(channel, timeoutMs = 4e3) {
 }
 async function checkForUpdate(channel) {
   const latest = await latestPublished(channel);
+  const direction = latest === null ? 0 : compareVersions(latest, DAEMON_VERSION);
   return {
     current: DAEMON_VERSION,
     latest,
-    updateAvailable: latest !== null && latest !== DAEMON_VERSION
+    // `compareVersions` returns 0 for unparseable input, so an unrecognizable tag
+    // is treated as "nothing to do" rather than gambling on a direction.
+    updateAvailable: latest !== null && direction > 0,
+    downgradeAvailable: latest !== null && direction < 0
   };
 }
 var POLL_INTERVAL_MS = {
@@ -54954,12 +55234,12 @@ async function reanchorProject(opts) {
 }
 
 // src/adopt.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { dirname as dirname10, join as join27 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { dirname as dirname10, join as join28 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync24(join27(dir, ".git"))) return dir;
+    if (existsSync25(join28(dir, ".git"))) return dir;
     const parent = dirname10(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -55208,7 +55488,7 @@ async function startMultiDaemon(opts = {}) {
     void ambientLinkAll();
     app.route(`/ws/${rec.id}`, rec.webApp);
     try {
-      writeFileSync19(
+      writeFileSync20(
         rec.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${rec.id}`, startedAt: Date.now() }),
         "utf8"
@@ -55397,7 +55677,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync19(
+    writeFileSync20(
       lockPath,
       JSON.stringify({ pid: process.pid, webUiUrl: baseUrl, startedAt: Date.now() }),
       "utf8"
@@ -55406,7 +55686,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync19(
+      writeFileSync20(
         r.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${r.id}`, startedAt: Date.now() }),
         "utf8"
@@ -55733,6 +56013,11 @@ async function startMultiDaemon(opts = {}) {
                   if (!local) continue;
                   store.updateNode(localId, { attrs: { ...local.attrs, contributedAtSeq: seq } });
                 }
+                if (p.blockedNodeIds?.length) {
+                  console.log(
+                    `[sync\u2192cloud] [${projectName}] context: ${p.blockedNodeIds.length} node(s) refused by an edge/CDN filter on content \u2014 left pending, will retry`
+                  );
+                }
                 noteFlushProgress(p.accepted, p.nodeIds.length, `context ${p.chunkIndex}/${p.totalChunks}`);
               }
             });
@@ -55762,9 +56047,18 @@ async function startMultiDaemon(opts = {}) {
         if (instances) {
           if (project) instances.projectId = project.projectId;
           await lane("instances", projectName, async () => {
+            const blocked = /* @__PURE__ */ new Set();
             const res = await client.ingest(instances, {
-              onChunk: (p) => noteFlushProgress(p.accepted, p.nodeIds.length, `instances ${p.chunkIndex}/${p.totalChunks}`)
+              onChunk: (p) => {
+                for (const id of p.blockedNodeIds ?? []) blocked.add(id);
+                noteFlushProgress(p.accepted, p.nodeIds.length, `instances ${p.chunkIndex}/${p.totalChunks}`);
+              }
             });
+            if (blocked.size > 0) {
+              console.log(
+                `[sync\u2192cloud] [${projectName}] instances: ${blocked.size} node(s) refused by an edge/CDN filter on content \u2014 left pending, will retry. First: ${store.getNode([...blocked][0])?.description.slice(0, 120) ?? [...blocked][0]}`
+              );
+            }
             uploaded += res.accepted;
             const seq = store.currentIngestSeq();
             const cloudIdByLocal = new Map(
@@ -55773,6 +56067,7 @@ async function startMultiDaemon(opts = {}) {
             for (const n of instances.nodes) {
               const local = store.getNode(n.id);
               if (!local || !["Problem", "Solution", "RootCause"].includes(local.label)) continue;
+              if (blocked.has(n.id)) continue;
               const cloudNodeId = cloudIdByLocal.get(n.id);
               store.updateNode(n.id, {
                 attrs: {
@@ -55889,7 +56184,7 @@ async function startMultiDaemon(opts = {}) {
     },
     async stop() {
       try {
-        const cur = readFileSync23(lockPath, "utf8");
+        const cur = readFileSync24(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
       } catch {
       }
@@ -56906,21 +57201,21 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync26 } = await import("node:fs");
-    const { join: join29 } = await import("node:path");
+    const { existsSync: existsSync27 } = await import("node:fs");
+    const { join: join30 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync26(join29(ROOT, ".cursor"))) {
+    if (existsSync27(join30(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
         console.warn(`  \u26A0\uFE0F  Cursor MCP config failed: ${err2 instanceof Error ? err2.message : err2}`);
       }
     }
-    if (existsSync26(join29(ROOT, ".codex"))) {
+    if (existsSync27(join30(ROOT, ".codex"))) {
       try {
         await installCodexHooks(port);
       } catch (err2) {
@@ -57077,9 +57372,9 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync25(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync25(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
-  if (existsSync25(paths.castalia)) {
+  console.log(`  graph db:  ${existsSync26(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync26(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  if (existsSync26(paths.castalia)) {
     try {
       const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
       const store = openGraphStore2({ path: paths.castalia });
@@ -57095,6 +57390,16 @@ async function cmdStatus() {
           }
         }
         console.log(`  contribute: ${pending} pending of ${total} instance node(s)`);
+        const rejections = store.edgeRejections();
+        if (rejections.length > 0) {
+          const refused = rejections.reduce((n, r) => n + r.count, 0);
+          console.log(`  edges:      ${refused} refused by the ontology gate \u2014 a producer is emitting invalid edges`);
+          for (const r of rejections.slice(0, 3)) {
+            const mins = Math.max(0, Math.round((Date.now() - r.lastAt) / 6e4));
+            const age = mins < 60 ? `${mins}m ago` : mins < 1440 ? `${Math.round(mins / 60)}h ago` : `${Math.round(mins / 1440)}d ago`;
+            console.log(`               ${r.count}x ${r.type} (last ${age})${r.sample ? ` \u2014 ${r.sample}` : ""}`);
+          }
+        }
       } finally {
         store.close();
       }
@@ -57214,9 +57519,11 @@ async function cmdUpdate(args2) {
   const cfg = loadConfig();
   let channel = cfg.updateChannel;
   let checkOnly = false;
+  let allowDowngrade = false;
   for (let i2 = 0; i2 < args2.length; i2++) {
     const a = args2[i2];
     if (a === "--check") checkOnly = true;
+    else if (a === "--allow-downgrade") allowDowngrade = true;
     else if (a === "--channel") {
       const v = args2[++i2];
       if (v === "dev" || v === "latest") channel = v;
@@ -57237,8 +57544,19 @@ async function cmdUpdate(args2) {
     return;
   }
   if (!status.updateAvailable) {
-    console.log(`errata is up to date \u2014 ${status.current} (channel: ${channel})`);
-    return;
+    if (status.downgradeAvailable) {
+      console.log(
+        `channel '${channel}' points at ${status.latest}, which is OLDER than the running ${status.current}.`
+      );
+      console.log(`  not installing \u2014 a downgrade past a store migration cannot open its own graph.`);
+      console.log(`  if this is a deliberate rollback: errata update --allow-downgrade`);
+      if (!allowDowngrade) return;
+      console.log(`
+--allow-downgrade given; proceeding.`);
+    } else {
+      console.log(`errata is up to date \u2014 ${status.current} (channel: ${channel})`);
+      return;
+    }
   }
   console.log(`update available: ${status.current} \u2192 ${status.latest} (channel: ${channel})`);
   if (checkOnly) {
@@ -57730,11 +58048,11 @@ function cmdInstallationProfile(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync25(paths.reviewQueue)) {
+  if (!existsSync26(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync24(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync25(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -58405,7 +58723,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync26 } = await import("node:fs");
+  const { existsSync: existsSync27 } = await import("node:fs");
   const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
@@ -58413,7 +58731,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync26(dbPath)) continue;
+    if (!existsSync27(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -58444,7 +58762,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync20 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync21 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -58457,8 +58775,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync8(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync20(join28(outDir, f.name), f.html, "utf8");
-  const indexPath = join28(outDir, "report.html");
+  for (const f of files) writeFileSync21(join29(outDir, f.name), f.html, "utf8");
+  const indexPath = join29(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(
     `  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`
@@ -58576,15 +58894,15 @@ function hookRelayCommand(port, path2) {
   return process.platform === "win32" ? `cmd //c "curl -s --connect-timeout 1 --max-time 2 -X POST -H \\"Content-Type: application/json\\" --data-binary @- ${url2} 2>NUL || echo {}"` : `curl -s --connect-timeout 1 --max-time 2 -X POST -H 'Content-Type: application/json' --data-binary @- ${url2} 2>/dev/null || echo '{}'`;
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync25, writeFileSync: writeFileSync20 } = await import("node:fs");
-  const { join: join29 } = await import("node:path");
-  const dir = join29(ROOT, ".claude");
-  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join29(dir, "settings.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync27, readFileSync: readFileSync26, writeFileSync: writeFileSync21 } = await import("node:fs");
+  const { join: join30 } = await import("node:path");
+  const dir = join30(ROOT, ".claude");
+  if (!existsSync27(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join30(dir, "settings.json");
   let settings = {};
-  if (existsSync26(file2)) {
+  if (existsSync27(file2)) {
     try {
-      settings = JSON.parse(readFileSync25(file2, "utf8"));
+      settings = JSON.parse(readFileSync26(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -58630,10 +58948,10 @@ async function installClaudeHooks(port) {
     dropErrata(list);
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
-  writeFileSync20(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync21(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   await installClaudeMcpConfig();
-  const claudeMd = join29(ROOT, "CLAUDE.md");
+  const claudeMd = join30(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -58645,15 +58963,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync25, writeFileSync: writeFileSync20 } = await import("node:fs");
-  const { join: join29, dirname: dirname11 } = await import("node:path");
-  const file2 = join29(ROOT, ".mcp.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync27, readFileSync: readFileSync26, writeFileSync: writeFileSync21 } = await import("node:fs");
+  const { join: join30, dirname: dirname11 } = await import("node:path");
+  const file2 = join30(ROOT, ".mcp.json");
   const dir = dirname11(file2);
-  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
+  if (!existsSync27(dir)) mkdirSync8(dir, { recursive: true });
   let cfg = {};
-  if (existsSync26(file2)) {
+  if (existsSync27(file2)) {
     try {
-      cfg = JSON.parse(readFileSync25(file2, "utf8"));
+      cfg = JSON.parse(readFileSync26(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -58661,21 +58979,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync20(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync21(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync25, writeFileSync: writeFileSync20 } = await import("node:fs");
-  const { join: join29 } = await import("node:path");
-  const dir = join29(ROOT, ".cursor");
-  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join29(dir, "mcp.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync27, readFileSync: readFileSync26, writeFileSync: writeFileSync21 } = await import("node:fs");
+  const { join: join30 } = await import("node:path");
+  const dir = join30(ROOT, ".cursor");
+  if (!existsSync27(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join30(dir, "mcp.json");
   let cfg = {};
-  if (existsSync26(file2)) {
+  if (existsSync27(file2)) {
     try {
-      cfg = JSON.parse(readFileSync25(file2, "utf8"));
+      cfg = JSON.parse(readFileSync26(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -58683,7 +59001,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync20(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync21(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -58691,16 +59009,16 @@ async function installCursorMcpConfig() {
   console.log(`  \u26A0\uFE0F  reload Cursor (Cmd/Ctrl-Shift-P \u2192 "Reload Window") to pick it up.`);
 }
 async function installCodexHooks(port) {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync25, writeFileSync: writeFileSync20 } = await import("node:fs");
-  const { join: join29 } = await import("node:path");
-  const dir = join29(ROOT, ".codex");
-  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join29(dir, "config.toml");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync27, readFileSync: readFileSync26, writeFileSync: writeFileSync21 } = await import("node:fs");
+  const { join: join30 } = await import("node:path");
+  const dir = join30(ROOT, ".codex");
+  if (!existsSync27(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join30(dir, "config.toml");
   const BEGIN = `# >>> errata hooks (errata-managed)`;
   const END = `# <<< errata hooks`;
   let existing = "";
-  if (existsSync26(file2)) {
-    existing = readFileSync25(file2, "utf8");
+  if (existsSync27(file2)) {
+    existing = readFileSync26(file2, "utf8");
     const beginIdx = existing.indexOf(BEGIN);
     const endIdx = existing.indexOf(END);
     if (beginIdx >= 0 && endIdx > beginIdx) {
@@ -58729,7 +59047,7 @@ ${END}
   const final = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
 
 ${block}` : existing + (existing.endsWith("\n\n") ? "" : "\n") + block;
-  writeFileSync20(file2, final, "utf8");
+  writeFileSync21(file2, final, "utf8");
   console.log(`installed Codex hooks \u2192 ${file2}`);
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
   console.log("");
@@ -59043,7 +59361,7 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile);
-        const res = bleedRules(join28(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join29(r.root, ".claude", "rules"), items);
         if (res.written || res.pruned) {
           console.log(
             `[rules:${r.entry.name}] ${res.written} collective principle(s) \u2192 .claude/rules` + (res.pruned ? `, ${res.pruned} pruned` : "")