@inerrata-corporation/errata 2.0.2-dev.211 → 2.0.2-dev.220

package/errata.mjs

@@ -21852,7 +21852,7 @@ var init_client = __esm({
     init_oauth();
     init_src();
     asWireCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : null;
-    INGEST_NODE_CHUNK = 25;
+    INGEST_NODE_CHUNK = 8;
     CloudClient = class {
       baseUrl;
       apiKey;
@@ -22015,7 +22015,7 @@ var init_client = __esm({
       async ingest(batch) {
         const runId = randomUUID();
         if (batch.nodes.length <= INGEST_NODE_CHUNK && batch.edges.length <= MAX_EDGES_PER_PAYLOAD) {
-          const result = await this.ingestWire(toWirePayload(batch, runId));
+          const result = await this.ingestWithSplit(batch, batch.nodes, batch.edges);
           return { ...summarizeIngestResult(result), result };
         }
         const merged = { runId, nodes: [], edges: [] };
@@ -22028,7 +22028,7 @@ var init_client = __esm({
             const shipped = new Set(inChunk);
             pendingEdges = pendingEdges.filter((e) => !shipped.has(e));
           }
-          const r = await this.ingestWire(toWirePayload({ ...batch, nodes: nodeChunk, edges: inChunk }, randomUUID()));
+          const r = await this.ingestWithSplit(batch, nodeChunk, inChunk);
           merged.nodes.push(...r.nodes);
           merged.edges.push(...r.edges);
           for (const rn of r.nodes) {
@@ -22055,6 +22055,38 @@ var init_client = __esm({
       async ingestWire(payload) {
         return this.json("POST", "/v2/ingest", payload);
       }
+      /**
+       * Ship a node chunk, and on an EDGE TIMEOUT split it and retry the halves.
+       *
+       * `INGEST_NODE_CHUNK` is a guess about how long the server takes per node, and
+       * that number moves with the size of the graph — so any fixed value eventually
+       * drifts into the proxy's timeout and the lane dies silently (the 2026-07-31
+       * three-day instances-lane outage). This makes the client self-correcting
+       * instead: a chunk that times out is halved and retried, down to a single node,
+       * so the drain degrades to slower rather than to stopped.
+       *
+       * ONLY on timeout-shaped failures (502/504/408, or a transport abort). A 4xx is
+       * 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) {
+        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 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), []);
+          return {
+            runId: a.runId,
+            nodes: [...a.nodes, ...b.nodes],
+            edges: [...a.edges, ...b.edges],
+            ...a.patternReconciliation || b.patternReconciliation ? { patternReconciliation: { ...a.patternReconciliation, ...b.patternReconciliation } } : {}
+          };
+        }
+      }
       /**
        * SDK v2 graph-native write. It remembers a typed diagnostic spine through
        * `/v2/ingest` instead of the legacy forum question/answer routes:
@@ -52342,7 +52374,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.211" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.220" : "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;
@@ -54003,6 +54035,7 @@ function buildContextIngest(store, profile, daemonVersion, ignorePatterns = [],
     for (const n of store.findNodesByLabel(label)) {
       if (n.attrs["source"] === "cloud") continue;
       if (ignored(n.description) || ignored(String(n.attrs["name"] ?? ""))) continue;
+      if (typeof n.attrs["contributedAtSeq"] === "number") continue;
       nodes.push({
         ...n,
         // Language wire id = the shared `languageCanonicalId` (warming-spine
@@ -54046,7 +54079,7 @@ function buildContextIngest(store, profile, daemonVersion, ignorePatterns = [],
     nodes,
     edges
   };
-  return { ...base, payloadDigest: digest(base) };
+  return { ...base, payloadDigest: digest(base), localIds: [...seen] };
 }
 
 // src/lockfile-auto.ts
@@ -54901,14 +54934,35 @@ async function startMultiDaemon(opts = {}) {
   let boundaryFlushing = false;
   let boundaryFlushStartedAt = 0;
   let boundaryFlushStage = "";
+  let boundaryFlushUnits = 0;
+  let boundaryFlushLastAdvanceAt = 0;
+  let boundaryFlushBatches = 0;
   const beginFlush = (stage) => {
     boundaryFlushing = true;
     boundaryFlushStartedAt = Date.now();
+    boundaryFlushLastAdvanceAt = Date.now();
+    boundaryFlushUnits = 0;
+    boundaryFlushBatches = 0;
     boundaryFlushStage = stage;
   };
   const flushStage = (stage) => {
     boundaryFlushStage = stage;
   };
+  const noteFlushProgress = (units) => {
+    boundaryFlushBatches++;
+    if (units > 0) {
+      boundaryFlushUnits += units;
+      boundaryFlushLastAdvanceAt = Date.now();
+    }
+  };
+  const flushSnapshot = () => ({
+    running: boundaryFlushing,
+    stage: boundaryFlushStage,
+    ageMs: boundaryFlushStartedAt ? Date.now() - boundaryFlushStartedAt : 0,
+    units: boundaryFlushUnits,
+    batches: boundaryFlushBatches,
+    stalledMs: boundaryFlushLastAdvanceAt ? Date.now() - boundaryFlushLastAdvanceAt : 0
+  });
   const endFlush = () => {
     boundaryFlushing = false;
     boundaryFlushStage = "";
@@ -55489,8 +55543,10 @@ async function startMultiDaemon(opts = {}) {
       const errors = [];
       const lane = async (name2, projectName, run3) => {
         try {
-          await run3();
+          const accepted = await run3();
+          noteFlushProgress(typeof accepted === "number" ? accepted : 0);
         } catch (err2) {
+          noteFlushProgress(0);
           const msg = `[${projectName}] ${name2}: ${err2 instanceof Error ? err2.message : String(err2)}`;
           errors.push(msg);
           console.error(`[sync\u2192cloud] ${msg}`);
@@ -55506,6 +55562,13 @@ async function startMultiDaemon(opts = {}) {
           await lane("context", projectName, async () => {
             const res = await client.ingest(context);
             uploaded += res.accepted;
+            const seq = store.currentIngestSeq();
+            for (const localId of context.localIds) {
+              const local = store.getNode(localId);
+              if (!local) continue;
+              store.updateNode(localId, { attrs: { ...local.attrs, contributedAtSeq: seq } });
+            }
+            return res.accepted;
           });
         }
         let lexicon;
@@ -55562,6 +55625,7 @@ async function startMultiDaemon(opts = {}) {
                 attrs: { ...local.attrs, semanticEdgesContributedDigest: dg }
               });
             }
+            return res.accepted;
           });
         }
       }
@@ -55671,11 +55735,7 @@ async function startMultiDaemon(opts = {}) {
     }
   };
   app.post("/api/sync", async (c) => {
-    if (boundaryFlushing)
-      return c.json(
-        { skipped: "in-flight", stage: boundaryFlushStage, ageMs: Date.now() - boundaryFlushStartedAt },
-        409
-      );
+    if (boundaryFlushing) return c.json({ skipped: "in-flight", ...flushSnapshot() }, 409);
     beginFlush("principles");
     try {
       const principles = await daemon.syncPrinciplesPublic();
@@ -55692,6 +55752,7 @@ async function startMultiDaemon(opts = {}) {
       endFlush();
     }
   });
+  app.get("/api/sync", (c) => c.json(flushSnapshot()));
   app.post("/api/tick", async (c) => {
     try {
       return c.json({ reports: Object.fromEntries(await daemon.tickAll()) });
@@ -56847,6 +56908,28 @@ async function cmdStatus() {
   }
   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)) {
+    try {
+      const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
+      const store = openGraphStore2({ path: paths.castalia });
+      try {
+        let pending = 0;
+        let total = 0;
+        for (const label of ["Problem", "Solution", "RootCause"]) {
+          for (const n of store.findNodesByLabel(label)) {
+            if (n.attrs["source"] === "cloud") continue;
+            total++;
+            const c = n.attrs["contributedAtSeq"];
+            if (typeof c !== "number" || (n.lastReinforcedAtSeq ?? 0) > c) pending++;
+          }
+        }
+        console.log(`  contribute: ${pending} pending of ${total} instance node(s)`);
+      } finally {
+        store.close();
+      }
+    } catch {
+    }
+  }
   const lockPath = globalDaemonLock();
   const running = isDaemonAlive(lockPath) ? readDaemonLock(lockPath) : null;
   console.log(
@@ -58520,9 +58603,19 @@ async function cmdSync(arg) {
         const ageMs = typeof body2?.ageMs === "number" ? body2.ageMs : 0;
         const dur = ageMs >= 6e4 ? `${Math.floor(ageMs / 6e4)}m` : `${Math.max(1, Math.round(ageMs / 1e3))}s`;
         const stage = body2?.stage ? ` \u2014 stage: ${body2.stage}` : "";
+        const units = typeof body2?.units === "number" ? body2.units : 0;
+        const batches = typeof body2?.batches === "number" ? body2.batches : 0;
+        const stalledMs = typeof body2?.stalledMs === "number" ? body2.stalledMs : 0;
+        const moved = batches > 0 ? ` \xB7 ${batches} batch(es), ${units} accepted` : "";
         console.log(
-          ageMs > 0 ? `sync already running: the daemon has been draining for ${dur}${stage}. It will finish on its own; nothing new was started.` : "sync already running: the daemon is mid-drain \u2014 it will finish on its own. Nothing new was started."
+          ageMs > 0 ? `sync already running: the daemon has been draining for ${dur}${stage}${moved}. It will finish on its own; nothing new was started.` : "sync already running: the daemon is mid-drain \u2014 it will finish on its own. Nothing new was started."
         );
+        if (stalledMs > 12e4 && batches > 0) {
+          const stalledMin = Math.floor(stalledMs / 6e4);
+          console.log(
+            `  \u26A0 STALLED: ${batches} batch(es) shipped but nothing accepted for ${stalledMin}m \u2014 the lane is looping, not draining. Check \`errata status\` for the backlog depth and daemon.log for the failing lane.`
+          );
+        }
         if (ageMs > 30 * 6e4) {
           console.log(
             "  \u26A0 this pass has run past 30 min \u2014 if daemon.log shows no upload progress it may be stranded (a sleep/resume can do this). Restart with: errata stop && errata start"

package/package.json

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