@inerrata-corporation/errata 2.0.17-dev.3435 → 2.0.17-dev.3450

package/consolidate-worker.mjs

@@ -18575,6 +18575,8 @@ function generalize(text, opts = {}) {
 init_src();
 
 // src/instance-receipts.ts
+var INSTANCE_SEMANTIC_EDGE_TYPES = ["CAUSED_BY", "SOLVED_BY"];
+var INSTANCE_ANCHOR_EDGE_TYPES = ["OCCURS_IN", "DEPENDS_ON", "PERTAIN_TO", "CONCERNS"];
 function receiptMap(attrs) {
   const value = attrs["instanceReceipts"];
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -19455,8 +19457,8 @@ function generalizeFileRefs(text, fileLexicon, level = 1) {
 
 // src/instance-ingest.ts
 var INSTANCE_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
-var INSTANCE_EDGES = ["CAUSED_BY", "SOLVED_BY"];
-var ANCHOR_EDGES = ["OCCURS_IN", "DEPENDS_ON", "PERTAIN_TO", "CONCERNS"];
+var INSTANCE_EDGES = INSTANCE_SEMANTIC_EDGE_TYPES;
+var ANCHOR_EDGES = INSTANCE_ANCHOR_EDGE_TYPES;
 var ANCHOR_TARGET_LABELS = ["Language", "Package", "Domain", "Component"];
 function stripCodebaseScope(scope) {
   const s = { ...scope ?? {} };

package/errata.mjs

@@ -26399,7 +26399,7 @@ function parseRestErrorEnvelope(text) {
     return null;
   }
 }
-var asWireCount, INGEST_NODE_CHUNK, E6B_PUBLIC_CONTEXT_SENTINEL, CloudClient, CloudError;
+var asWireCount, INGEST_NODE_CHUNK, INGEST_EDGE_CHUNK, E6B_PUBLIC_CONTEXT_SENTINEL, CloudClient, CloudError;
 var init_client = __esm({
   "../../packages/cloud-client/src/client.ts"() {
     "use strict";
@@ -26407,6 +26407,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;
+    INGEST_EDGE_CHUNK = 32;
     E6B_PUBLIC_CONTEXT_SENTINEL = "00000000-0000-4e6b-8000-000000000e6b";
     CloudClient = class {
       baseUrl;
@@ -26598,42 +26599,45 @@ var init_client = __esm({
       async ingest(batch, opts = {}) {
         const runId = randomUUID();
         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);
+        const single = batch.nodes.length <= INGEST_NODE_CHUNK && batch.edges.length <= INGEST_EDGE_CHUNK;
+        let pendingEdges = [...batch.edges];
+        const nodePlan = single ? [] : chunkArray(batch.nodes, INGEST_NODE_CHUNK).map((nodes) => {
+          const ids = new Set(nodes.map((n) => n.id));
+          const edges = pendingEdges.filter((e) => ids.has(e.from) && ids.has(e.to)).slice(0, INGEST_EDGE_CHUNK);
+          const shipped = new Set(edges);
+          pendingEdges = pendingEdges.filter((e) => !shipped.has(e));
+          return { nodes, edges };
+        });
+        const totalChunks = single ? 1 : nodePlan.length + Math.ceil(pendingEdges.length / INGEST_EDGE_CHUNK);
         let chunkIndex = 0;
         const blocked = [];
-        const emit = (nodeIds, accepted) => {
+        const emit = async (nodeIds, result) => {
           chunkIndex++;
           const refused = blocked.splice(0, blocked.length);
           const refusedSet = new Set(refused);
-          opts.onChunk?.({
+          await opts.onChunk?.({
             chunkIndex,
             totalChunks,
             // 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,
+            accepted: summarizeIngestResult(result).accepted,
+            result,
             elapsedMs: Date.now() - startedAt,
             ...refused.length ? { blockedNodeIds: refused } : {}
           });
         };
-        if (batch.nodes.length <= INGEST_NODE_CHUNK && batch.edges.length <= MAX_EDGES_PER_PAYLOAD) {
+        if (single) {
           const result = await this.ingestWithSplit(batch, batch.nodes, batch.edges, blocked);
           const summary = summarizeIngestResult(result);
-          emit(batch.nodes.map((n) => n.id), summary.accepted);
+          await emit(batch.nodes.map((n) => n.id), result);
           return { ...summary, result };
         }
         const merged = { runId, nodes: [], edges: [] };
-        let pendingEdges = [...batch.edges];
         const echoedCloudId = /* @__PURE__ */ new Map();
-        for (const nodeChunk of chunkArray(batch.nodes, INGEST_NODE_CHUNK)) {
-          const ids = new Set(nodeChunk.map((n) => n.id));
-          const inChunk = pendingEdges.filter((e) => ids.has(e.from) && ids.has(e.to)).slice(0, MAX_EDGES_PER_PAYLOAD);
-          if (inChunk.length > 0) {
-            const shipped = new Set(inChunk);
-            pendingEdges = pendingEdges.filter((e) => !shipped.has(e));
-          }
+        for (const { nodes: nodeChunk, edges: inChunk } of nodePlan) {
           const r = await this.ingestWithSplit(batch, nodeChunk, inChunk, blocked);
-          emit(nodeChunk.map((n) => n.id), summarizeIngestResult(r).accepted);
+          await emit(nodeChunk.map((n) => n.id), r);
           merged.nodes.push(...r.nodes);
           merged.edges.push(...r.edges);
           for (const rn of r.nodes) {
@@ -26645,7 +26649,7 @@ var init_client = __esm({
             merged.patternReconciliation = { ...merged.patternReconciliation, ...r.patternReconciliation };
           }
         }
-        for (const edgeChunk of chunkArray(pendingEdges, MAX_EDGES_PER_PAYLOAD)) {
+        for (const edgeChunk of chunkArray(pendingEdges, INGEST_EDGE_CHUNK)) {
           const projected = edgeChunk.map((e) => ({
             ...e,
             from: echoedCloudId.get(e.from) ?? e.from,
@@ -26664,11 +26668,11 @@ var init_client = __esm({
             return false;
           });
           if (rewritten.length === 0) {
-            emit([], 0);
+            await emit([], { runId, nodes: [], edges: [] });
             continue;
           }
-          const r = await this.ingestWire(toWirePayload({ ...batch, nodes: [], edges: rewritten }, randomUUID()));
-          emit([], summarizeIngestResult(r).accepted);
+          const r = await this.ingestWithSplit(batch, [], rewritten, blocked);
+          await emit([], r);
           merged.edges.push(...r.edges);
         }
         return { ...summarizeIngestResult(merged), result: merged };
@@ -26697,6 +26701,12 @@ var init_client = __esm({
         } catch (err2) {
           const status = err2 instanceof CloudError ? err2.status : 0;
           const timedOut = status === 502 || status === 504 || status === 408 || status === 0;
+          if (timedOut && nodes.length === 0 && edges.length > 1) {
+            const mid2 = Math.ceil(edges.length / 2);
+            const a2 = await this.ingestWithSplit(batch, [], edges.slice(0, mid2), blocked);
+            const b2 = await this.ingestWithSplit(batch, [], edges.slice(mid2), blocked);
+            return { runId: a2.runId, nodes: [], edges: [...a2.edges, ...b2.edges] };
+          }
           const refusedAtEdge = blocked !== void 0 && isIntermediaryRejection(err2);
           if (refusedAtEdge && nodes.length === 1 && nodes[0]) {
             blocked.push(nodes[0].id);
@@ -82159,7 +82169,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.17-dev.3435" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.17-dev.3450" : "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;
@@ -85045,6 +85055,39 @@ async function linkRegisteredWorkspaces(cfg, loggedInProfile = cfg.activeInstall
 
 // src/instance-receipts.ts
 import { createHash as createHash18 } from "node:crypto";
+var INSTANCE_SEMANTIC_EDGE_TYPES = ["CAUSED_BY", "SOLVED_BY"];
+var INSTANCE_ANCHOR_EDGE_TYPES = ["OCCURS_IN", "DEPENDS_ON", "PERTAIN_TO", "CONCERNS"];
+function edgeReceiptKind(type) {
+  if (INSTANCE_SEMANTIC_EDGE_TYPES.includes(type)) return "semantic";
+  if (INSTANCE_ANCHOR_EDGE_TYPES.includes(type)) return "anchor";
+  return type === "ANCHORED_AT" ? "projectAnchor" : null;
+}
+function instanceEdgeReceipts(sent, received, cloudIds) {
+  const wireId = (id) => cloudIds.get(id) ?? id;
+  const edgeKey = (e) => JSON.stringify([wireId(e.from), e.type, wireId(e.to)]);
+  const groupKey = (source, kind) => JSON.stringify([wireId(source), kind]);
+  const accepted = /* @__PURE__ */ new Map();
+  const rejected = /* @__PURE__ */ new Set();
+  for (const edge2 of received) {
+    const key = edgeKey(edge2);
+    if (edge2.decision === "rejected") rejected.add(key);
+    else if (edge2.decision === "created" || edge2.decision === "reinforced") accepted.set(key, (accepted.get(key) ?? 0) + 1);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const edge2 of sent) {
+    const kind = edgeReceiptKind(edge2.type);
+    if (!kind) continue;
+    const group = groupKey(edge2.from, kind);
+    const expected = groups.get(group) ?? /* @__PURE__ */ new Map();
+    const key = edgeKey(edge2);
+    expected.set(key, (expected.get(key) ?? 0) + 1);
+    groups.set(group, expected);
+  }
+  const complete = new Set([...groups].filter(
+    ([, expected]) => [...expected].every(([key, count]) => !rejected.has(key) && (accepted.get(key) ?? 0) >= count)
+  ).map(([group]) => group));
+  return { complete: (source, kind) => complete.has(groupKey(source, kind)) };
+}
 var FIELDS = ["contributedAtSeq", "cloudNodeId", "anchorsContributedDigest", "projectAnchorsContributedDigest", "semanticEdgesContributedDigest", "shipRefusedSinceSeq", "shipRefusedCount", "shipRefusedReason", "shipRefusedFingerprint"];
 function instanceDestinationKey(input) {
   return createHash18("sha256").update(JSON.stringify([
@@ -85076,8 +85119,20 @@ function updateInstanceReceipt(n, destination, patch, mirrorLegacy) {
 function instanceReceiptSequence(n) {
   return Math.max(n.lastReinforcedAtSeq ?? 0, n.createdAtSeq ?? 0);
 }
+function acceptedInstanceReceipt(current, sent, decision, destination, mirrorLegacy) {
+  if (!["Problem", "Vulnerability", "Solution", "RootCause"].includes(current.label) || !["created", "reinforced"].includes(decision.decision) || !decision.nodeId) return null;
+  return updateInstanceReceipt(current, destination, {
+    contributedAtSeq: instanceReceiptSequence(sent),
+    cloudNodeId: decision.nodeId,
+    shipRefusedSinceSeq: void 0,
+    shipRefusedCount: void 0,
+    shipRefusedReason: void 0,
+    shipRefusedFingerprint: void 0
+  }, mirrorLegacy);
+}
 
 // src/multi.ts
+init_src();
 init_dist();
 init_src5();
 import { existsSync as existsSync34, readFileSync as readFileSync36, unlinkSync as unlinkSync5, writeFileSync as writeFileSync26 } from "node:fs";
@@ -85459,8 +85514,8 @@ function internalSymbolsFor(description, lexiconHas, publicIndex) {
 // src/instance-ingest.ts
 init_generalize_graph();
 var INSTANCE_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
-var INSTANCE_EDGES = ["CAUSED_BY", "SOLVED_BY"];
-var ANCHOR_EDGES = ["OCCURS_IN", "DEPENDS_ON", "PERTAIN_TO", "CONCERNS"];
+var INSTANCE_EDGES = INSTANCE_SEMANTIC_EDGE_TYPES;
+var ANCHOR_EDGES = INSTANCE_ANCHOR_EDGE_TYPES;
 var ANCHOR_TARGET_LABELS = ["Language", "Package", "Domain", "Component"];
 function stripCodebaseScope(scope) {
   const s = { ...scope ?? {} };
@@ -90290,10 +90345,24 @@ async function startMultiDaemon(opts = {}) {
           if (project) instances.projectId = project.projectId;
           const shipStartedAt = Date.now();
           await lane("instances", projectName, async () => {
+            const owningStore = (id) => {
+              const w = store.getNode(id);
+              if (w) return { s: store, n: w };
+              const sh = sharedStore.getNode(id);
+              return sh ? { s: sharedStore, n: sh } : null;
+            };
+            const sentById = new Map(instances.nodes.map((n) => [n.id, n]));
             const blocked = /* @__PURE__ */ new Set();
             const res = await client.ingest(instances, {
               onChunk: (p) => {
                 for (const id of p.blockedNodeIds ?? []) blocked.add(id);
+                for (const decision of p.result.nodes) {
+                  const sent = sentById.get(decision.canonicalId);
+                  const owner = owningStore(decision.canonicalId);
+                  if (!sent || !owner || blocked.has(sent.id)) continue;
+                  const attrs = acceptedInstanceReceipt(owner.n, sent, decision, destinationKey, owner.s === store);
+                  if (attrs) owner.s.updateNode(sent.id, { attrs });
+                }
                 noteFlushProgress(p.accepted, p.nodeIds.length, `instances ${p.chunkIndex}/${p.totalChunks}`);
               }
             });
@@ -90303,15 +90372,25 @@ async function startMultiDaemon(opts = {}) {
               );
             }
             uploaded += res.accepted;
-            const cloudIdByLocal = new Map(
-              res.result.nodes.filter((rn) => rn.nodeId).map((rn) => [rn.canonicalId, rn.nodeId])
-            );
             const rejected = /* @__PURE__ */ new Map();
             for (const rn of res.result.nodes) {
               if (rn.decision === "rejected") rejected.set(rn.canonicalId, rn.reason ?? "no reason given");
             }
             const rejectedEdges = res.result.edges.filter((re) => re.decision === "rejected");
-            const edgeReceiptsComplete = rejectedEdges.length === 0 && res.result.edges.length === instances.edges.length;
+            const cloudIds = /* @__PURE__ */ new Map();
+            for (const node2 of res.result.nodes) {
+              if (isMembraneSaltedId(node2.nodeId)) cloudIds.set(node2.canonicalId, node2.nodeId);
+            }
+            for (const localId of /* @__PURE__ */ new Set([
+              ...Object.keys(instances.anchorDigests),
+              ...Object.keys(instances.projectAnchorDigests),
+              ...Object.keys(instances.semanticEdgeDigests)
+            ])) {
+              const owner = owningStore(localId);
+              const cloudId = owner && instanceReceipt(owner.n, destinationKey)["cloudNodeId"];
+              if (isMembraneSaltedId(cloudId)) cloudIds.set(localId, cloudId);
+            }
+            const edgeReceipts = instanceEdgeReceipts(instances.edges, res.result.edges, cloudIds);
             if (rejectedEdges.length > 0) {
               const byReason = /* @__PURE__ */ new Map();
               for (const re of rejectedEdges) {
@@ -90328,13 +90407,6 @@ async function startMultiDaemon(opts = {}) {
                 `[sync\u2192cloud] [${projectName}] instances: ${rejected.size} node(s) REJECTED by the door \u2014 left pending for the next flush: ` + sample.join(" | ")
               );
             }
-            const owningStore = (id) => {
-              const w = store.getNode(id);
-              if (w) return { s: store, n: w };
-              const sh = sharedStore.getNode(id);
-              if (sh) return { s: sharedStore, n: sh };
-              return null;
-            };
             let blockedRepeat = 0;
             let rejectedRepeat = 0;
             const nowHeld = [];
@@ -90365,36 +90437,10 @@ async function startMultiDaemon(opts = {}) {
                 `[sync\u2192cloud] [${projectName}] instances: HOLDING ${nowHeld.length} node(s) \u2014 refused identically ${SHIP_TERMINAL_REFUSALS}\xD7 on unchanged text; not re-sent until the text changes: ` + nowHeld.map(({ id, reason }) => `${id} "${owningStore(id)?.n.description.slice(0, 60) ?? ""}": ${reason}`).join(" | ")
               );
             }
-            await stampBatched(instances.nodes, (n) => {
-              const owner = owningStore(n.id);
-              if (!owner || !["Problem", "Solution", "RootCause"].includes(owner.n.label)) return;
-              if (blocked.has(n.id)) return;
-              if (!cloudIdByLocal.has(n.id)) return;
-              if (rejected.has(n.id)) return;
-              const cloudNodeId = cloudIdByLocal.get(n.id);
-              const {
-                shipRefusedSinceSeq: _clearedSeq,
-                shipRefusedCount: _clearedCount,
-                shipRefusedReason: _clearedReason,
-                shipRefusedFingerprint: _clearedFp,
-                ...carried
-              } = instanceReceipt(owner.n, destinationKey);
-              owner.s.updateNode(n.id, {
-                attrs: updateInstanceReceipt(owner.n, destinationKey, {
-                  ...carried,
-                  shipRefusedSinceSeq: void 0,
-                  shipRefusedCount: void 0,
-                  shipRefusedReason: void 0,
-                  shipRefusedFingerprint: void 0,
-                  contributedAtSeq: instanceReceiptSequence(n),
-                  cloudNodeId
-                }, owner.s === store)
-              });
-            });
             await stampBatched(Object.entries(instances.anchorDigests), ([localId, dg]) => {
               const owner = owningStore(localId);
               if (!owner) return;
-              if (!edgeReceiptsComplete || !instanceReceipt(owner.n, destinationKey)["cloudNodeId"] || rejected.has(localId) || blocked.has(localId)) return;
+              if (!edgeReceipts.complete(localId, "anchor") || !instanceReceipt(owner.n, destinationKey)["cloudNodeId"] || rejected.has(localId) || blocked.has(localId)) return;
               owner.s.updateNode(localId, {
                 attrs: updateInstanceReceipt(owner.n, destinationKey, { anchorsContributedDigest: dg }, owner.s === store)
               });
@@ -90402,7 +90448,7 @@ async function startMultiDaemon(opts = {}) {
             await stampBatched(Object.entries(instances.projectAnchorDigests), ([localId, dg]) => {
               const owner = owningStore(localId);
               if (!owner) return;
-              if (!edgeReceiptsComplete || !instanceReceipt(owner.n, destinationKey)["cloudNodeId"] || rejected.has(localId) || blocked.has(localId)) return;
+              if (!edgeReceipts.complete(localId, "projectAnchor") || !instanceReceipt(owner.n, destinationKey)["cloudNodeId"] || rejected.has(localId) || blocked.has(localId)) return;
               owner.s.updateNode(localId, {
                 attrs: updateInstanceReceipt(owner.n, destinationKey, { projectAnchorsContributedDigest: dg }, owner.s === store)
               });
@@ -90410,7 +90456,7 @@ async function startMultiDaemon(opts = {}) {
             await stampBatched(Object.entries(instances.semanticEdgeDigests), ([localId, dg]) => {
               const owner = owningStore(localId);
               if (!owner) return;
-              if (!edgeReceiptsComplete || !instanceReceipt(owner.n, destinationKey)["cloudNodeId"] || rejected.has(localId) || blocked.has(localId)) return;
+              if (!edgeReceipts.complete(localId, "semantic") || !instanceReceipt(owner.n, destinationKey)["cloudNodeId"] || rejected.has(localId) || blocked.has(localId)) return;
               owner.s.updateNode(localId, {
                 attrs: updateInstanceReceipt(owner.n, destinationKey, { semanticEdgesContributedDigest: dg }, owner.s === store)
               });

package/package.json

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