@inerrata-corporation/errata 2.0.6-dev.2656 → 2.0.6-dev.2674

package/consolidate-worker.mjs

@@ -16206,6 +16206,10 @@ function rowToEdge(r) {
 }
 var SqliteGraphStore = class {
   db;
+  // Typed edge lookups build their SQL from the number of types asked for, and
+  // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
+  // 225k-node store was statement compilation alone. Keyed by the SQL text.
+  typedEdgeStmts = /* @__PURE__ */ new Map();
   stmts;
   /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
    *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -16710,6 +16714,14 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare(sql).all(params);
     return rows.map(rowToNode);
   }
+  typedEdgeStmt(sql) {
+    let stmt = this.typedEdgeStmts.get(sql);
+    if (!stmt) {
+      stmt = this.db.prepare(sql);
+      this.typedEdgeStmts.set(sql, stmt);
+    }
+    return stmt;
+  }
   outEdges(nodeId, types) {
     if (!types || types.length === 0) {
       const rows2 = this.stmts.outEdges.all(nodeId);
@@ -16720,7 +16732,7 @@ var SqliteGraphStore = class {
     types.forEach((t, i) => {
       params[`t${i}`] = t;
     });
-    const rows = this.db.prepare(
+    const rows = this.typedEdgeStmt(
       `SELECT * FROM edges WHERE from_id = :from_id AND type IN (${placeholders}) AND valid_to IS NULL`
     ).all(params);
     return rows.map(rowToEdge);
@@ -16735,7 +16747,7 @@ var SqliteGraphStore = class {
     types.forEach((t, i) => {
       params[`t${i}`] = t;
     });
-    const rows = this.db.prepare(
+    const rows = this.typedEdgeStmt(
       `SELECT * FROM edges WHERE to_id = :to_id AND type IN (${placeholders}) AND valid_to IS NULL`
     ).all(params);
     return rows.map(rowToEdge);
@@ -16813,6 +16825,15 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
     return rows.map((r) => r.id);
   }
+  labelFingerprint(labels) {
+    if (labels.length === 0) return "0";
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
+                MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
+           FROM nodes WHERE valid_to IS NULL AND label IN (${labels.map(() => "?").join(",")})`
+    ).get(...labels);
+    return `${r.n}:${r.t ?? 0}:${r.s ?? 0}`;
+  }
   /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
    *  Closures matter as much as additions: a node that lost inflow is rank-dirty
    *  while its own row never updated, so removal endpoints must seed the
@@ -18254,10 +18275,16 @@ function internalPackageNames(workspaceRoot) {
   return names;
 }
 var cache = /* @__PURE__ */ new Map();
+var cacheKeys = /* @__PURE__ */ new Map();
 function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   const now = deps.nowMs ?? Date.now();
+  const fileRows = store.labelFingerprint?.(["File"]);
+  const key = fileRows === void 0 ? void 0 : `${fileRows}|${store.countNodesByLabel("Module")}`;
   const cached2 = cache.get(workspaceRoot);
-  if (cached2 && now - cached2.builtAt < INDEX_TTL_MS) return cached2;
+  if (cached2) {
+    const fresh = key !== void 0 ? cacheKeys.get(workspaceRoot) === key : now - cached2.builtAt < INDEX_TTL_MS;
+    if (fresh) return cached2;
+  }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
       return readFileSync(absPath, "utf8").slice(0, HEAD_BYTES);
@@ -18294,6 +18321,8 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const index = { symbols, builtAt: now };
   cache.set(workspaceRoot, index);
+  if (key !== void 0) cacheKeys.set(workspaceRoot, key);
+  else cacheKeys.delete(workspaceRoot);
   return index;
 }
 var PRESERVED_SYMBOLS_CAP = 8;
@@ -19082,7 +19111,16 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     ...profile.repoLocatorAliases ? { aliases: profile.repoLocatorAliases } : {},
     ...profile.aka ? { aka: profile.aka } : {}
   };
-  const fileLexicon = buildFileLexicon(store);
+  const fileLexicon = opts.fileLexicon ?? buildFileLexicon(store);
+  const nodeMemo = /* @__PURE__ */ new Map();
+  const nodeOf = (id) => {
+    let n = nodeMemo.get(id);
+    if (n === void 0) {
+      n = store.getNode(id) ?? opts.sharedStore?.getNode(id) ?? null;
+      nodeMemo.set(id, n);
+    }
+    return n;
+  };
   const shareable = (n) => {
     const preserved = symbolIndex ? preservedSymbolsFor(n.description, symbolIndex) : [];
     const fileRefs = generalizeFileRefs(n.description, fileLexicon, level);
@@ -19207,7 +19245,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   for (const sourceId of anchorSources) {
     const targets = [];
     for (const e of store.outEdges(sourceId, [...ANCHOR_EDGES])) {
-      const t = store.getNode(e.to);
+      const t = nodeOf(e.to);
       if (!t || !ANCHOR_TARGET_LABELS.includes(t.label)) continue;
       if (e.type === "OCCURS_IN" && t.label !== "Language") continue;
       if (e.type === "DEPENDS_ON" && t.label !== "Package") continue;
@@ -19230,7 +19268,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
       }
     }
     const dg = digest(targets.map(({ e, wireId }) => `${e.type}>${wireId}`).sort());
-    const sourceNode = store.getNode(sourceId);
+    const sourceNode = nodeOf(sourceId);
     if (sourceNode?.attrs["anchorsContributedDigest"] === dg) continue;
     anchorDigests[sourceId] = dg;
     const wireFrom = seen.has(sourceId) || !sourceNode ? sourceId : contributedWireId(sourceNode);
@@ -19260,12 +19298,12 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   if (project) {
     const now = Date.now();
     for (const sourceId of anchorSources) {
-      const source = store.getNode(sourceId);
+      const source = nodeOf(sourceId);
       if (!source) continue;
       const wireFrom = seen.has(sourceId) ? sourceId : contributedWireId(source);
       const planned = [];
       for (const e of store.outEdges(sourceId, ["ANCHORED_AT"])) {
-        const target = store.getNode(e.to);
+        const target = nodeOf(e.to);
         if (!target) continue;
         if (!isAnchorLabelKind(target.label)) continue;
         const isFile = target.label === "File";
@@ -19342,7 +19380,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     const outs = [...dedup.values()].map((e) => ({ e, wireTo: semanticEndpoints.get(e.to) })).filter((x) => x.wireTo != null);
     if (outs.length === 0) continue;
     const dg = digest(outs.map(({ e, wireTo }) => `${e.type}>${wireTo}`).sort());
-    const owner = store.getNode(sourceId) ?? opts.sharedStore?.getNode(sourceId);
+    const owner = nodeOf(sourceId);
     const digestSkip = owner?.attrs["semanticEdgesContributedDigest"] === dg;
     if (!digestSkip) semanticEdgeDigests[sourceId] = dg;
     for (const { e, wireTo } of outs) {
@@ -19399,7 +19437,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   const heldOrphans = /* @__PURE__ */ new Set();
   for (const wn of nodes) {
     if (wn.label !== "RootCause" && wn.label !== "Solution") continue;
-    const src = store.getNode(wn.id) ?? opts.sharedStore?.getNode(wn.id);
+    const src = nodeOf(wn.id);
     if (typeof src?.attrs["contributedAtSeq"] === "number") continue;
     if (bindingEndpoints.has(wn.id)) continue;
     heldOrphans.add(wn.id);
@@ -19444,6 +19482,21 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
 }
 
 // src/drain-build.ts
+var LEXICON_SYMBOL_LABELS = ["Function", "Method", "Class", "Interface", "Const", "Comment"];
+function codeGraphKey(store) {
+  const files = store.labelFingerprint?.(["File"]);
+  if (files === void 0) return null;
+  return [files, ...LEXICON_SYMBOL_LABELS.map((l) => store.countNodesByLabel(l))].join("|");
+}
+var lexiconCache = /* @__PURE__ */ new WeakMap();
+function lexiconsFor(store) {
+  const key = codeGraphKey(store);
+  const hit = key !== null ? lexiconCache.get(store) : void 0;
+  if (hit && hit.key === key) return hit;
+  const built = { symbols: buildSymbolLexicon(store), files: buildFileLexicon(store) };
+  if (key !== null) lexiconCache.set(store, { key, ...built });
+  return built;
+}
 function buildDrainContext(store, input) {
   return buildContextIngest(store, input.profile, input.daemonVersion, input.ignorePatterns, {
     ...input.includePackages !== void 0 ? { includePackages: input.includePackages } : {}
@@ -19451,9 +19504,10 @@ function buildDrainContext(store, input) {
 }
 function buildDrainInstances(store, sharedStore, input) {
   let lexicon;
+  let fileLexicon;
   let lexiconError;
   try {
-    lexicon = buildSymbolLexicon(store);
+    ({ symbols: lexicon, files: fileLexicon } = lexiconsFor(store));
   } catch (err) {
     lexiconError = err instanceof Error ? err.message : String(err);
   }
@@ -19466,6 +19520,7 @@ function buildDrainInstances(store, sharedStore, input) {
       composition = c;
     },
     ...lexicon ? { lexicon } : {},
+    ...fileLexicon ? { fileLexicon } : {},
     ...input.project ? { project: input.project } : {}
   });
   return {

package/errata.mjs

@@ -17566,6 +17566,10 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
 `;
     SqliteGraphStore = class {
       db;
+      // Typed edge lookups build their SQL from the number of types asked for, and
+      // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
+      // 225k-node store was statement compilation alone. Keyed by the SQL text.
+      typedEdgeStmts = /* @__PURE__ */ new Map();
       stmts;
       /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
        *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -18070,6 +18074,14 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
         const rows = this.db.prepare(sql).all(params);
         return rows.map(rowToNode);
       }
+      typedEdgeStmt(sql) {
+        let stmt = this.typedEdgeStmts.get(sql);
+        if (!stmt) {
+          stmt = this.db.prepare(sql);
+          this.typedEdgeStmts.set(sql, stmt);
+        }
+        return stmt;
+      }
       outEdges(nodeId, types) {
         if (!types || types.length === 0) {
           const rows2 = this.stmts.outEdges.all(nodeId);
@@ -18080,7 +18092,7 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
         types.forEach((t, i2) => {
           params[`t${i2}`] = t;
         });
-        const rows = this.db.prepare(
+        const rows = this.typedEdgeStmt(
           `SELECT * FROM edges WHERE from_id = :from_id AND type IN (${placeholders}) AND valid_to IS NULL`
         ).all(params);
         return rows.map(rowToEdge);
@@ -18095,7 +18107,7 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
         types.forEach((t, i2) => {
           params[`t${i2}`] = t;
         });
-        const rows = this.db.prepare(
+        const rows = this.typedEdgeStmt(
           `SELECT * FROM edges WHERE to_id = :to_id AND type IN (${placeholders}) AND valid_to IS NULL`
         ).all(params);
         return rows.map(rowToEdge);
@@ -18173,6 +18185,15 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
         const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
         return rows.map((r) => r.id);
       }
+      labelFingerprint(labels) {
+        if (labels.length === 0) return "0";
+        const r = this.db.prepare(
+          `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
+                MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
+           FROM nodes WHERE valid_to IS NULL AND label IN (${labels.map(() => "?").join(",")})`
+        ).get(...labels);
+        return `${r.n}:${r.t ?? 0}:${r.s ?? 0}`;
+      }
       /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
        *  Closures matter as much as additions: a node that lost inflow is rank-dirty
        *  while its own row never updated, so removal endpoints must seed the
@@ -71163,7 +71184,7 @@ var init_report_render = __esm({
 init_src6();
 import { closeSync as closeSync2, existsSync as existsSync34, openSync as openSync2, readFileSync as readFileSync34, renameSync as renameSync4, statSync as statSync8 } from "node:fs";
 import { join as join39, resolve as pathResolve2 } from "node:path";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 
 // src/daemon.ts
 import { existsSync as existsSync26, writeFileSync as writeFileSync22 } from "node:fs";
@@ -78515,7 +78536,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2656" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2674" : "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;
@@ -81236,10 +81257,16 @@ function internalPackageNames(workspaceRoot) {
   return names;
 }
 var cache = /* @__PURE__ */ new Map();
+var cacheKeys = /* @__PURE__ */ new Map();
 function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   const now = deps.nowMs ?? Date.now();
+  const fileRows = store.labelFingerprint?.(["File"]);
+  const key = fileRows === void 0 ? void 0 : `${fileRows}|${store.countNodesByLabel("Module")}`;
   const cached2 = cache.get(workspaceRoot);
-  if (cached2 && now - cached2.builtAt < INDEX_TTL_MS) return cached2;
+  if (cached2) {
+    const fresh = key !== void 0 ? cacheKeys.get(workspaceRoot) === key : now - cached2.builtAt < INDEX_TTL_MS;
+    if (fresh) return cached2;
+  }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
       return readFileSync28(absPath, "utf8").slice(0, HEAD_BYTES);
@@ -81276,6 +81303,8 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const index = { symbols, builtAt: now };
   cache.set(workspaceRoot, index);
+  if (key !== void 0) cacheKeys.set(workspaceRoot, key);
+  else cacheKeys.delete(workspaceRoot);
   return index;
 }
 var PRESERVED_SYMBOLS_CAP = 8;
@@ -81410,7 +81439,16 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     ...profile.repoLocatorAliases ? { aliases: profile.repoLocatorAliases } : {},
     ...profile.aka ? { aka: profile.aka } : {}
   };
-  const fileLexicon = buildFileLexicon(store);
+  const fileLexicon = opts.fileLexicon ?? buildFileLexicon(store);
+  const nodeMemo = /* @__PURE__ */ new Map();
+  const nodeOf = (id) => {
+    let n = nodeMemo.get(id);
+    if (n === void 0) {
+      n = store.getNode(id) ?? opts.sharedStore?.getNode(id) ?? null;
+      nodeMemo.set(id, n);
+    }
+    return n;
+  };
   const shareable = (n) => {
     const preserved = symbolIndex ? preservedSymbolsFor(n.description, symbolIndex) : [];
     const fileRefs = generalizeFileRefs(n.description, fileLexicon, level);
@@ -81535,7 +81573,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   for (const sourceId of anchorSources) {
     const targets = [];
     for (const e of store.outEdges(sourceId, [...ANCHOR_EDGES])) {
-      const t = store.getNode(e.to);
+      const t = nodeOf(e.to);
       if (!t || !ANCHOR_TARGET_LABELS.includes(t.label)) continue;
       if (e.type === "OCCURS_IN" && t.label !== "Language") continue;
       if (e.type === "DEPENDS_ON" && t.label !== "Package") continue;
@@ -81558,7 +81596,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
       }
     }
     const dg = digest(targets.map(({ e, wireId }) => `${e.type}>${wireId}`).sort());
-    const sourceNode = store.getNode(sourceId);
+    const sourceNode = nodeOf(sourceId);
     if (sourceNode?.attrs["anchorsContributedDigest"] === dg) continue;
     anchorDigests[sourceId] = dg;
     const wireFrom = seen.has(sourceId) || !sourceNode ? sourceId : contributedWireId(sourceNode);
@@ -81588,12 +81626,12 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   if (project) {
     const now = Date.now();
     for (const sourceId of anchorSources) {
-      const source = store.getNode(sourceId);
+      const source = nodeOf(sourceId);
       if (!source) continue;
       const wireFrom = seen.has(sourceId) ? sourceId : contributedWireId(source);
       const planned = [];
       for (const e of store.outEdges(sourceId, ["ANCHORED_AT"])) {
-        const target = store.getNode(e.to);
+        const target = nodeOf(e.to);
         if (!target) continue;
         if (!isAnchorLabelKind(target.label)) continue;
         const isFile = target.label === "File";
@@ -81670,7 +81708,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     const outs = [...dedup.values()].map((e) => ({ e, wireTo: semanticEndpoints.get(e.to) })).filter((x) => x.wireTo != null);
     if (outs.length === 0) continue;
     const dg = digest(outs.map(({ e, wireTo }) => `${e.type}>${wireTo}`).sort());
-    const owner = store.getNode(sourceId) ?? opts.sharedStore?.getNode(sourceId);
+    const owner = nodeOf(sourceId);
     const digestSkip = owner?.attrs["semanticEdgesContributedDigest"] === dg;
     if (!digestSkip) semanticEdgeDigests[sourceId] = dg;
     for (const { e, wireTo } of outs) {
@@ -81727,7 +81765,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   const heldOrphans = /* @__PURE__ */ new Set();
   for (const wn of nodes) {
     if (wn.label !== "RootCause" && wn.label !== "Solution") continue;
-    const src = store.getNode(wn.id) ?? opts.sharedStore?.getNode(wn.id);
+    const src = nodeOf(wn.id);
     if (typeof src?.attrs["contributedAtSeq"] === "number") continue;
     if (bindingEndpoints.has(wn.id)) continue;
     heldOrphans.add(wn.id);
@@ -81811,8 +81849,58 @@ function buildCausalEdgeBackfill(store, profile, daemonVersion) {
   return { ...base, payloadDigest: digest(base) };
 }
 
+// src/live-sync.ts
+var LIVE_SYNC_DEFAULTS = {
+  enabled: true,
+  debounceMs: 1e4,
+  maxWaitMs: 6e4
+};
+var BACKOFF_BASE_MS = 5 * 6e4;
+var BACKOFF_MAX_MS = 60 * 6e4;
+function positiveMs(raw2, fallback) {
+  if (raw2 === void 0 || raw2.trim() === "") return fallback;
+  const n = Number(raw2);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function liveSyncConfig(env2 = process.env) {
+  const flag = (env2["ERRATA_LIVE_SYNC"] ?? "").trim().toLowerCase();
+  const debounceMs = positiveMs(env2["ERRATA_LIVE_SYNC_DEBOUNCE_MS"], LIVE_SYNC_DEFAULTS.debounceMs);
+  return {
+    enabled: !["0", "false", "off", "no"].includes(flag),
+    debounceMs,
+    // A ceiling below the debounce would make the debounce meaningless.
+    maxWaitMs: Math.max(debounceMs, positiveMs(env2["ERRATA_LIVE_SYNC_MAX_WAIT_MS"], LIVE_SYNC_DEFAULTS.maxWaitMs))
+  };
+}
+function liveSyncEnabled(env2 = process.env) {
+  return liveSyncConfig(env2).enabled;
+}
+function liveShipDelay(now, dirtySince, cfg) {
+  const ceiling = dirtySince + cfg.maxWaitMs - now;
+  return Math.max(0, Math.min(cfg.debounceMs, ceiling));
+}
+function liveBackoffMs(failures) {
+  if (failures <= 0) return 0;
+  return Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** (failures - 1));
+}
+
 // src/drain-build.ts
 init_generalize_graph();
+var LEXICON_SYMBOL_LABELS = ["Function", "Method", "Class", "Interface", "Const", "Comment"];
+function codeGraphKey(store) {
+  const files = store.labelFingerprint?.(["File"]);
+  if (files === void 0) return null;
+  return [files, ...LEXICON_SYMBOL_LABELS.map((l) => store.countNodesByLabel(l))].join("|");
+}
+var lexiconCache = /* @__PURE__ */ new WeakMap();
+function lexiconsFor(store) {
+  const key = codeGraphKey(store);
+  const hit = key !== null ? lexiconCache.get(store) : void 0;
+  if (hit && hit.key === key) return hit;
+  const built = { symbols: buildSymbolLexicon(store), files: buildFileLexicon(store) };
+  if (key !== null) lexiconCache.set(store, { key, ...built });
+  return built;
+}
 function buildDrainContext(store, input) {
   return buildContextIngest(store, input.profile, input.daemonVersion, input.ignorePatterns, {
     ...input.includePackages !== void 0 ? { includePackages: input.includePackages } : {}
@@ -81820,9 +81908,10 @@ function buildDrainContext(store, input) {
 }
 function buildDrainInstances(store, sharedStore, input) {
   let lexicon;
+  let fileLexicon;
   let lexiconError;
   try {
-    lexicon = buildSymbolLexicon(store);
+    ({ symbols: lexicon, files: fileLexicon } = lexiconsFor(store));
   } catch (err2) {
     lexiconError = err2 instanceof Error ? err2.message : String(err2);
   }
@@ -81835,6 +81924,7 @@ function buildDrainInstances(store, sharedStore, input) {
       composition = c;
     },
     ...lexicon ? { lexicon } : {},
+    ...fileLexicon ? { fileLexicon } : {},
     ...input.project ? { project: input.project } : {}
   });
   return {
@@ -82620,6 +82710,17 @@ function isGeneratedPath(path2) {
 function isReleaseSubject(subject) {
   return RELEASE_SUBJECT_RE.test(subject.trim());
 }
+var FORGE_MARK_RES = [/^See merge request \S+!\d+$/i, /^Merge pull request #\d+ from \S+$/i];
+var TRAILER_RES = [
+  /^(Closes|Fixes|Resolves|Related to|Part of)\b.*$/i,
+  /^(Co-Authored-By|Signed-off-by|Reviewed-by|Approved-by):/i
+];
+function isForgeTrailerBody(body2) {
+  const lines = body2.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  if (!lines.some((l) => FORGE_MARK_RES.some((re) => re.test(l)))) return false;
+  const own = lines.filter((l) => !FORGE_MARK_RES.some((re) => re.test(l)) && !TRAILER_RES.some((re) => re.test(l)));
+  return own.length <= 1;
+}
 function classifySkip(subject, files, tags) {
   if (files.length > 0 && files.every((f) => f.binary || isLockfilePath(f.path) || isGeneratedPath(f.path))) {
     return "lockfile-only";
@@ -82628,6 +82729,7 @@ function classifySkip(subject, files, tags) {
   return void 0;
 }
 var GIT_OPTS = ["-c", "core.quotepath=false", "-c", "color.ui=never", "--no-pager"];
+var MERGE_SIDE_CONCURRENCY = 6;
 var META_FMT = ["%H", "%P", "%aI", "%s", "%b"].join("%x00") + "%x00";
 function parseMeta(head2) {
   const [sha2, parents, authorDate, subject, body2] = head2.split("\0");
@@ -82666,6 +82768,38 @@ async function readCommit(root, sha2) {
   const rest2 = parts2.slice(5).join("\0");
   return { ...parseMeta(head2), files: parseNumstat(rest2) };
 }
+async function readCommitsBulk(root, branch, since) {
+  const out2 = await git(root, [
+    ...GIT_OPTS,
+    "log",
+    "--numstat",
+    "-M",
+    "--diff-merges=first-parent",
+    `--format=%x1e${META_FMT}`,
+    ...since ? [`^${since}`] : [],
+    branch
+  ]);
+  const map2 = /* @__PURE__ */ new Map();
+  for (const rec of out2.split("")) {
+    if (!rec) continue;
+    const parts2 = rec.split("\0");
+    const meta3 = parseMeta(parts2.slice(0, 5).join("\0"));
+    if (meta3.sha) map2.set(meta3.sha, { ...meta3, files: parseNumstat(parts2.slice(5).join("\0")) });
+  }
+  return map2;
+}
+async function mapBounded(items, limit, fn) {
+  const out2 = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i2 = next++;
+      out2[i2] = await fn(items[i2]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out2;
+}
 async function firstParentLine(root, branch) {
   const out2 = await git(root, [...GIT_OPTS, "rev-list", "--first-parent", "--reverse", "--parents", branch]);
   return out2.split(/\r?\n/).filter((l) => l.trim().length > 0).map((l) => {
@@ -82705,11 +82839,18 @@ async function enumerateUnits(root, opts = {}) {
   }
   const tags = await tagsByCommit(root);
   const tagsOf = (sha2) => tags.get(sha2) ?? [];
+  if (start2 >= line.length) return [];
+  const commits = await readCommitsBulk(root, branch, start2 > 0 ? line[start2 - 1].sha : null);
+  const commit = async (sha2) => commits.get(sha2) ?? await readCommit(root, sha2);
+  const merges = line.slice(start2).filter((c) => c.parents.length >= 2);
+  const sides = /* @__PURE__ */ new Map();
+  const sideLists = await mapBounded(merges, MERGE_SIDE_CONCURRENCY, (m) => mergeSide(root, m.parents[0], m.parents[1]));
+  merges.forEach((m, i2) => sides.set(m.sha, sideLists[i2]));
   const units = [];
   for (let index = start2; index < line.length; index++) {
     const { sha: sha2, parents } = line[index];
     if (parents.length < 2) {
-      const c = await readCommit(root, sha2);
+      const c = await commit(sha2);
       const skip = classifySkip(c.subject, c.files, tagsOf(sha2));
       units.push({
         index,
@@ -82725,11 +82866,11 @@ async function enumerateUnits(root, opts = {}) {
       });
       continue;
     }
-    const side = await mergeSide(root, parents[0], parents[1]);
+    const side = sides.get(sha2) ?? await mergeSide(root, parents[0], parents[1]);
     const group = [];
     for (const s of side) {
       if (s.parents.length >= 2) continue;
-      const c = await readCommit(root, s.sha);
+      const c = await commit(s.sha);
       const skip = classifySkip(c.subject, c.files, tagsOf(s.sha));
       group.push({
         index,
@@ -82745,8 +82886,9 @@ async function enumerateUnits(root, opts = {}) {
         groupSha: sha2
       });
     }
-    const merge2 = await readCommit(root, sha2);
-    if (merge2.body.length > 0) {
+    const merge2 = await commit(sha2);
+    const hasMembers = group.some((g) => !g.skip);
+    if (merge2.body.length > 0 && !(hasMembers && isForgeTrailerBody(merge2.body))) {
       const skip = classifySkip(merge2.subject, merge2.files, tagsOf(sha2));
       group.push({
         index,
@@ -83978,10 +84120,111 @@ async function buildUnitBundle(root, unit, opts = {}) {
   };
 }
 
+// src/git-batch.ts
+import { spawn as spawn3 } from "node:child_process";
+var GitBlobReader = class {
+  constructor(root, maxCached = 4096) {
+    this.root = root;
+    this.maxCached = maxCached;
+  }
+  proc = null;
+  buf = Buffer.alloc(0);
+  queue = [];
+  cache = /* @__PURE__ */ new Map();
+  failed = null;
+  start() {
+    if (this.proc) return this.proc;
+    const proc = spawn3("git", ["-C", this.root, "cat-file", "--batch"], { windowsHide: true });
+    proc.stdout.on("data", (chunk) => {
+      this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+      this.drain();
+    });
+    const fail = (err2) => {
+      this.failed = err2;
+      this.proc = null;
+      for (const p of this.queue.splice(0)) p.reject(err2);
+    };
+    proc.on("error", fail);
+    proc.stdin.on("error", fail);
+    proc.on("exit", (code) => {
+      if (this.queue.length > 0) fail(new Error(`git cat-file --batch exited (${code}) with ${this.queue.length} reads pending`));
+      this.proc = null;
+    });
+    this.proc = proc;
+    return proc;
+  }
+  drain() {
+    for (; ; ) {
+      const nl = this.buf.indexOf(10);
+      if (nl < 0 || this.queue.length === 0) return;
+      const header = this.buf.subarray(0, nl).toString("utf8");
+      if (header.endsWith(" missing") || header.endsWith(" ambiguous")) {
+        this.buf = this.buf.subarray(nl + 1);
+        this.queue.shift().resolve(null);
+        continue;
+      }
+      const size = Number(header.slice(header.lastIndexOf(" ") + 1));
+      if (!Number.isFinite(size)) {
+        const err2 = new Error(`git cat-file --batch: unexpected header ${JSON.stringify(header.slice(0, 120))}`);
+        this.queue.shift().reject(err2);
+        this.buf = this.buf.subarray(nl + 1);
+        continue;
+      }
+      if (this.buf.length < nl + 1 + size + 1) return;
+      const body2 = this.buf.subarray(nl + 1, nl + 1 + size).toString("utf8");
+      this.buf = this.buf.subarray(nl + 1 + size + 1);
+      const oid = header.slice(0, header.indexOf(" "));
+      this.remember(oid, body2);
+      this.queue.shift().resolve(body2);
+    }
+  }
+  remember(oid, text) {
+    if (this.cache.size >= this.maxCached) {
+      const first = this.cache.keys().next().value;
+      if (first !== void 0) this.cache.delete(first);
+    }
+    this.cache.set(oid, text);
+  }
+  /** Read one object by blob id (served from cache when seen) or `<rev>:<path>`. */
+  read(spec) {
+    const hit = this.cache.get(spec);
+    if (hit !== void 0) return Promise.resolve(hit);
+    if (this.failed) return Promise.reject(this.failed);
+    if (/[\r\n]/.test(spec)) return Promise.resolve(null);
+    const proc = this.start();
+    return new Promise((resolve7, reject) => {
+      this.queue.push({ resolve: resolve7, reject });
+      proc.stdin.write(`${spec}
+`);
+    });
+  }
+  /**
+   * End the process and wait for it to exit: on Windows a live cat-file keeps
+   * the repo's pack files open, so a caller that removes or moves the checkout
+   * right after the walk (EPERM) must not race it. Bounded, never throws.
+   */
+  close(timeoutMs = 5e3) {
+    const proc = this.proc;
+    this.proc = null;
+    if (!proc || proc.exitCode !== null) return Promise.resolve();
+    return new Promise((resolve7) => {
+      const timer = setTimeout(() => {
+        proc.kill();
+        resolve7();
+      }, timeoutMs);
+      proc.once("exit", () => {
+        clearTimeout(timer);
+        resolve7();
+      });
+      proc.stdin.end();
+    });
+  }
+};
+
 // src/project-history.ts
 init_profile2();
 var execFileAsync = promisify(execFile3);
-var HISTORY_EXTRACTOR_VERSION = "history-1";
+var HISTORY_EXTRACTOR_VERSION = "history-2";
 var LEASE_POLL_MS = 2e4;
 var RECOVERY_DEADLINE_MS = 15 * 6e4;
 var MAX_ANCHORS_PER_TOKEN = 20;
@@ -83997,27 +84240,38 @@ function readIgnoreLines(root, profile) {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
-async function spineForUnit(git3, root, unit) {
-  const listing = await git3(root, ["ls-tree", "-r", "--name-only", unit.sha]);
-  const manifestPaths2 = listing.split("\n").map((l) => l.trim()).filter((p) => p && isManifestPath(p));
-  if (manifestPaths2.length === 0) return void 0;
-  const texts = /* @__PURE__ */ new Map();
-  for (const p of manifestPaths2) {
+function readBlobViaGit(git3, root) {
+  return async (spec) => {
     try {
-      texts.set(p, await git3(root, ["show", `${unit.sha}:${p}`]));
+      return await git3(root, ["show", spec]);
     } catch {
+      return null;
     }
+  };
+}
+function manifestBlobs(listing) {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const line of listing.split("\n")) {
+    const tab = line.indexOf("	");
+    if (tab < 0) continue;
+    const path2 = line.slice(tab + 1).trim();
+    const [, type, oid] = line.slice(0, tab).split(" ");
+    if (type === "blob" && oid && path2 && isManifestPath(path2)) out2.set(path2, oid);
   }
+  return out2;
+}
+async function spineForUnit(git3, root, unit, readBlob) {
+  const blobs = manifestBlobs(await git3(root, ["ls-tree", "-r", unit.sha]));
+  if (blobs.size === 0) return void 0;
+  const texts = /* @__PURE__ */ new Map();
+  const read2 = await Promise.all([...blobs].map(async ([p, oid]) => [p, await readBlob(oid).catch(() => null)]));
+  for (const [p, text] of read2) if (text !== null) texts.set(p, text);
   const spine = buildSpine(unit.sha, [...texts.keys()], (p) => texts.get(p) ?? "");
   const parentTexts = /* @__PURE__ */ new Map();
   const readParent = (p) => parentTexts.get(p) ?? null;
   for (const f of unit.files) {
     if (!isManifestPath(f.path) || parentTexts.has(f.path)) continue;
-    try {
-      parentTexts.set(f.path, await git3(root, ["show", `${unit.sha}^:${f.path}`]));
-    } catch {
-      parentTexts.set(f.path, null);
-    }
+    parentTexts.set(f.path, await readBlob(`${unit.sha}^:${f.path}`).catch(() => null));
   }
   const rings = depsForUnit(spine, unit.files.map((f) => f.path), readParent);
   const wire = (d) => ({ ecosystem: d.ecosystem, name: d.name, version: d.version, kind: d.kind, manifest: d.manifest });
@@ -84060,16 +84314,36 @@ function stage(profile, patch, now) {
       headSha: patch.headSha !== void 0 ? patch.headSha : prev?.headSha ?? null,
       startedAt: prev?.startedAt ?? at,
       updatedAt: at,
-      ...patch.lastError !== void 0 ? { lastError: patch.lastError } : prev?.lastError ? { lastError: prev.lastError } : {},
+      // `lastError: undefined` in the patch CLEARS it (a resumed walk must not
+      // keep showing the error it recovered from); an absent key keeps it.
+      ..."lastError" in patch ? patch.lastError ? { lastError: patch.lastError } : {} : prev?.lastError ? { lastError: prev.lastError } : {},
       ...patch.counts ? { counts: patch.counts } : prev?.counts ? { counts: prev.counts } : {}
     }
   };
 }
+function unitTiming(postStarted, prepMs, receipt) {
+  const s = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+  const parts2 = [`local ${s(prepMs)}`];
+  const g = receipt.gate;
+  if (g) parts2.push(g.pRoutine === null ? `jev ${g.error ?? "n/a"}` : `jev ${s(g.ms)} p=${g.pRoutine}${g.skipped ? " skipped" : ""}`);
+  if (receipt.timing?.modelMs !== void 0) parts2.push(`model ${s(receipt.timing.modelMs)}`);
+  if (receipt.timing?.ingestMs !== void 0) parts2.push(`ingest ${s(receipt.timing.ingestMs)}`);
+  return ` in ${s(Date.now() - postStarted + prepMs)} (${parts2.join(", ")})`;
+}
 function addCounts(a, b) {
   const sum = (k) => (a[k] ?? 0) + (b[k] ?? 0);
   return { commitsWalked: sum("commitsWalked"), changesExtracted: sum("changesExtracted"), pairs: sum("pairs"), claims: sum("claims"), anchors: sum("anchors"), packages: sum("packages") };
 }
 async function runHistoryWalk(root, input, client, opts = {}) {
+  const reader = opts.git ? null : new GitBlobReader(root);
+  const readBlob = reader ? (spec) => reader.read(spec) : readBlobViaGit(opts.git ?? defaultGit, root);
+  try {
+    return await walk10(root, input, client, opts, readBlob);
+  } finally {
+    await reader?.close();
+  }
+}
+async function walk10(root, input, client, opts, readBlob) {
   const log = opts.log ?? ((line) => console.warn(line));
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
@@ -84124,6 +84398,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       log(`[errata] history ${label} skipped (${u.skip})`);
       continue;
     }
+    const prepStarted = Date.now();
     const bundle = await buildUnitBundle(root, u, {
       ignorePatterns: ignoreLines,
       narrative: narrative(u, u.isMerge ? group : void 0)
@@ -84145,7 +84420,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       ...opts.frame ? { frame: opts.frame } : {},
       ...dryRun ? { dryRun: true } : {}
     };
-    const spine = await spineForUnit(git3, root, u);
+    const spine = await spineForUnit(git3, root, u, readBlob);
     if (spine) body2.spine = spine;
     const anchors = anchorsFor(bundle.pathTokens, ignoreLines, projectId, opts.anchors);
     if (anchors) {
@@ -84161,6 +84436,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       await reportHistoryStage(client, profile, log);
       return { profile, processed, state: "refused" };
     }
+    const prepMs = Date.now() - prepStarted;
     const started2 = Date.now();
     let outcome = null;
     let attempt = 0;
@@ -84206,7 +84482,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
         }
         const packages = new Set(outcome.result.nodes.filter((n) => n.decision !== "rejected" && n.canonicalId.startsWith("pkg:")).map((n) => n.canonicalId)).size;
         counts = addCounts(counts, { commitsWalked: 1, changesExtracted: 1, pairs: outcome.receipt.keptPairs, claims: outcome.receipt.claims, anchors: outcome.receipt.anchors, packages });
-        log(`[errata] history ${label}: ${outcome.result.nodes.length} nodes, ${outcome.result.edges.length} edges (${outcome.receipt.keptPairs} pairs, ${outcome.receipt.claims} claims)`);
+        log(`[errata] history ${label}: ${outcome.result.nodes.length} nodes, ${outcome.result.edges.length} edges (${outcome.receipt.keptPairs} pairs, ${outcome.receipt.claims} claims)${unitTiming(started2, prepMs, outcome.receipt)}`);
         break;
       }
       case "replayed": {
@@ -84217,7 +84493,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       case "empty":
       case "dry-run":
         counts = addCounts(counts, { commitsWalked: 1, changesExtracted: outcome.status === "dry-run" ? 1 : 0, pairs: outcome.receipt.keptPairs, claims: outcome.receipt.claims });
-        log(`[errata] history ${label}: ${outcome.status} (${outcome.receipt.keptPairs} pairs, dropped ${outcome.receipt.droppedByEvidence} by evidence, ${outcome.receipt.droppedByAnchor} by anchor)`);
+        log(`[errata] history ${label}: ${outcome.status} (${outcome.receipt.keptPairs} pairs, dropped ${outcome.receipt.droppedByEvidence} by evidence, ${outcome.receipt.droppedByAnchor} by anchor)${unitTiming(started2, prepMs, outcome.receipt)}`);
         break;
       case "refused":
         profile = stage(profile, { state: "refused", lastError: `unit ${label} refused: ${outcome.reason}` }, now);
@@ -84299,12 +84575,12 @@ function applyStopRequest(profile, now = () => /* @__PURE__ */ new Date()) {
     }
   };
 }
-async function startHistoryStage(root, input, client, walk10 = {}) {
+async function startHistoryStage(root, input, client, walk11 = {}) {
   let profile = input;
   if (!profile.projectId) return { started: false, reason: "no-project", profile };
   const response = await reportHistoryStage(client, profile);
-  if (response?.consents && walk10.applyConsents) {
-    profile = walk10.applyConsents(profile, response.consents);
+  if (response?.consents && walk11.applyConsents) {
+    profile = walk11.applyConsents(profile, response.consents);
   }
   const consents = historyConsents(profile);
   if (response?.stopRequested && profile.historyStage && profile.historyStage.state !== "refused") {
@@ -84313,7 +84589,7 @@ async function startHistoryStage(root, input, client, walk10 = {}) {
     return { started: false, reason: "stopped", profile: stopped };
   }
   if (!consents.mineHistory) return { started: false, reason: "consent-pending", profile };
-  const outcome = await runHistoryWalk(root, profile, client, walk10);
+  const outcome = await runHistoryWalk(root, profile, client, walk11);
   return { started: true, profile: outcome.profile };
 }
 
@@ -85215,6 +85491,8 @@ async function startMultiDaemon(opts = {}) {
   let serverPending = null;
   const boundaryListeners = [];
   let boundaryFlushing = false;
+  let pushRequested = false;
+  let shippedFingerprint = "";
   let settleRunning = false;
   let boundaryFlushStartedAt = 0;
   let boundaryFlushStage = "";
@@ -85284,6 +85562,36 @@ async function startMultiDaemon(opts = {}) {
     boundaryFlushStage = "";
     endFlushPass?.();
     endFlushPass = null;
+    if (pushRequested) {
+      pushRequested = false;
+      setImmediate(() => {
+        void daemon.liveShip().catch(() => {
+        });
+      });
+    }
+  };
+  const instanceFingerprint = () => {
+    const cfg2 = loadConfig();
+    const parts2 = [];
+    for (const r of records) {
+      if (!effectiveConsent(cfg2, r.engine.profile).sync) continue;
+      parts2.push(`${r.id}=${r.engine.store.labelFingerprint?.(INSTANCE_LABELS) ?? `?${Date.now()}`}`);
+    }
+    if (parts2.length === 0) return "";
+    parts2.push(`shared=${sharedStore.labelFingerprint?.(["RootCause"]) ?? `?${Date.now()}`}`);
+    return parts2.join("|");
+  };
+  const runSettle = async () => {
+    if (settleRunning) return;
+    settleRunning = true;
+    try {
+      for (const r of records) {
+        const donePass = markPass(`settle:${r.engine.profile.name}`);
+        await r.engine.embedSettled().finally(donePass);
+      }
+    } finally {
+      settleRunning = false;
+    }
   };
   const fireBoundary = () => {
     for (const l of boundaryListeners) {
@@ -86565,22 +86873,17 @@ async function startMultiDaemon(opts = {}) {
       return { written, pruned: pruned2 };
     },
     async sessionBoundaryFlush() {
-      if (!settleRunning) {
-        settleRunning = true;
-        try {
-          for (const r of records) {
-            const donePass = markPass(`settle:${r.engine.profile.name}`);
-            await r.engine.embedSettled().finally(donePass);
-          }
-        } finally {
-          settleRunning = false;
-        }
+      await runSettle();
+      if (boundaryFlushing) {
+        pushRequested = true;
+        return { uploaded: 0, written: 0, pruned: 0, skipped: "in-flight" };
       }
-      if (boundaryFlushing) return { uploaded: 0, written: 0, pruned: 0, skipped: "in-flight" };
       beginFlush("instances");
       try {
         flushStage("instances");
+        const startedFrom = instanceFingerprint();
         const inst = await daemon.syncInstancesPublic();
+        shippedFingerprint = startedFrom;
         flushStage("skills");
         const skills = await daemon.syncSkillsAll();
         return {
@@ -86593,6 +86896,36 @@ async function startMultiDaemon(opts = {}) {
         endFlush();
       }
     },
+    pendingLiveFingerprint() {
+      const fp = instanceFingerprint();
+      return fp && fp !== shippedFingerprint ? fp : null;
+    },
+    async liveShip() {
+      if (!liveSyncEnabled()) return { uploaded: 0, skipped: "disabled" };
+      if (daemon.pendingLiveFingerprint() === null) return { uploaded: 0, skipped: "unchanged" };
+      if (boundaryFlushing) {
+        pushRequested = true;
+        return { uploaded: 0, skipped: "in-flight" };
+      }
+      await runSettle();
+      if (boundaryFlushing) {
+        pushRequested = true;
+        return { uploaded: 0, skipped: "in-flight" };
+      }
+      beginFlush("live");
+      try {
+        const startedFrom = instanceFingerprint();
+        const inst = await daemon.syncInstancesPublic();
+        shippedFingerprint = startedFrom;
+        return {
+          uploaded: inst.uploaded,
+          ...inst.skipped ? { skipped: inst.skipped } : {},
+          ...inst.errors ? { errors: inst.errors } : {}
+        };
+      } finally {
+        endFlush();
+      }
+    },
     onSessionBoundary(cb) {
       boundaryListeners.push(cb);
     },
@@ -86953,9 +87286,9 @@ function deriveAuthBase(verificationUri) {
 }
 function openInBrowser(url2) {
   try {
-    void import("node:child_process").then(({ spawn: spawn4 }) => {
+    void import("node:child_process").then(({ spawn: spawn5 }) => {
       const [cmd2, args2] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url2]] : process.platform === "darwin" ? ["open", [url2]] : ["xdg-open", [url2]];
-      spawn4(cmd2, args2, { detached: true, stdio: "ignore" }).unref();
+      spawn5(cmd2, args2, { detached: true, stdio: "ignore" }).unref();
     });
   } catch {
   }
@@ -89598,7 +89931,7 @@ function spawnDaemonDetached(options = {}) {
     out2 = openSync2(logPath, "a");
   } catch {
   }
-  spawn3(cmd2, args2, {
+  spawn4(cmd2, args2, {
     detached: true,
     stdio: ["ignore", out2, out2],
     windowsHide: true,
@@ -90059,8 +90392,53 @@ async function cmdDash(args2) {
     void flushed.finally(() => triggerConsolidation(force));
   };
   handle2.onSessionBoundary(() => settleThenConsolidate("session-end", true));
+  const liveCfg = liveSyncConfig();
+  let liveTimer = null;
+  let liveDirtySince = 0;
+  let liveSeenFingerprint = "";
+  let liveFailures = 0;
+  let liveBackoffUntil = 0;
+  const fireLiveShip = () => {
+    liveTimer = null;
+    void handle2.liveShip().then((r) => {
+      if (r.skipped === "in-flight") return;
+      liveDirtySince = 0;
+      if (r.errors && r.errors.length > 0) {
+        liveFailures++;
+        const pause = liveBackoffMs(liveFailures);
+        liveBackoffUntil = Date.now() + pause;
+        console.warn(
+          `[live] push had ${r.errors.length} error(s); pausing the live push ${Math.round(pause / 6e4)}m (quiescence / session-end still flush)`
+        );
+        return;
+      }
+      liveFailures = 0;
+      if (r.uploaded > 0) console.log(`[live] uploaded ${r.uploaded} node(s)/edge(s)`);
+    }).catch(() => {
+    });
+  };
+  const probeLivePush = () => {
+    if (!liveCfg.enabled || Date.now() < liveBackoffUntil) return;
+    let fp;
+    try {
+      fp = handle2.pendingLiveFingerprint();
+    } catch {
+      return;
+    }
+    if (fp === null) {
+      liveSeenFingerprint = "";
+      return;
+    }
+    if (fp === liveSeenFingerprint) return;
+    liveSeenFingerprint = fp;
+    const now = Date.now();
+    if (!liveDirtySince) liveDirtySince = now;
+    if (liveTimer) clearTimeout(liveTimer);
+    liveTimer = setTimeout(fireLiveShip, liveShipDelay(now, liveDirtySince, liveCfg));
+  };
   let ticking = false;
   const interval = setInterval(() => {
+    probeLivePush();
     if (ticking) return;
     ticking = true;
     void handle2.tickAll().then((m) => {
@@ -90301,6 +90679,7 @@ shutting down\u2026 (${signal})`);
     clearInterval(interval);
     clearInterval(nightlyInterval);
     if (quiesceTimer) clearTimeout(quiesceTimer);
+    if (liveTimer) clearTimeout(liveTimer);
     await handle2.stop();
     process.exit(0);
   };

package/package.json

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

package/pass-worker.mjs

@@ -24588,6 +24588,10 @@ function rowToEdge(r) {
 }
 var SqliteGraphStore = class {
   db;
+  // Typed edge lookups build their SQL from the number of types asked for, and
+  // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
+  // 225k-node store was statement compilation alone. Keyed by the SQL text.
+  typedEdgeStmts = /* @__PURE__ */ new Map();
   stmts;
   /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
    *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -25092,6 +25096,14 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare(sql).all(params);
     return rows.map(rowToNode);
   }
+  typedEdgeStmt(sql) {
+    let stmt = this.typedEdgeStmts.get(sql);
+    if (!stmt) {
+      stmt = this.db.prepare(sql);
+      this.typedEdgeStmts.set(sql, stmt);
+    }
+    return stmt;
+  }
   outEdges(nodeId, types) {
     if (!types || types.length === 0) {
       const rows2 = this.stmts.outEdges.all(nodeId);
@@ -25102,7 +25114,7 @@ var SqliteGraphStore = class {
     types.forEach((t, i2) => {
       params[`t${i2}`] = t;
     });
-    const rows = this.db.prepare(
+    const rows = this.typedEdgeStmt(
       `SELECT * FROM edges WHERE from_id = :from_id AND type IN (${placeholders}) AND valid_to IS NULL`
     ).all(params);
     return rows.map(rowToEdge);
@@ -25117,7 +25129,7 @@ var SqliteGraphStore = class {
     types.forEach((t, i2) => {
       params[`t${i2}`] = t;
     });
-    const rows = this.db.prepare(
+    const rows = this.typedEdgeStmt(
       `SELECT * FROM edges WHERE to_id = :to_id AND type IN (${placeholders}) AND valid_to IS NULL`
     ).all(params);
     return rows.map(rowToEdge);
@@ -25195,6 +25207,15 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
     return rows.map((r) => r.id);
   }
+  labelFingerprint(labels) {
+    if (labels.length === 0) return "0";
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
+                MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
+           FROM nodes WHERE valid_to IS NULL AND label IN (${labels.map(() => "?").join(",")})`
+    ).get(...labels);
+    return `${r.n}:${r.t ?? 0}:${r.s ?? 0}`;
+  }
   /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
    *  Closures matter as much as additions: a node that lost inflow is rank-dirty
    *  while its own row never updated, so removal endpoints must seed the