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

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/);
@@ -52276,7 +52315,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.208" : "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 +52335,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 +52878,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 +53282,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.208",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {