@inerrata-corporation/errata 2.0.2-dev.685 → 2.0.2-dev.690

package/errata.mjs

@@ -32946,7 +32946,7 @@ async function Module2(moduleArg = {}) {
       }
     };
     if (flags.loadAsync) {
-      return metadata.neededDynlibs.reduce((chain, dynNeeded) => chain.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);
+      return metadata.neededDynlibs.reduce((chain2, dynNeeded) => chain2.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);
     }
     metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));
     return loadModule();
@@ -49533,13 +49533,13 @@ function learnedCard(c, opts) {
   }
   if (c.chain.instanceOf)
     segs.push(`<span class="e">INSTANCE_OF</span> <span class="rc">${esc3(c.chain.instanceOf)}</span>`);
-  const chain = segs.length > 0 ? `\u2514\u2500 ${segs.join(" \u2500 ")}` : '\u2514\u2500 <span class="rc">(no causal chain yet)</span>';
+  const chain2 = segs.length > 0 ? `\u2514\u2500 ${segs.join(" \u2500 ")}` : '\u2514\u2500 <span class="rc">(no causal chain yet)</span>';
   return `<div class="lcard">
   <div class="row1">
     <span class="prob">${esc3(c.problem)}</span>
     <span class="badge ${PROV_CLASS[c.provenance]}">${BADGE2[c.provenance]} ${PROV_LABEL[c.provenance]}</span>
   </div>
-  <div class="chain">${chain}</div>
+  <div class="chain">${chain2}</div>
   <div class="lfoot">${trustHtml(c.trust, c.trustNote)}${nextHtml(c.next, opts)}</div>
 </div>`;
 }
@@ -52221,23 +52221,38 @@ init_review2();
 import { closeSync, existsSync as existsSync12, fstatSync, openSync, readdirSync as readdirSync5, readSync, statSync as statSync3 } from "node:fs";
 import { basename as basename3, dirname as dirname8, join as join15 } from "node:path";
 import { homedir as homedir3 } from "node:os";
-function readFrom(path2, fromByte) {
+function readFrom(path2, fromByte, maxBytes) {
   let fd;
   try {
     fd = openSync(path2, "r");
   } catch {
-    return { text: "", nextOffset: fromByte };
+    return { text: "", nextOffset: fromByte, more: false };
   }
   try {
     const size = fstatSync(fd).size;
     const start2 = fromByte > 0 && fromByte <= size ? fromByte : 0;
-    const len = size - start2;
-    if (len <= 0) return { text: "", nextOffset: size };
-    const buf = Buffer.allocUnsafe(len);
-    readSync(fd, buf, 0, len, start2);
-    return { text: buf.toString("utf8"), nextOffset: size };
+    const remaining = size - start2;
+    if (remaining <= 0) return { text: "", nextOffset: size, more: false };
+    let cap = maxBytes && maxBytes > 0 ? maxBytes : remaining;
+    for (; ; ) {
+      const len = Math.min(cap, remaining);
+      const buf = Buffer.allocUnsafe(len);
+      readSync(fd, buf, 0, len, start2);
+      if (len >= remaining) {
+        return { text: buf.toString("utf8"), nextOffset: size, more: false };
+      }
+      const nl = buf.lastIndexOf(10);
+      if (nl >= 0) {
+        return {
+          text: buf.subarray(0, nl + 1).toString("utf8"),
+          nextOffset: start2 + nl + 1,
+          more: true
+        };
+      }
+      cap *= 2;
+    }
   } catch {
-    return { text: "", nextOffset: fromByte };
+    return { text: "", nextOffset: fromByte, more: false };
   } finally {
     closeSync(fd);
   }
@@ -52333,9 +52348,9 @@ function isUserTurnBoundary(obj) {
 function readAssistantTurns(transcriptPath, includeThinking = true, maxBytes = 2e6) {
   return parseAssistantTurns(readTail(transcriptPath, maxBytes), includeThinking);
 }
-function readAssistantTurnsFrom(transcriptPath, fromByte, includeThinking = true) {
-  const { text, nextOffset } = readFrom(transcriptPath, fromByte);
-  return { turns: parseAssistantTurns(text, includeThinking), nextOffset };
+function readAssistantTurnsFrom(transcriptPath, fromByte, includeThinking = true, maxBytes) {
+  const { text, nextOffset, more } = readFrom(transcriptPath, fromByte, maxBytes);
+  return { turns: parseAssistantTurns(text, includeThinking), nextOffset, more };
 }
 function parseAssistantTurns(raw2, includeThinking) {
   if (!raw2) return [];
@@ -53749,18 +53764,38 @@ function recordEpisode(store, workspaceId2, t, delta, causal) {
   return id;
 }
 
+// src/footprint.ts
+function numEnv(key, fallback) {
+  const raw2 = process.env[key];
+  if (raw2 == null || raw2.trim() === "") return fallback;
+  const n = Number(raw2);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var DAEMON_MAX_HEAP_MB = numEnv("ERRATA_MAX_HEAP_MB", 2048);
+var WORKER_MAX_HEAP_MB = numEnv("ERRATA_WORKER_MAX_HEAP_MB", 1024);
+var HARVEST_SLICE_BYTES = numEnv("ERRATA_HARVEST_SLICE_BYTES", 4e6);
+function workerResourceLimits() {
+  return { maxOldGenerationSizeMb: WORKER_MAX_HEAP_MB };
+}
+function isWorkerOom(err2) {
+  const e = err2;
+  if (!e) return false;
+  if (e.code === "ERR_WORKER_OUT_OF_MEMORY") return true;
+  return /out of memory|ERR_WORKER_OUT_OF_MEMORY|heap limit/i.test(e.message ?? "");
+}
+
 // src/episode-retention.ts
 var EPISODE_RETAIN_DAYS_DEFAULT = 90;
 var EPISODE_RETIRE_BATCH_DEFAULT = 300;
 var DAY_MS = 864e5;
-function numEnv(key, fallback) {
+function numEnv2(key, fallback) {
   const raw2 = process.env[key];
   if (raw2 == null || raw2.trim() === "") return fallback;
   const n = Number(raw2);
   return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 function retireEpisodeProvenance(store, now, opts = {}) {
-  const retainDays = opts.retainDays ?? numEnv("ERRATA_EPISODE_RETAIN_DAYS", EPISODE_RETAIN_DAYS_DEFAULT);
+  const retainDays = opts.retainDays ?? numEnv2("ERRATA_EPISODE_RETAIN_DAYS", EPISODE_RETAIN_DAYS_DEFAULT);
   const batch = opts.batch ?? EPISODE_RETIRE_BATCH_DEFAULT;
   const cutoff = now - retainDays * DAY_MS;
   const due = store.findNodesByLabel("Episode").filter((ep) => {
@@ -53794,6 +53829,27 @@ function retireEpisodeProvenance(store, now, opts = {}) {
 
 // src/pass-worker-client.ts
 import { Worker } from "node:worker_threads";
+
+// src/pass-gate.ts
+var QUEUE_WARN_MS = 12e4;
+var chain = Promise.resolve();
+function withHeavyPassSlot(label, fn) {
+  const queuedAt = Date.now();
+  const run3 = chain.then(() => {
+    const waited = Date.now() - queuedAt;
+    if (waited > QUEUE_WARN_MS) {
+      console.warn(`[errata] heavy-pass slot: ${label} waited ${Math.round(waited / 1e3)}s`);
+    }
+    return fn();
+  });
+  chain = run3.then(
+    () => void 0,
+    () => void 0
+  );
+  return run3;
+}
+
+// src/pass-worker-client.ts
 var PassWorker = class {
   constructor(init2) {
     this.init = init2;
@@ -53824,19 +53880,30 @@ var PassWorker = class {
   }
   call(kind, payload) {
     if (this.stopped) return Promise.reject(new Error("pass worker stopped"));
-    this.ensureWorker();
-    const id = this.nextId++;
-    return this.ready.then(
-      () => new Promise((resolve6, reject) => {
-        this.pending.set(id, { resolve: resolve6, reject });
-        this.worker.postMessage({ id, kind, ...payload !== void 0 ? { payload } : {} });
-      })
-    );
+    return withHeavyPassSlot(`${kind}:${this.init.workspaceId}`, () => {
+      if (this.stopped) return Promise.reject(new Error("pass worker stopped"));
+      this.ensureWorker();
+      const id = this.nextId++;
+      return this.ready.then(
+        () => new Promise((resolve6, reject) => {
+          this.pending.set(id, { resolve: resolve6, reject });
+          this.worker.postMessage({ id, kind, ...payload !== void 0 ? { payload } : {} });
+        })
+      );
+    });
   }
   ensureWorker() {
     if (this.worker) return;
     const workerUrl = new URL("./pass-worker.mjs", import.meta.url);
-    const worker = new Worker(workerUrl, { workerData: this.init, execArgv: process.execArgv });
+    const worker = new Worker(workerUrl, {
+      workerData: this.init,
+      execArgv: process.execArgv,
+      // HZ-footprint-cap: hard heap ceiling per isolate. A pass that would
+      // exceed it dies HERE, in the isolate built to be expendable — the
+      // engine's fallback must then SKIP the pass (isWorkerOom), never re-run
+      // it inline where the same allocation would take down the hook server.
+      resourceLimits: workerResourceLimits()
+    });
     this.worker = worker;
     this.ready = new Promise((resolve6, reject) => {
       const onReady = (m) => {
@@ -55412,7 +55479,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.685" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.690" : "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;
@@ -55958,6 +56025,36 @@ function createWorkspaceEngine(opts) {
         }
         return { report: r.report, localSkills: r.localSkills };
       } catch (err2) {
+        if (isWorkerOom(err2)) {
+          console.warn("[errata] nightly worker hit its heap ceiling \u2014 heavy pass skipped this fire");
+          appendPassLedger(paths.configDir, "graph-rescore", 0, { oomSkipped: 1 });
+          const sem = runSemanticMaintenance(store);
+          return {
+            report: {
+              scoredNodes: 0,
+              iterations: 0,
+              converged: true,
+              landmarks: 0,
+              communities: 0,
+              motifsPromoted: 0,
+              techniques: 0,
+              antipatterns: 0,
+              skillsInduced: 0,
+              skillsRefreshed: 0,
+              pageRankWritten: 0,
+              landmarkFlips: 0,
+              mode: "incremental",
+              regionSize: 0,
+              designResolved: sem.designResolved,
+              revisitsCleared: sem.revisitsCleared,
+              fixCandidatesSettled: sem.fixCandidatesSettled,
+              claimsEvaluated: sem.claimsEvaluated,
+              claimsDerived: sem.claimsDerived,
+              durationMs: sem.durationMs
+            },
+            localSkills: 0
+          };
+        }
         console.warn(
           "[errata] nightly worker unavailable, running inline:",
           err2 instanceof Error ? err2.message : err2
@@ -56717,20 +56814,38 @@ function createWorkspaceEngine(opts) {
         turns = readAssistantTurns(transcriptPath);
         nextOffset = transcriptSize(transcriptPath);
       } else {
-        ({ turns, nextOffset } = readAssistantTurnsFrom(transcriptPath, known));
+        ({ turns, nextOffset } = readAssistantTurnsFrom(transcriptPath, known, true, HARVEST_SLICE_BYTES));
       }
     } catch {
       return;
     }
-    const fresh = turnsSince(turns, lastTurnUuid.get(sessionId));
-    turnOffset.set(sessionId, nextOffset);
-    if (fresh.length === 0) {
+    for (let slice = 0; ; slice++) {
+      const fresh = turnsSince(turns, lastTurnUuid.get(sessionId));
+      turnOffset.set(sessionId, nextOffset);
+      if (fresh.length > 0) {
+        lastTurnUuid.set(sessionId, turns[turns.length - 1].uuid);
+        await harvestTexts(sessionId, fresh);
+      }
       saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
-      return;
+      if (slice >= 256) {
+        console.warn("[errata] harvest slice guard hit \u2014 backlog resumes next tick");
+        break;
+      }
+      let next;
+      try {
+        next = readAssistantTurnsFrom(transcriptPath, nextOffset, true, HARVEST_SLICE_BYTES);
+      } catch {
+        break;
+      }
+      if (next.turns.length === 0 && !next.more) {
+        turnOffset.set(sessionId, next.nextOffset);
+        saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
+        break;
+      }
+      turns = next.turns;
+      nextOffset = next.nextOffset;
+      await new Promise((resolve6) => setImmediate(resolve6));
     }
-    lastTurnUuid.set(sessionId, turns[turns.length - 1].uuid);
-    await harvestTexts(sessionId, fresh);
-    saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
   };
   const seenMessageIds = /* @__PURE__ */ new Set();
   const onMessage = (e) => {
@@ -58124,7 +58239,12 @@ var ConsolidateWorker = class {
   ensureWorker() {
     if (this.worker) return;
     const workerUrl = new URL("./consolidate-worker.mjs", import.meta.url);
-    const worker = new Worker2(workerUrl, { workerData: {}, execArgv: process.execArgv });
+    const worker = new Worker2(workerUrl, {
+      workerData: {},
+      execArgv: process.execArgv,
+      // HZ-footprint-cap — see pass-worker-client.ts for the contract.
+      resourceLimits: workerResourceLimits()
+    });
     this.worker = worker;
     this.ready = new Promise((resolve6, reject) => {
       const onReady = (m) => {
@@ -58485,7 +58605,7 @@ function findGitRoot(absPath) {
 var RETRY_COOLDOWN_MS = 15 * 6e4;
 function createRootAdopter(deps) {
   const attempted = /* @__PURE__ */ new Map();
-  let chain = Promise.resolve();
+  let chain2 = Promise.resolve();
   const tryAdopt = async (path2) => {
     if (!deps.linkingAllowed()) return;
     const root = findGitRoot(path2);
@@ -58505,9 +58625,9 @@ function createRootAdopter(deps) {
   return {
     noteMiss(path2) {
       if (!path2) return;
-      chain = chain.then(() => tryAdopt(path2)).catch(() => void 0);
+      chain2 = chain2.then(() => tryAdopt(path2)).catch(() => void 0);
     },
-    idle: () => chain
+    idle: () => chain2
   };
 }
 
@@ -60253,7 +60373,7 @@ var DEFAULT_CONSOLIDATION_POLICY = {
   quiescenceMs: 6e4
   // sim preferred 60s over 90s (fresher, esp. heavy-code)
 };
-function numEnv2(env2, key, fallback) {
+function numEnv3(env2, key, fallback) {
   const raw2 = env2[key];
   if (raw2 == null || raw2.trim() === "") return fallback;
   const n = Number(raw2);
@@ -60261,12 +60381,12 @@ function numEnv2(env2, key, fallback) {
 }
 function consolidationPolicyFromEnv(env2 = process.env) {
   return {
-    baseFloorMs: numEnv2(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
-    dutyFactor: numEnv2(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
-    momentumThreshold: numEnv2(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
-    momentumRatio: numEnv2(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
-    momentumRatioCap: numEnv2(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
-    quiescenceMs: numEnv2(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
+    baseFloorMs: numEnv3(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
+    dutyFactor: numEnv3(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
+    momentumThreshold: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
+    momentumRatio: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
+    momentumRatioCap: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
+    quiescenceMs: numEnv3(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
   };
 }
 function consolidationGapMs(lastPassMs, policy) {
@@ -62165,7 +62285,16 @@ function spawnDaemonDetached() {
     detached: true,
     stdio: ["ignore", out2, out2],
     windowsHide: true,
-    cwd: ROOT
+    cwd: ROOT,
+    // HZ-footprint-cap: hard V8 old-space ceiling on the daemon process. The
+    // workers carry their own resourceLimits; this bounds the main isolate
+    // (hook server + capture), whose bursts are slice-capped so the ceiling is
+    // a backstop, not a working limit. NODE_OPTIONS so it applies however the
+    // bundle re-executes.
+    env: {
+      ...process.env,
+      NODE_OPTIONS: `${process.env["NODE_OPTIONS"] ?? ""} --max-old-space-size=${DAEMON_MAX_HEAP_MB}`.trim()
+    }
   }).unref();
   if (out2 !== "ignore") closeSync2(out2);
 }

package/package.json

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