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

package/errata.mjs

@@ -25270,15 +25270,17 @@ function triageBullet(ref) {
 }
 function linkBullet(ref) {
   return [
-    "  \u2022 you flagged a problem \u2014 LINK it, and do it ESPECIALLY when the finding feels novel.",
-    "    Work you just did feels specific to here; that feeling is why links go unwritten, and it is",
-    "    exactly backwards \u2014 a finding nobody can reach from anywhere else is one nobody reuses:",
+    // Lead-in states the trigger without the old "resembles prior knowledge"
+    // conditional (which gated the whole bullet on recognising a prior). Kept to ONE
+    // line on purpose: Cycle 13 measured this instruction at 55% of the 9,000-char
+    // passive-context budget, and every char here is paid for by evicting a prior the
+    // agent could have cited — so unproven framing is a net loss, however good it reads.
+    "  \u2022 you flagged a problem \u2014 LINK it, ESPECIALLY when the finding feels novel to here:",
     `    \xB7 (instance:[${ref}],[another-prior],\u2026) \u2014 the priors this problem is an instance of.`,
     "      Aim for ~3 DIFFERENT relevant priors; one link is weak, three triangulate it.",
     `    \xB7 ${TAG_EXAMPLE.pattern()} \u2014 name the general shape it instantiates (e.g. (pattern: unbounded`,
     "      queue growth under backpressure)) \u2014 this works with NO code anchor, and two agents naming",
-    "      the same pattern converge on one node. Naming the shape costs your finding nothing and is",
-    "      what lets a stranger hit it. Cite a shown Pattern by handle: (pattern:[handle]).",
+    "      the same pattern converge on one node. Cite a shown Pattern by handle: (pattern:[handle]).",
     `    \xB7 ${TAG_EXAMPLE.package()} \u2014 the PUBLIC PACKAGE the problem is about, even when this`,
     "      workspace doesn't depend on it (e.g. (package: chokidar), (package: pypi/requests)) \u2014 a",
     "      public-registry anchor lets the knowledge cross to the collective; internal names stay private.",
@@ -25385,7 +25387,7 @@ var init_agent_signals = __esm({
       // contribution, so stating the general area reads as vague restatement — exactly
       // when it matters most, because precise wording is what makes a problem
       // unfindable to anyone who doesn't already share it.
-      domain: "you flagged a problem that isn't about one specific file \u2014 name the AREA it's about. Precision is not a substitute: the sharper your wording, the LESS anyone else will search for it, and an abstract problem with no area is an invisible island. Title Case",
+      domain: "you flagged a problem that isn't about one specific file \u2014 name the AREA it's about. The sharper your wording, the LESS anyone else will search for it; an abstract problem with no area is an invisible island. Title Case",
       link: "the problem you flagged is an instance of priors/abstractions you can name \u2014 (instance:[h1],[h2],\u2026) / (pattern: \u2026) / (aids:[h]); rendered whole via linkBullet"
     };
   }
@@ -49650,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 {
@@ -49727,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/);
@@ -52274,7 +52315,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.204" : "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;
@@ -52294,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 {
   }
 }
@@ -52818,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) => {
@@ -53221,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.204",
+  "version": "2.0.2-dev.208",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {