@inerrata-corporation/errata 2.0.17-dev.3433 → 2.0.17-dev.3447

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.3433" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.17-dev.3447" : "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;
@@ -85076,6 +85086,17 @@ 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_dist();
@@ -87681,6 +87702,10 @@ async function walk10(root, input, client, opts, readBlob) {
   const launched = /* @__PURE__ */ new Map();
   const cap = opts.maxUnits;
   const edgeParked = /* @__PURE__ */ new Set();
+  const parkedEarlier = new Set((profile.historyStage?.coverageGaps ?? []).filter((g) => g.reason === "edge-blocked").map((g) => `${g.sha}/${g.subIndex}`));
+  units.forEach((u, j) => {
+    if (parkedEarlier.has(`${u.sha}/${u.subIndex}`)) edgeParked.add(j);
+  });
   const predecessor = (k) => {
     for (let j = k - 1; j >= 0; j--) if (!units[j].skip && !edgeParked.has(j)) return units[j];
     return void 0;
@@ -87746,7 +87771,7 @@ async function walk10(root, input, client, opts, readBlob) {
     let ahead = 0;
     for (let j = k + 1; j < units.length && ahead < lookahead; j++) {
       if (cap !== void 0 && processed + (j - k) >= cap) break;
-      if (units[j].skip) continue;
+      if (units[j].skip || edgeParked.has(j)) continue;
       ahead += 1;
       await launch(j);
     }
@@ -87767,6 +87792,13 @@ async function walk10(root, input, client, opts, readBlob) {
       log(`[errata] history ${label} skipped (${u.skip})`);
       continue;
     }
+    if (edgeParked.has(k)) {
+      profile = stage(profile, { state: dryRun ? "extracting" : "contributing", unitsDone: doneSoFar, counts, ...lastInPosition ? { watermarkSha: positionSha } : {} }, now);
+      persist(profile);
+      processed += 1;
+      log(`[errata] history ${label}: edge-blocked on an earlier run; gap kept, not re-sent`);
+      continue;
+    }
     const { body: body2, prepMs } = await prepare(k);
     profile = stage(profile, { state: dryRun ? "extracting" : "contributing", unitsDone: doneSoFar - 1, lastError: void 0 }, now);
     persist(profile);
@@ -90279,10 +90311,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}`);
               }
             });
@@ -90292,9 +90338,6 @@ 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");
@@ -90317,13 +90360,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 = [];
@@ -90354,32 +90390,6 @@ 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;

package/package.json

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