@inerrata-corporation/errata 2.0.17-dev.3492 → 2.0.17-dev.3501

package/errata.mjs

@@ -82246,7 +82246,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.17-dev.3492" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.17-dev.3501" : "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;
@@ -87726,6 +87726,10 @@ var execFileAsync2 = promisify4(execFile5);
 var HISTORY_EXTRACTOR_VERSION = "history-2";
 var LEASE_POLL_MS = 2e4;
 var RECOVERY_DEADLINE_MS = 15 * 6e4;
+var UNIT_ATTEMPTS = 3;
+function isDoorDeferral(outcome) {
+  return outcome.status === "error" && !!outcome.parked && !!outcome.runId && ["deferred-context", "deferred-budget"].includes(outcome.errorCode ?? "");
+}
 var DEFAULT_LOOKAHEAD = 2;
 var CONTENT_TRANSPORT_VERSION = 1;
 async function defaultGit(root, args2) {
@@ -88036,58 +88040,69 @@ async function walk10(root, input, client, opts, readBlob) {
     let attempt = 0;
     let edgeBlocks = 0;
     let parkedAtEdge = false;
-    while (outcome === null) {
-      attempt += 1;
-      if (!first && body2.backfill && body2.backfill.anchorSeq === void 0 && anchor.seq !== void 0) {
-        body2.backfill = { ...body2.backfill, anchorSeq: anchor.seq };
-      }
-      if (!first && body2.after) {
-        const prev = predecessor(k);
-        if (!prev) delete body2.after;
-        else if (prev.sha !== body2.after.sha || prev.subIndex !== body2.after.subIndex) body2.after = { sha: prev.sha, subIndex: prev.subIndex };
-      }
-      const settled = await (first ?? settle(Promise.resolve().then(() => post(projectId, body2))));
-      first = null;
-      if ("err" in settled) {
-        const err2 = settled.err;
-        const status = err2 instanceof CloudError ? err2.status : 0;
-        const elapsed = Math.round((Date.now() - started2) / 1e3);
-        if (isEdgeContentBlock(err2) && ++edgeBlocks >= 2) {
-          parkedAtEdge = true;
-          break;
+    let unitTries = 0;
+    unitAttempt: for (; ; ) {
+      unitTries += 1;
+      outcome = null;
+      while (outcome === null) {
+        attempt += 1;
+        if (!first && body2.backfill && body2.backfill.anchorSeq === void 0 && anchor.seq !== void 0) {
+          body2.backfill = { ...body2.backfill, anchorSeq: anchor.seq };
+        }
+        if (!first && body2.after) {
+          const prev = predecessor(k);
+          if (!prev) delete body2.after;
+          else if (prev.sha !== body2.after.sha || prev.subIndex !== body2.after.subIndex) body2.after = { sha: prev.sha, subIndex: prev.subIndex };
+        }
+        const settled = await (first ?? settle(Promise.resolve().then(() => post(projectId, body2))));
+        first = null;
+        if ("err" in settled) {
+          const err2 = settled.err;
+          const status = err2 instanceof CloudError ? err2.status : 0;
+          const elapsed = Math.round((Date.now() - started2) / 1e3);
+          if (isEdgeContentBlock(err2) && ++edgeBlocks >= 2) {
+            parkedAtEdge = true;
+            break;
+          }
+          if (Date.now() - started2 > RECOVERY_DEADLINE_MS) {
+            profile = stage(profile, { state: "paused", lastError: `unit ${label}: ${status || "connection"} after ${elapsed}s, giving up until the next run` }, now);
+            persist(profile);
+            await reportHistoryStage(client, profile, log);
+            return { profile, processed, state: "paused" };
+          }
+          const detail = err2 instanceof Error ? ` (${err2.message.replace(/\s+/g, " ").slice(0, 160)})` : "";
+          log(`[errata] history ${label}: HTTP ${status || "connection error"} on attempt ${attempt} after ${elapsed}s${detail} \u2014 re-POSTing the same unit`);
+          await sleep(attempt === 1 ? 1e4 : Math.min(3e4 * attempt, 12e4));
+          continue;
         }
-        if (Date.now() - started2 > RECOVERY_DEADLINE_MS) {
-          profile = stage(profile, { state: "paused", lastError: `unit ${label}: ${status || "connection"} after ${elapsed}s, giving up until the next run` }, now);
+        const res = settled.res;
+        if (res.ordered) doorOrders = true;
+        if (res.backfill && anchor.seq === void 0) {
+          anchor.seq = res.backfill.anchorSeq;
+          profile = stage(profile, { backfillAnchor: { ...anchor } }, now);
           persist(profile);
-          await reportHistoryStage(client, profile, log);
-          return { profile, processed, state: "paused" };
         }
-        const detail = err2 instanceof Error ? ` (${err2.message.replace(/\s+/g, " ").slice(0, 160)})` : "";
-        log(`[errata] history ${label}: HTTP ${status || "connection error"} on attempt ${attempt} after ${elapsed}s${detail} \u2014 re-POSTing the same unit`);
-        await sleep(attempt === 1 ? 1e4 : Math.min(3e4 * attempt, 12e4));
-        continue;
-      }
-      const res = settled.res;
-      if (res.ordered) doorOrders = true;
-      if (res.backfill && anchor.seq === void 0) {
-        anchor.seq = res.backfill.anchorSeq;
-        profile = stage(profile, { backfillAnchor: { ...anchor } }, now);
-        persist(profile);
-      }
-      if (res.status === "in_progress") {
-        const retryAt = new Date(Date.now() + res.retryAfterMs).toISOString();
-        if (Date.now() - started2 > RECOVERY_DEADLINE_MS) {
-          profile = stage(profile, { state: "paused", lastError: `waiting on held lease for ${label}, retry at ${retryAt}` }, now);
-          persist(profile);
-          await reportHistoryStage(client, profile, log);
-          return { profile, processed, state: "paused" };
+        if (res.status === "in_progress") {
+          const retryAt = new Date(Date.now() + res.retryAfterMs).toISOString();
+          if (Date.now() - started2 > RECOVERY_DEADLINE_MS) {
+            profile = stage(profile, { state: "paused", lastError: `waiting on held lease for ${label}, retry at ${retryAt}` }, now);
+            persist(profile);
+            await reportHistoryStage(client, profile, log);
+            return { profile, processed, state: "paused" };
+          }
+          const why = res.waitingOn === "predecessor" ? `sent ahead, its predecessor ${res.predecessor === "failed" ? "failed" : "had not landed"} \u2014 re-POSTing in turn` : "run held by the door (lease)";
+          log(`[errata] history ${label}: ${why}, polling in ${Math.min(LEASE_POLL_MS, res.retryAfterMs) / 1e3}s`);
+          await sleep(Math.min(LEASE_POLL_MS, Math.max(1e3, res.retryAfterMs)));
+          continue;
         }
-        const why = res.waitingOn === "predecessor" ? `sent ahead, its predecessor ${res.predecessor === "failed" ? "failed" : "had not landed"} \u2014 re-POSTing in turn` : "run held by the door (lease)";
-        log(`[errata] history ${label}: ${why}, polling in ${Math.min(LEASE_POLL_MS, res.retryAfterMs) / 1e3}s`);
-        await sleep(Math.min(LEASE_POLL_MS, Math.max(1e3, res.retryAfterMs)));
-        continue;
+        outcome = res;
+      }
+      if (!parkedAtEdge && outcome !== null && outcome.status === "error" && !isDoorDeferral(outcome) && unitTries < UNIT_ATTEMPTS) {
+        log(`[errata] history ${label}: ${outcome.errorCode ?? "error"} on try ${unitTries}/${UNIT_ATTEMPTS} (${outcome.error.slice(0, 80)}) \u2014 re-sending`);
+        await sleep(5e3);
+        continue unitAttempt;
       }
-      outcome = res;
+      break;
     }
     if (parkedAtEdge || outcome === null) {
       edgeParked.add(k);
@@ -88135,7 +88150,7 @@ async function walk10(root, input, client, opts, readBlob) {
         return { profile, processed, state: "refused" };
       case "rejected":
       case "error":
-        if (outcome.status === "error" && outcome.parked && outcome.runId && ["deferred-context", "deferred-budget"].includes(outcome.errorCode ?? "")) {
+        if (isDoorDeferral(outcome)) {
           const gaps = [...profile.historyStage?.coverageGaps ?? []];
           const recoveredGap = recovering ? gaps.findIndex((g) => g.reason === "edge-blocked" && unitKey(g) === unitKey(u)) : -1;
           if (recoveredGap >= 0) gaps.splice(recoveredGap, 1);
@@ -88146,10 +88161,28 @@ async function walk10(root, input, client, opts, readBlob) {
           log(`[errata] history ${label}: deferred (${outcome.errorCode}); coverage gap retained as ${outcome.runId}`);
           break;
         }
-        profile = stage(profile, { state: "paused", lastError: `unit ${label} ${outcome.status}: ${outcome.error.slice(0, 200)}` }, now);
-        persist(profile);
-        await reportHistoryStage(client, profile, log);
-        return { profile, processed, state: "paused" };
+        {
+          edgeParked.add(k);
+          const code = outcome.errorCode ?? (outcome.status === "rejected" ? "invalid" : "error");
+          const reason = `${outcome.status === "rejected" ? "rejected" : "failed"}:${code}`;
+          const runId = `unit-${reason}:${u.sha}/${u.subIndex}`;
+          const gaps = [...profile.historyStage?.coverageGaps ?? []];
+          const known = gaps.some((g) => unitKey(g) === unitKey(u) && g.reason === reason);
+          counts = addCounts(counts, { commitsWalked: walkIncrement, deferredUnits: known ? 0 : 1 });
+          if (!known) gaps.push({ sha: u.sha, subIndex: u.subIndex, runId, reason });
+          profile = stage(profile, { coverageGaps: gaps.slice(-1e3) }, now);
+          log(`[errata] history ${label}: ${outcome.status} (${code}) after ${unitTries} ${unitTries === 1 ? "try" : "tries"}: ${outcome.error.slice(0, 120)} \u2014 coverage gap retained as ${runId}, walking on`);
+          break;
+        }
+    }
+    if (["completed", "replayed", "empty"].includes(outcome.status)) {
+      const before = profile.historyStage?.coverageGaps ?? [];
+      const gaps = before.filter((g) => !(unitKey(g) === unitKey(u) && g.reason.startsWith("failed:")));
+      if (gaps.length !== before.length) {
+        counts.deferredUnits = Math.max(0, (counts.deferredUnits ?? 0) - (before.length - gaps.length));
+        profile = stage(profile, { coverageGaps: gaps }, now);
+        log(`[errata] history ${label}: recovered an earlier failed extraction`);
+      }
     }
     if (recovering && ["completed", "replayed", "empty"].includes(outcome.status)) {
       const gaps = (profile.historyStage?.coverageGaps ?? []).filter((g) => !(g.reason === "edge-blocked" && unitKey(g) === unitKey(u)));
@@ -91449,6 +91482,27 @@ function buildCodexHooksToml(port, options) {
   );
   return CODEX_HOOKS_BEGIN + "\n" + handlers.join("\n") + CODEX_HOOKS_END + "\n";
 }
+function installedHookPort(settingsText) {
+  let settings;
+  try {
+    settings = JSON.parse(settingsText);
+  } catch {
+    return null;
+  }
+  const hooks = settings?.hooks;
+  if (!hooks || typeof hooks !== "object") return null;
+  for (const groups of Object.values(hooks)) {
+    for (const group of Array.isArray(groups) ? groups : []) {
+      for (const h of group?.hooks ?? []) {
+        if (typeof h?.command !== "string" || !h.command.includes("errata-managed")) continue;
+        const m = /http:\/\/127\.0\.0\.1:(\d+)\//.exec(h.command);
+        const port = m ? Number(m[1]) : NaN;
+        if (Number.isInteger(port) && port > 0 && port < 65536) return port;
+      }
+    }
+  }
+  return null;
+}
 
 // src/codex-hook-relay.ts
 var CODEX_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata install-hooks codex
@@ -91891,6 +91945,10 @@ function removeProjectStatusLine(settings) {
   }
   return removed;
 }
+function isSameInstall(value, relay) {
+  const command = value["command"].replace(/\\/g, "/").toLowerCase();
+  return command.includes(relay.replace(/\\/g, "/").toLowerCase());
+}
 function userClaudeSettingsPath() {
   const base = process.env["CLAUDE_CONFIG_DIR"] ?? join46(homedir8(), ".claude");
   return join46(base, "settings.json");
@@ -91910,10 +91968,11 @@ function ensureUserStatusLine(opts) {
       return "unreadable";
     }
   }
-  const ownMain = settings["statusLine"] !== void 0 && !isErrataStatusLine(settings["statusLine"]);
-  const ownRows = settings["subagentStatusLine"] !== void 0 && !isErrataStatusLine(settings["subagentStatusLine"]);
-  if (ownMain && ownRows) return "kept-own";
   const relay = join46(opts.relayDir, STATUSLINE_RELAY_FILE);
+  const keep = (value) => value !== void 0 && (!isErrataStatusLine(value) || !isSameInstall(value, relay));
+  const ownMain = keep(settings["statusLine"]);
+  const ownRows = keep(settings["subagentStatusLine"]);
+  if (ownMain && ownRows) return "kept-own";
   mkdirSync10(opts.relayDir, { recursive: true });
   if (!existsSync37(relay) || readFileSync40(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
     writeFileSync28(relay, STATUSLINE_RELAY_SOURCE, "utf8");
@@ -92329,6 +92388,11 @@ function resolveHookPort(explicit) {
       }
     }
   }
+  const settingsPath = join47(ROOT, ".claude", "settings.json");
+  try {
+    if (existsSync38(settingsPath)) return installedHookPort(readFileSync41(settingsPath, "utf8")) ?? 7891;
+  } catch {
+  }
   return 7891;
 }
 async function cmdInit() {

package/package.json

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