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

package/errata.mjs

@@ -49652,6 +49652,39 @@ 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) {
+  let fd;
+  try {
+    fd = openSync(path2, "r");
+  } catch {
+    return { text: "", nextOffset: fromByte };
+  }
+  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 };
+  } catch {
+    return { text: "", nextOffset: fromByte };
+  } finally {
+    closeSync(fd);
+  }
+}
+function transcriptSize(path2) {
+  try {
+    const fd = openSync(path2, "r");
+    try {
+      return fstatSync(fd).size;
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return 0;
+  }
+}
 function readTail(path2, maxBytes) {
   let fd;
   try {
@@ -49729,7 +49762,13 @@ function isUserTurnBoundary(obj) {
   return blocks.some((b) => b["type"] === "text");
 }
 function readAssistantTurns(transcriptPath, includeThinking = true, maxBytes = 2e6) {
-  const raw2 = readTail(transcriptPath, maxBytes);
+  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 parseAssistantTurns(raw2, includeThinking) {
   if (!raw2) return [];
   const turns = [];
   const lines = raw2.split(/\r?\n/);
@@ -50583,7 +50622,9 @@ var EMPTY = {
   detached: 0,
   reopened: 0,
   witnessed: 0,
-  cloudTwins: []
+  cloudTwins: [],
+  reminted: 0,
+  recoverable: 0
 };
 function markerPath(configDir) {
   return join16(configDir, "constraint-backfill.json");
@@ -50649,8 +50690,11 @@ function backfillConstraintKind(store, opts) {
     detached: 0,
     reopened: 0,
     witnessed: 0,
-    cloudTwins: []
+    cloudTwins: [],
+    reminted: 0,
+    recoverable: 0
   };
+  const missing = [];
   const seen = /* @__PURE__ */ new Set();
   const work = [];
   for (const statement of statements) {
@@ -50658,7 +50702,10 @@ function backfillConstraintKind(store, opts) {
     if (seen.has(id)) continue;
     seen.add(id);
     const node2 = store.getNode(id);
-    if (!node2 || node2.label !== "Problem") continue;
+    if (!node2 || node2.label !== "Problem") {
+      missing.push(statement);
+      continue;
+    }
     const isWitnessed = citedByFix.has(priorHandle(node2)) || citedByFix.has(id) || [...citedByFix].some((c) => c && id.startsWith(c));
     const fabricated = [];
     for (const e of store.outEdges(id, ["SOLVED_BY"])) {
@@ -50680,7 +50727,26 @@ function backfillConstraintKind(store, opts) {
     }
     if (stamp || fabricated.length > 0) work.push({ id, fabricated, stamp });
   }
-  if (opts.dryRun) return report;
+  report.recoverable = opts.remint ? 0 : missing.length;
+  if (opts.dryRun) {
+    report.reminted = opts.remint ? missing.length : 0;
+    return report;
+  }
+  if (opts.remint && missing.length > 0) {
+    store.transaction(() => {
+      for (const statement of missing) {
+        try {
+          const r = ingestDesignProblem(
+            store,
+            { problem: statement, kind: "constraint" },
+            { workspaceId: "", source: `constraint-remint:v${BACKFILL_VERSION}`, ts: opts.now }
+          );
+          if (r.created) report.reminted++;
+        } catch {
+        }
+      }
+    });
+  }
   store.transaction(() => {
     for (const w of work) {
       const node2 = store.getNode(w.id);
@@ -52276,7 +52342,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.206" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.211" : "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;
@@ -52296,14 +52362,33 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    return new Map(Object.entries(JSON.parse(readFileSync18(path2, "utf8"))));
+    const raw2 = JSON.parse(readFileSync18(path2, "utf8"));
+    return new Map(
+      Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
+    );
   } catch {
     return /* @__PURE__ */ new Map();
   }
 }
-function saveTurnCursors(path2, cursors) {
+function loadTurnOffsets(path2) {
   try {
-    writeFileSync15(path2, JSON.stringify(Object.fromEntries(cursors)), "utf8");
+    const raw2 = JSON.parse(readFileSync18(path2, "utf8"));
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of Object.entries(raw2)) {
+      const off = typeof v === "object" && v !== null ? v.offset : void 0;
+      if (typeof off === "number" && off >= 0) out2.set(k, off);
+    }
+    return out2;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function saveTurnCursors(path2, cursors, offsets) {
+  try {
+    const merged = {};
+    for (const [k, uuid3] of cursors) merged[k] = { uuid: uuid3, offset: offsets.get(k) ?? 0 };
+    for (const [k, offset] of offsets) if (!merged[k]) merged[k] = { uuid: "", offset };
+    writeFileSync15(path2, JSON.stringify(merged), "utf8");
   } catch {
   }
 }
@@ -52820,6 +52905,7 @@ function createWorkspaceEngine(opts) {
   };
   const turnCursorPath = join23(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
+  const turnOffset = loadTurnOffsets(turnCursorPath);
   const sessionLastProblem = /* @__PURE__ */ new Map();
   const sessionThreads = /* @__PURE__ */ new Map();
   const harvestTexts = async (sessionId, items) => {
@@ -53223,17 +53309,28 @@ function createWorkspaceEngine(opts) {
     }
   };
   const harvestTurns = async (sessionId, transcriptPath) => {
+    const known = turnOffset.get(sessionId);
     let turns;
+    let nextOffset;
     try {
-      turns = readAssistantTurns(transcriptPath);
+      if (known === void 0) {
+        turns = readAssistantTurns(transcriptPath);
+        nextOffset = transcriptSize(transcriptPath);
+      } else {
+        ({ turns, nextOffset } = readAssistantTurnsFrom(transcriptPath, known));
+      }
     } catch {
       return;
     }
     const fresh = turnsSince(turns, lastTurnUuid.get(sessionId));
-    if (fresh.length === 0) return;
+    turnOffset.set(sessionId, nextOffset);
+    if (fresh.length === 0) {
+      saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
+      return;
+    }
     lastTurnUuid.set(sessionId, turns[turns.length - 1].uuid);
     await harvestTexts(sessionId, fresh);
-    saveTurnCursors(turnCursorPath, lastTurnUuid);
+    saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
   };
   const seenMessageIds = /* @__PURE__ */ new Set();
   const onMessage = (e) => {

package/package.json

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