@inerrata-corporation/errata 2.0.2-dev.682 → 2.0.2-dev.688

package/errata.mjs

@@ -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 [];
@@ -53558,7 +53573,12 @@ function passLedgerPath(configDir) {
 function appendPassLedger(configDir, kind, durationMs, counts) {
   const path2 = passLedgerPath(configDir);
   try {
-    const entry = { ts: Date.now(), kind, durationMs, counts };
+    const entry = {
+      ts: Date.now(),
+      kind,
+      durationMs,
+      counts: { ...counts, rssMB: Math.round(process.memoryUsage().rss / 1048576) }
+    };
     appendFileSync2(path2, JSON.stringify(entry) + "\n");
     const n = (appendsSinceTrim.get(path2) ?? 0) + 1;
     if (n < TRIM_EVERY) {
@@ -53744,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) => {
@@ -53831,7 +53871,15 @@ var PassWorker = class {
   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) => {
@@ -55407,7 +55455,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.682" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.688" : "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;
@@ -55953,6 +56001,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
@@ -56712,20 +56790,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) => {
@@ -58119,7 +58215,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) => {
@@ -60248,7 +60349,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);
@@ -60256,12 +60357,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) {
@@ -62160,7 +62261,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.682",
+  "version": "2.0.2-dev.688",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {