@inerrata-corporation/errata 2.0.22-dev.4430 → 2.0.22-dev.4530

package/errata.mjs

@@ -17425,6 +17425,12 @@ var init_history_temporal = __esm({
 });
 
 // ../../packages/shared/src/history-revision.ts
+function settledHistoryReceipt(evidence) {
+  if (!evidence || typeof evidence !== "object") return false;
+  const e = evidence;
+  const review = e["review"];
+  return e["build"] === HISTORY_RECONCILE_BUILD && e["reviewStatus"] !== "failed-provider" && review?.["status"] !== "failed-schema" && (e["reviewStatus"] !== "deferred-budget" || e["reviewPolicy"] === HISTORY_REVIEW_POLICY);
+}
 function historyDag(records) {
   const graph = new Map(records.map((r) => [r.commit, r.parents]));
   if (graph.size !== records.length) throw new Error("duplicate Git commit in history proof");
@@ -17481,7 +17487,7 @@ function preservedHistoryOccurrence(o, observed, atCommit, ancestor) {
   if (!anchors?.length || anchors.some((a) => a.side !== "after" || !a.bodyHash || !observed.symbols.some((s) => s.symbolId === a.symbolId && s.bodyHash === a.bodyHash))) return false;
   return parsed.data.every((e) => anchors.some((a) => a.blockDigest === e.blockDigest && a.startByte <= e.startByte && a.endByte >= e.endByte));
 }
-var Sha, HistoryRevisionRequestSchema;
+var Sha, HistoryRevisionRequestSchema, HistoryCarryRequestSchema, HISTORY_REVIEW_BUDGET, HISTORY_REVIEW_POLICY;
 var init_history_revision = __esm({
   "../../packages/shared/src/history-revision.ts"() {
     "use strict";
@@ -17501,6 +17507,17 @@ var init_history_revision = __esm({
         dependencyContext: HistoryDependencyContextSchema.optional()
       })).max(50)
     });
+    HistoryCarryRequestSchema = external_exports.strictObject({
+      fromCommit: Sha,
+      atCommit: Sha,
+      parents: external_exports.array(external_exports.strictObject({ commit: Sha, parents: external_exports.array(Sha).max(32) })).max(8192),
+      /** Every symbol in a file the range changed, both sides; `null` = too many to name, treat all as changed. */
+      changedSymbols: external_exports.array(external_exports.string().regex(/^sym_[a-f0-9]{8,64}$/)).max(5e3).nullable(),
+      /** Manifests the range changed; `null` = a lockfile (or too many manifests) changed, treat all as changed. */
+      changedManifests: external_exports.array(external_exports.string().regex(/^hmanifest_[a-f0-9]{32}$/)).max(512).nullable()
+    });
+    HISTORY_REVIEW_BUDGET = 48e3;
+    HISTORY_REVIEW_POLICY = `reviewer-view-${HISTORY_REVIEW_BUDGET}`;
   }
 });
 
@@ -17608,10 +17625,13 @@ __export(src_exports, {
   HISTORY_MAX_SPINE_DEPS: () => HISTORY_MAX_SPINE_DEPS,
   HISTORY_MAX_TEXT_CHARS: () => HISTORY_MAX_TEXT_CHARS,
   HISTORY_RECONCILE_BUILD: () => HISTORY_RECONCILE_BUILD,
+  HISTORY_REVIEW_BUDGET: () => HISTORY_REVIEW_BUDGET,
+  HISTORY_REVIEW_POLICY: () => HISTORY_REVIEW_POLICY,
   HISTORY_SCRUBBER_VERSION: () => HISTORY_SCRUBBER_VERSION,
   HistoryAnchorSourceSchema: () => HistoryAnchorSourceSchema,
   HistoryCandidateBatchSchema: () => HistoryCandidateBatchSchema,
   HistoryCandidateSchema: () => HistoryCandidateSchema,
+  HistoryCarryRequestSchema: () => HistoryCarryRequestSchema,
   HistoryDependencyContextSchema: () => HistoryDependencyContextSchema,
   HistoryDependencySchema: () => HistoryDependencySchema,
   HistoryEvidenceRefSchema: () => HistoryEvidenceRefSchema,
@@ -17750,6 +17770,7 @@ __export(src_exports, {
   scrubHistoryText: () => scrubHistoryText,
   scrubHistoryValue: () => scrubHistoryValue,
   selectHistoryDependencies: () => selectHistoryDependencies,
+  settledHistoryReceipt: () => settledHistoryReceipt,
   sha256: () => sha256,
   sha256Short: () => sha256Short,
   sidecarDropBucket: () => sidecarDropBucket,
@@ -17826,8 +17847,8 @@ ${endMarker}
   const startM = current.match(START_RE);
   const endM = current.match(END_RE);
   if (!startM || !endM || startM.index === void 0 || endM.index === void 0) {
-    const sep6 = current.endsWith("\n") ? "" : "\n";
-    writeFileSync(filePath, `${current}${sep6}
+    const sep7 = current.endsWith("\n") ? "" : "\n";
+    writeFileSync(filePath, `${current}${sep7}
 ${blockText}`, "utf8");
     return { kind: "created", newHash };
   }
@@ -19145,6 +19166,129 @@ var init_text_index = __esm({
   }
 });
 
+// ../../packages/local-graph/src/exposure-attrs.ts
+var EXPOSURE_ATTRS, EXPOSURE_SCOPE;
+var init_exposure_attrs = __esm({
+  "../../packages/local-graph/src/exposure-attrs.ts"() {
+    "use strict";
+    EXPOSURE_ATTRS = [
+      "shownCount",
+      "evictedCount",
+      "firstShownAt",
+      "firstEvictedAt",
+      "firstShownAtSeq",
+      "lastShownAtSeq",
+      "lastEvictedAtSeq",
+      "shownSinceTouch",
+      "shownSinceTouchAt",
+      "exposureLog",
+      "exposureLogStart",
+      "exposureLogSince",
+      "exposureFirst",
+      "exposureTrimmed"
+    ];
+    EXPOSURE_SCOPE = "exposure";
+  }
+});
+
+// ../../packages/local-graph/src/change-feed.ts
+function installChangeFeed(db) {
+  if (changeFeedInstalled(db)) return;
+  db.transaction(() => {
+    db.exec("CREATE TABLE IF NOT EXISTS change_seq (scope TEXT PRIMARY KEY, seq INTEGER NOT NULL) WITHOUT ROWID");
+    db.exec(`CREATE TABLE IF NOT EXISTS change_log (change_seq INTEGER PRIMARY KEY, kind TEXT NOT NULL, id TEXT NOT NULL,
+      label TEXT, from_id TEXT, to_id TEXT)`);
+    for (const name2 of ["nodes", "edges"].flatMap((t) => ["insert", "update", "delete"].map((op) => `change_feed_${t}_${op}`))) {
+      db.exec(`DROP TRIGGER IF EXISTS ${name2}`);
+    }
+    const changed = (table) => columns(db, table).map((c) => `OLD."${c}" IS NOT NEW."${c}"`).join(" OR ");
+    const strip3 = (row) => `json_remove(${row}.attrs_json, ${EXPOSURE_ATTRS.map((a) => `'$.${a}'`).join(", ")})`;
+    const exposureOnly = `(${columns(db, "nodes").filter((c) => c !== "attrs_json").map((c) => `OLD."${c}" IS NEW."${c}"`).join(" AND ")}
+      AND CASE WHEN json_valid(OLD.attrs_json) AND json_valid(NEW.attrs_json) THEN ${strip3("OLD")} IS ${strip3("NEW")} ELSE 0 END)`;
+    const bump = (...scopes) => `INSERT INTO change_seq(scope, seq) VALUES ${scopes.map((s) => `(${s}, 1)`).join(", ")}
+      ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;`;
+    const seq = `(SELECT seq FROM change_seq WHERE scope = '*')`;
+    const logNode = (row) => `INSERT INTO change_log(change_seq, kind, id, label) VALUES (${seq}, 'node', ${row}.id, ${row}.label);`;
+    const logEdge = (row) => `INSERT INTO change_log(change_seq, kind, id, label, from_id, to_id) VALUES (${seq}, 'edge', ${row}.id, ${row}.type, ${row}.from_id, ${row}.to_id);`;
+    const node2 = (row) => `'node:' || ${row}.label`;
+    const edge2 = (row) => `'edge:' || ${row}.type`;
+    db.exec(`CREATE TRIGGER change_feed_nodes_insert AFTER INSERT ON nodes BEGIN ${bump(`'*'`, node2("NEW"))} ${logNode("NEW")} END;`);
+    db.exec(`CREATE TRIGGER change_feed_nodes_update AFTER UPDATE ON nodes WHEN ${changed("nodes")} BEGIN
+      ${bump(`'*'`)}
+      INSERT INTO change_seq(scope, seq) SELECT CASE WHEN ${exposureOnly} THEN '${EXPOSURE_SCOPE}' ELSE ${node2("NEW")} END, 1 WHERE 1
+        ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;
+      INSERT INTO change_seq(scope, seq) SELECT ${node2("OLD")}, 1 WHERE OLD.label IS NOT NEW.label
+        ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;
+      ${logNode("NEW")}
+    END;`);
+    db.exec(`CREATE TRIGGER change_feed_nodes_delete AFTER DELETE ON nodes BEGIN ${bump(`'*'`, node2("OLD"))} ${logNode("OLD")} END;`);
+    db.exec(`CREATE TRIGGER change_feed_edges_insert AFTER INSERT ON edges BEGIN ${bump(`'*'`, edge2("NEW"))} ${logEdge("NEW")} END;`);
+    db.exec(`CREATE TRIGGER change_feed_edges_update AFTER UPDATE ON edges WHEN ${changed("edges")} BEGIN
+      ${bump(`'*'`, edge2("NEW"))}
+      INSERT INTO change_seq(scope, seq) SELECT ${edge2("OLD")}, 1 WHERE OLD.type IS NOT NEW.type
+        ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;
+      ${logEdge("NEW")}
+    END;`);
+    db.exec(`CREATE TRIGGER change_feed_edges_delete AFTER DELETE ON edges BEGIN ${bump(`'*'`, edge2("OLD"))} ${logEdge("OLD")} END;`);
+    db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, ?)").run(PRUNED_TO_KEY, String(readChangeSeq(db)));
+    db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, ?)").run(CHANGE_FEED_KEY, columnSignature(db));
+  });
+}
+function readChangeSeq(db, scopes = [ANY_CHANGE]) {
+  if (!scopes.length) return 0;
+  const row = db.prepare(`SELECT coalesce(sum(seq), 0) AS n FROM change_seq WHERE scope IN (${scopes.map(() => "?").join(",")})`).get(...scopes);
+  return Number(row?.n ?? 0);
+}
+function changeLogCovers(db, sinceSeq) {
+  const prunedTo = Number(db.prepare("SELECT value FROM store_meta WHERE key = ?").get(PRUNED_TO_KEY)?.["value"] ?? NaN);
+  return Number.isFinite(prunedTo) && sinceSeq >= prunedTo;
+}
+function readLineageChangedFiles(db, sinceSeq) {
+  if (!changeLogCovers(db, sinceSeq)) return null;
+  const rows = db.prepare(LINEAGE_CHANGED_FILES_SQL).all({ s: sinceSeq });
+  return rows.map((r) => r.id);
+}
+function pruneChangeLog(db) {
+  const max = Number(db.prepare("SELECT coalesce(max(change_seq), 0) AS n FROM change_log").get()?.["n"] ?? 0);
+  const cut = max - CHANGE_LOG_KEEP;
+  if (cut <= 0) return 0;
+  let removed = 0;
+  db.transaction(() => {
+    removed = Number(db.prepare("DELETE FROM change_log WHERE change_seq <= ?").run(cut).changes);
+    const prev = Number(db.prepare("SELECT value FROM store_meta WHERE key = ?").get(PRUNED_TO_KEY)?.["value"] ?? 0);
+    db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, ?)").run(PRUNED_TO_KEY, String(Math.max(prev, cut)));
+  });
+  return removed;
+}
+function changeFeedInstalled(db) {
+  return db.prepare("SELECT value FROM store_meta WHERE key = ?").get(CHANGE_FEED_KEY)?.["value"] === columnSignature(db);
+}
+function columns(db, table) {
+  return db.prepare(`SELECT name FROM pragma_table_info('${table}') ORDER BY cid`).all().map((r) => r.name);
+}
+function columnSignature(db) {
+  return `5|${columns(db, "nodes").join(",")}|${columns(db, "edges").join(",")}|${EXPOSURE_ATTRS.join(",")}`;
+}
+var CHANGE_FEED_KEY, ANY_CHANGE, nodeScope, edgeScope, CHANGE_LOG_KEEP, PRUNED_TO_KEY, LINEAGE_CHANGED_FILES_SQL;
+var init_change_feed = __esm({
+  "../../packages/local-graph/src/change-feed.ts"() {
+    "use strict";
+    init_exposure_attrs();
+    CHANGE_FEED_KEY = "change-feed";
+    ANY_CHANGE = "*";
+    nodeScope = (label) => `node:${label}`;
+    edgeScope = (type) => `edge:${type}`;
+    CHANGE_LOG_KEEP = 25e4;
+    PRUNED_TO_KEY = "change-log-pruned-to";
+    LINEAGE_CHANGED_FILES_SQL = `
+  SELECT id FROM change_log WHERE change_seq > :s AND kind = 'node' AND label = 'File'
+  UNION SELECT from_id FROM change_log WHERE change_seq > :s AND kind = 'edge' AND label IN ('DEFINES','CONTAINS')
+  UNION SELECT e.from_id FROM (SELECT DISTINCT id FROM change_log WHERE change_seq > :s AND kind = 'node') c
+    CROSS JOIN edges e ON e.to_id = c.id AND e.type IN ('DEFINES','CONTAINS')
+`;
+  }
+});
+
 // ../../packages/local-graph/src/lineage-integrity.ts
 function stmt(db, sql) {
   let byDb = statements.get(db);
@@ -20399,6 +20543,7 @@ function graphStoreNeedsPreparation(path3) {
     for (const match2 of (SCHEMA_SQL + TEMPORAL_INDEX_SQL).matchAll(/CREATE INDEX IF NOT EXISTS (\w+)/g)) {
       if (!indexes.has(match2[1])) return true;
     }
+    if (!changeFeedInstalled(db)) return true;
     return [SESSION_REPAIR_KEY, HISTORY_CACHE_FLOOR_KEY, EDIT_PLACEHOLDER_FLOOR_KEY, CLOUD_ATTR_COMPACTION_KEY, HISTORY_ATTR_SLIM_KEY, TEXT_INDEX_KEY, LINEAGE_INTEGRITY_KEY].some((key) => !db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key));
   } catch {
     return true;
@@ -20478,6 +20623,7 @@ var init_store = __esm({
     init_cloud_attr_compaction();
     init_history_attr_slim();
     init_text_index();
+    init_change_feed();
     init_lineage_integrity();
     init_src3();
     init_node_select();
@@ -20705,6 +20851,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           });
         }
         installLineageIntegrityRepair(this.db);
+        installChangeFeed(this.db);
         this.stmts = {
           insertNode: this.db.prepare(`
         INSERT INTO nodes (
@@ -21492,12 +21639,39 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       mutationCount() {
         return this.mutations;
       }
+      changeStamp() {
+        const { data_version } = this.db.pragma("data_version");
+        const { n } = this.db.prepare("SELECT total_changes() AS n").get();
+        return `${data_version}:${n}`;
+      }
+      changeSeq(scopes) {
+        return readChangeSeq(this.db, scopes);
+      }
+      lineageChangedFiles(sinceSeq) {
+        return readLineageChangedFiles(this.db, sinceSeq);
+      }
+      pruneChangeLog() {
+        return pruneChangeLog(this.db);
+      }
+      fileRowStates(ids) {
+        if (ids.length === 0) return [];
+        if (ids.length > 500) throw new RangeError("fileRowStates accepts at most 500 ids per read");
+        return this.db.prepare(`SELECT id, last_updated_at AS lastUpdatedAt, valid_to AS validTo FROM nodes WHERE id IN (${ids.map(() => "?").join(",")})`).all(...ids);
+      }
+      // Read and advanced in SQL, never from a per-connection copy: pass workers and
+      // MCP processes open their own connections and advance the same row, so a
+      // copy loaded at open went stale, and `copy + 1` wrote a duplicate or a
+      // backwards seq from whichever connection had fallen behind.
       currentIngestSeq() {
+        const row = this.db.prepare("SELECT value FROM store_meta WHERE key = 'ingest_seq'").get();
+        this.ingestSeq = row ? Number(row.value) : 0;
         return this.ingestSeq;
       }
       nextIngestSeq() {
-        this.ingestSeq += 1;
-        this.stmts.setIngestSeq.run({ v: String(this.ingestSeq) });
+        const row = this.db.prepare(
+          "INSERT INTO store_meta (key, value) VALUES ('ingest_seq', '1') ON CONFLICT(key) DO UPDATE SET value = CAST(value AS INTEGER) + 1 RETURNING value"
+        ).get();
+        this.ingestSeq = Number(row.value);
         return this.ingestSeq;
       }
       edgeCount() {
@@ -27128,14 +27302,17 @@ var init_wm_calibration = __esm({
 // ../../packages/local-graph/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
+  ANY_CHANGE: () => ANY_CHANGE,
   AUTO_MINT_PREFIX: () => AUTO_MINT_PREFIX,
   CAUSAL_FAMILY: () => CAUSAL_FAMILY,
   CITABLE_PRIOR_LABELS: () => CITABLE_PRIOR_LABELS,
   CODE_REACH_EDGES: () => CODE_REACH_EDGES,
   CREDIT_FAMILY: () => CREDIT_FAMILY,
   DEFAULT_MIN_COVERAGE: () => DEFAULT_MIN_COVERAGE,
+  EXPOSURE_ATTRS: () => EXPOSURE_ATTRS,
   EXPOSURE_LOG_KEYS: () => EXPOSURE_LOG_KEYS,
   EXPOSURE_LOG_MAX: () => EXPOSURE_LOG_MAX,
+  EXPOSURE_SCOPE: () => EXPOSURE_SCOPE,
   FINGERPRINT_INDEXED_LABELS: () => FINGERPRINT_INDEXED_LABELS,
   FIX_CANDIDATE_ASK_LIMIT: () => FIX_CANDIDATE_ASK_LIMIT,
   FOLD_EMBED_AUTO_COSINE: () => FOLD_EMBED_AUTO_COSINE,
@@ -27208,6 +27385,7 @@ __export(src_exports2, {
   designProblemId: () => designProblemId,
   detectLocalCommunities: () => detectLocalCommunities,
   edgeConductance: () => edgeConductance,
+  edgeScope: () => edgeScope,
   evaluateDependency: () => evaluateDependency,
   evaluateFed: () => evaluateFed,
   evaluateMechanisms: () => evaluateMechanisms,
@@ -27261,6 +27439,7 @@ __export(src_exports2, {
   mintDomainNode: () => mintDomainNode,
   mintPatternNode: () => mintPatternNode,
   mintWorkspaceCausalFact: () => mintWorkspaceCausalFact,
+  nodeScope: () => nodeScope,
   openGraphStore: () => openGraphStore,
   osNodeId: () => osNodeId,
   parseAbstractionFences: () => parseAbstractionFences,
@@ -27321,6 +27500,8 @@ var init_src5 = __esm({
     "use strict";
     init_store();
     init_types();
+    init_change_feed();
+    init_exposure_attrs();
     init_traversal();
     init_justification();
     init_credit();
@@ -27374,12 +27555,12 @@ function buildSnapshot(opts) {
   const problems = opts.store.selectNodes({ labels: ["Problem", "Vulnerability"], attrs: PROBLEM_BAND_ATTRS }).filter((p) => p.attrs["mergedInto"] === void 0 && passiveAllowed(p, opts.atCommit));
   const stillOpen = problems.filter((p) => p.attrs["resolvedAt"] == null);
   const allProblems = rankRecentBand(stillOpen.filter((p) => !isConstraintProblem(p)));
-  const openPool = allProblems.slice(0, RECENT_OPEN * SCOPE_POOL_FACTOR).map((p) => ({
+  const openPool = allProblems.slice(0, Math.max(RECENT_OPEN * SCOPE_POOL_FACTOR, RECENT_WINDOW_BANDS * RECENT_OPEN)).map((p) => ({
     node: hydrate(p.id),
     anchors: opts.store.outEdges(p.id, ["MANIFESTED_IN", "EVIDENCED_BY"])
   }));
   const recent4 = openPool.slice(0, RECENT_OPEN);
-  const constraintPool = rankRecentBand(stillOpen.filter((p) => isConstraintProblem(p)), { window: RECENT_WINDOW_BANDS * RECENT_CONSTRAINTS }).slice(0, RECENT_CONSTRAINTS * SCOPE_POOL_FACTOR).map((p) => hydrate(p.id));
+  const constraintPool = rankRecentBand(stillOpen.filter((p) => isConstraintProblem(p)), { window: RECENT_WINDOW_BANDS * RECENT_CONSTRAINTS }).slice(0, Math.max(RECENT_CONSTRAINTS * SCOPE_POOL_FACTOR, RECENT_WINDOW_BANDS * RECENT_CONSTRAINTS)).map((p) => hydrate(p.id));
   const recentConstraints = constraintPool.slice(0, RECENT_CONSTRAINTS);
   const regressionSources = /* @__PURE__ */ new Set();
   for (const target of opts.store.inDegreeByType(["REGRESSION_OF"]).keys()) {
@@ -27489,6 +27670,22 @@ function rankRecentBand(problems, { quota = RECENT_SHOW_QUOTA, window: window2 =
   const head2 = byRecency.slice(0, window2);
   return [...head2.filter((p) => !spent(p)), ...head2.filter(spent), ...byRecency.slice(window2)];
 }
+function freshenRecentBands(s, read2) {
+  const pool = s.scopePool;
+  if (!pool) return s;
+  const fresh = (n) => read2(n.id) ?? n;
+  const openRows = pool.open.map((r) => ({ ...r, node: fresh(r.node) }));
+  const openOrder = rankRecentBand(openRows.map((r) => r.node), { window: openRows.length });
+  const byId = new Map(openRows.map((r) => [r.node.id, r]));
+  const open2 = openOrder.map((n) => byId.get(n.id));
+  const constraints = rankRecentBand(pool.constraints.map(fresh), { window: pool.constraints.length });
+  return {
+    ...s,
+    recentProblems: open2.slice(0, RECENT_OPEN),
+    recentConstraints: constraints.slice(0, RECENT_CONSTRAINTS),
+    scopePool: { ...pool, open: open2, constraints }
+  };
+}
 function scopeSnapshot(s, keep) {
   const pool = s.scopePool;
   if (!pool) return s;
@@ -29363,10 +29560,16 @@ var init_client = __esm({
       async getProjectHistoryCorrections(projectId, since, limit = 200) {
         return this.json("GET", `/v2/projects/${encodeURIComponent(projectId)}/anchors?correctionsOnly=1&correctionSince=${String(since)}&limit=${String(limit)}`);
       }
-      async getHistoryOccurrences(projectId, atCommit, after) {
-        const query = new URLSearchParams({ atCommit, limit: "50", ...after ? { after } : {} });
+      /** `pendingOnly`: just what a sweep at `atCommit` must post (no settled receipt) or land
+       *  (a verdict other than unknown). A cloud that predates the filter returns every occurrence. */
+      async getHistoryOccurrences(projectId, atCommit, after, opts = {}) {
+        const query = new URLSearchParams({ atCommit, limit: "50", ...after ? { after } : {}, ...opts.pendingOnly ? { pending: "1" } : {} });
         return this.json("GET", `/v2/projects/${encodeURIComponent(projectId)}/history/occurrences?${query}`);
       }
+      /** Carry settled verdicts across a commit range; 404 from a cloud that predates the route. */
+      async carryHistory(projectId, carry) {
+        return this.json("POST", `/v2/projects/${encodeURIComponent(projectId)}/history/carry`, carry);
+      }
       async reconcileHistory(projectId, proof) {
         return this.json("POST", `/v2/projects/${encodeURIComponent(projectId)}/history/reconcile`, proof);
       }
@@ -35158,7 +35361,7 @@ function rememberAgentCard(sessionId, agentId, card, now = Date.now()) {
 function subagentRows(body2, now = Date.now()) {
   const sessionId = typeof body2["session_id"] === "string" ? body2["session_id"] : "";
   const tasks = Array.isArray(body2["tasks"]) ? body2["tasks"] : [];
-  const columns = typeof body2["columns"] === "number" && body2["columns"] > 20 ? body2["columns"] : 100;
+  const columns2 = typeof body2["columns"] === "number" && body2["columns"] > 20 ? body2["columns"] : 100;
   const lines = [];
   for (const task of tasks) {
     const id = typeof task["id"] === "string" ? task["id"] : "";
@@ -35168,7 +35371,7 @@ function subagentRows(body2, now = Date.now()) {
     const title = String(task["description"] ?? task["label"] ?? "").trim();
     const plain = clip(
       `${title ? `${title} \xB7 ` : ""}\u26A1 errata \xB7 ${hit.card.headline}${lead2 ? ` \u2014 ${labelName(lead2.label)}: ${lead2.text}` : ""}`,
-      columns - 2
+      columns2 - 2
     );
     lines.push(JSON.stringify({ id, content: plain.replace("\u26A1", `${AMBER}\u26A1${RESET}`) }));
   }
@@ -38216,8 +38419,8 @@ import { execFileSync as execFileSync3 } from "node:child_process";
 function nowTs() {
   return indexNow ?? Date.now();
 }
-function fingerprintOf(signature, bodyHash) {
-  return `${signature ?? ""}|${bodyHash ?? ""}`;
+function fingerprintOf(signature2, bodyHash) {
+  return `${signature2 ?? ""}|${bodyHash ?? ""}`;
 }
 function sha(s) {
   return createHash7("sha256").update(s).digest("hex").slice(0, 16);
@@ -46733,11 +46936,20 @@ function* walkSource(dir) {
 function listSourceFiles(root) {
   return gitSourceFiles(root) ?? walkSource(root);
 }
-async function findStaleFiles(store, rootPath, workspaceId2) {
+async function findStaleFiles(store, rootPath, workspaceId2, lineageVerifiedAt) {
   const stale = [];
+  const changed = lineageVerifiedAt !== void 0 && store.fileRowStates ? store.lineageChangedFiles?.(lineageVerifiedAt) : null;
+  const relineage = changed ? new Set(changed) : null;
   let pending = [];
   const check2 = () => {
-    const states = new Map(store.fileIndexStates(pending.map((f) => f.id)).map((s) => [s.id, s]));
+    const full = relineage ? pending.filter((f) => relineage.has(f.id)) : pending;
+    const states = new Map(
+      store.fileIndexStates(full.map((f) => f.id)).map((s) => [s.id, s])
+    );
+    if (relineage) {
+      const rowOnly = pending.filter((f) => !relineage.has(f.id)).map((f) => f.id);
+      for (const s of store.fileRowStates(rowOnly)) states.set(s.id, { ...s, complete: true });
+    }
     for (const f of pending) {
       const state = states.get(f.id);
       if (!state || state.validTo !== null || state.lastUpdatedAt < f.mtimeMs || !state.complete) stale.push(f.abs);
@@ -46762,6 +46974,19 @@ async function findStaleFiles(store, rootPath, workspaceId2) {
 function findStrandedSymbols(store) {
   return store.strandedSymbols();
 }
+function standingStrandedCount(store) {
+  try {
+    const last = JSON.parse(store.getMeta?.(STRANDED_KEY) ?? "null");
+    if (!last) return null;
+    if ((store.changeSeq?.() ?? Infinity) - last.seq > STRANDED_WINDOW_MAX) return null;
+    return store.lineageChangedFiles?.(last.seq)?.length === 0 ? last.count : null;
+  } catch {
+    return null;
+  }
+}
+function recordStrandedCount(store, seq, count) {
+  if (seq !== void 0) store.setMeta?.(STRANDED_KEY, JSON.stringify({ seq, count }));
+}
 function reapOrphanedFiles(store, rootPath, workspaceId2, ignoreDirs = []) {
   const ignores = /* @__PURE__ */ new Set([...DEFAULT_IGNORES, ...ignoreDirs]);
   const listed = gitListRelPaths(rootPath, ignores);
@@ -46800,8 +47025,16 @@ function reapOrphanedFiles(store, rootPath, workspaceId2, ignoreDirs = []) {
   return { reaped: orphans.length, symbolsClosed };
 }
 async function reconcileStaleFiles(store, rootPath, workspaceId2) {
-  const stale = await findStaleFiles(store, rootPath, workspaceId2);
-  if (stale.length === 0) return 0;
+  const startedAt = store.changeSeq?.();
+  const verified = Number(store.getMeta?.(LINEAGE_VERIFIED_KEY) ?? NaN);
+  const stale = await findStaleFiles(store, rootPath, workspaceId2, Number.isFinite(verified) ? verified : void 0);
+  const verify = () => {
+    if (startedAt !== void 0) store.setMeta?.(LINEAGE_VERIFIED_KEY, String(startedAt));
+  };
+  if (stale.length === 0) {
+    verify();
+    return 0;
+  }
   let total = 0;
   let failedBatches = 0;
   const BATCH = 20;
@@ -46819,10 +47052,12 @@ async function reconcileStaleFiles(store, rootPath, workspaceId2) {
   }
   if (failedBatches > 0) {
     console.warn(`[errata] reconcile: ${failedBatches} batch(es) failed; ${total} file(s) reindexed`);
+  } else {
+    verify();
   }
   return total;
 }
-var IGNORED, SOURCE_RE, SCAN_YIELD_EVERY, ORPHAN_REAP_MAX_FRACTION, ORPHAN_REAP_MIN_ALLOWANCE;
+var IGNORED, SOURCE_RE, SCAN_YIELD_EVERY, STRANDED_KEY, STRANDED_WINDOW_MAX, ORPHAN_REAP_MAX_FRACTION, ORPHAN_REAP_MIN_ALLOWANCE, LINEAGE_VERIFIED_KEY;
 var init_reconcile = __esm({
   "src/reconcile.ts"() {
     "use strict";
@@ -46830,8 +47065,11 @@ var init_reconcile = __esm({
     IGNORED = /[\\/](?:\.git|node_modules|\.errata|dist|__pycache__)(?:[\\/]|$)/;
     SOURCE_RE = /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i;
     SCAN_YIELD_EVERY = 100;
+    STRANDED_KEY = "pass-inputs:stranded";
+    STRANDED_WINDOW_MAX = 2e4;
     ORPHAN_REAP_MAX_FRACTION = 0.25;
     ORPHAN_REAP_MIN_ALLOWANCE = 50;
+    LINEAGE_VERIFIED_KEY = "pass-inputs:reconcile-lineage";
   }
 });
 
@@ -76471,18 +76709,18 @@ __export(witness_ledger_exports, {
   summarizeWitnessLedger: () => summarizeWitnessLedger,
   witnessLedgerPath: () => witnessLedgerPath
 });
-import { appendFileSync as appendFileSync3, existsSync as existsSync27, readFileSync as readFileSync30, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join34 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync27, readFileSync as readFileSync31, writeFileSync as writeFileSync22 } from "node:fs";
+import { join as join35 } from "node:path";
 function witnessLedgerPath(configDir) {
-  return join34(configDir, "witness-ledger.jsonl");
+  return join35(configDir, "witness-ledger.jsonl");
 }
 function appendWitnessLedger(configDir, entry) {
   const path3 = witnessLedgerPath(configDir);
   try {
     appendFileSync3(path3, JSON.stringify(entry) + "\n");
-    const lines = readFileSync30(path3, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync31(path3, "utf8").split("\n").filter(Boolean);
     if (lines.length > LEDGER_MAX_LINES) {
-      writeFileSync21(path3, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
+      writeFileSync22(path3, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
     }
   } catch {
   }
@@ -76491,7 +76729,7 @@ function readWitnessLedger(configDir) {
   const path3 = witnessLedgerPath(configDir);
   if (!existsSync27(path3)) return [];
   try {
-    return readFileSync30(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
+    return readFileSync31(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
   } catch {
     return [];
   }
@@ -76930,12 +77168,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync3, existsSync as existsSync40, openSync as openSync3, readFileSync as readFileSync45, renameSync as renameSync9, statSync as statSync15 } from "node:fs";
-import { join as join53, resolve as pathResolve2 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync40, openSync as openSync3, readFileSync as readFileSync48, renameSync as renameSync10, statSync as statSync16 } from "node:fs";
+import { join as join56, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync29, writeFileSync as writeFileSync24 } from "node:fs";
+import { existsSync as existsSync29, writeFileSync as writeFileSync25 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.34/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -77619,8 +77857,8 @@ function knowledgeTag(label, attrs) {
 
 // src/engine.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync28, statSync as statSync10, appendFileSync as appendFileSync4, readdirSync as readdirSync11, renameSync as renameSync4, readFileSync as readFileSync32, writeFileSync as writeFileSync23 } from "node:fs";
-import { basename as basename8, join as join36, relative as relative7, sep as sep4 } from "node:path";
+import { existsSync as existsSync28, statSync as statSync11, appendFileSync as appendFileSync4, readdirSync as readdirSync11, renameSync as renameSync5, readFileSync as readFileSync33, writeFileSync as writeFileSync24 } from "node:fs";
+import { basename as basename8, join as join37, relative as relative6, sep as sep5 } from "node:path";
 
 // src/coalesced-file-pass.ts
 function createCoalescedFilePass(delayMs, run3, onError) {
@@ -77665,7 +77903,7 @@ function createCoalescedFilePass(delayMs, run3, onError) {
 // src/source-watcher.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
 import { readdirSync as readdirSync6, statSync as statSync7, watch as watch2 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join21, relative as relative6 } from "node:path";
+import { join as join21, sep as sep4 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -78396,9 +78634,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname19 = sysPath.dirname(file2);
+    const dirname20 = sysPath.dirname(file2);
     const basename10 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname19);
+    const parent = this.fsw._getWatchedDir(dirname20);
     let prevStats = stats;
     if (parent.has(basename10))
       return;
@@ -78425,7 +78663,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname19, basename10);
+          this.fsw._remove(dirname20, basename10);
         }
       } else if (parent.has(basename10)) {
         const at = newStats.atimeMs;
@@ -78674,11 +78912,11 @@ function createPattern(matcher) {
       if (matcher.path === string4)
         return true;
       if (matcher.recursive) {
-        const relative9 = sysPath2.relative(matcher.path, string4);
-        if (!relative9) {
+        const relative8 = sysPath2.relative(matcher.path, string4);
+        if (!relative8) {
           return false;
         }
-        return !relative9.startsWith("..") && !sysPath2.isAbsolute(relative9);
+        return !relative8.startsWith("..") && !sysPath2.isAbsolute(relative8);
       }
       return false;
     };
@@ -79387,7 +79625,9 @@ var NativeSourceWatcher = class extends EventEmitter2 {
   handles = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
   rescans = /* @__PURE__ */ new Map();
-  known = /* @__PURE__ */ new Set();
+  /** Each known file's content signature (mtime and size). A raw event whose
+   *  file still has the same signature changed nothing in it. */
+  known = /* @__PURE__ */ new Map();
   closed = false;
   add(target) {
     if (this.closed || this.handles.has(target)) return;
@@ -79441,21 +79681,35 @@ var NativeSourceWatcher = class extends EventEmitter2 {
     this.pending.set(path3, { timer, renamed: renamed || (prev?.renamed ?? false) });
   }
   seedKnown(target, isDir) {
-    for (const path3 of this.filesUnder(target, isDir)) this.known.add(path3);
+    for (const [path3, sig] of this.filesUnder(target, isDir)) this.known.set(path3, sig);
   }
   filesUnder(target, isDir) {
-    const files = /* @__PURE__ */ new Set();
+    const files = /* @__PURE__ */ new Map();
+    const add = (path3) => {
+      try {
+        files.set(path3, signature(statSync7(path3)));
+      } catch {
+      }
+    };
     if (!isDir) {
-      if (!this.ignored(target)) files.add(target);
+      if (!this.ignored(target)) add(target);
       return files;
     }
-    try {
-      for (const entry of readdirSync6(target, { recursive: true, withFileTypes: true })) {
-        if (!entry.isFile()) continue;
-        const path3 = join21(entry.parentPath, entry.name);
-        if (!this.ignored(path3)) files.add(path3);
+    const dirs = [target];
+    while (dirs.length > 0) {
+      const dir = dirs.pop();
+      let entries;
+      try {
+        entries = readdirSync6(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const path3 = join21(dir, entry.name);
+        if (this.ignored(path3)) continue;
+        if (entry.isDirectory()) dirs.push(path3);
+        else if (entry.isFile()) add(path3);
       }
-    } catch {
     }
     return files;
   }
@@ -79466,19 +79720,17 @@ var NativeSourceWatcher = class extends EventEmitter2 {
       this.rescans.delete(target);
       if (this.closed || !this.handles.has(target)) return;
       const current = this.filesUnder(target, isDir);
-      const belongsToTarget = (path3) => {
-        const rel = relative6(target, path3);
-        return rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
-      };
-      for (const path3 of [...this.known]) {
+      const prefix = target.endsWith(sep4) ? target : target + sep4;
+      const belongsToTarget = (path3) => path3 === target || path3.startsWith(prefix);
+      for (const path3 of [...this.known.keys()]) {
         if (belongsToTarget(path3) && !current.has(path3)) {
           this.known.delete(path3);
           this.emit("unlink", path3);
         }
       }
-      for (const path3 of current) {
+      for (const [path3, sig] of current) {
         if (!this.known.has(path3)) {
-          this.known.add(path3);
+          this.known.set(path3, sig);
           this.emit("add", path3);
         }
       }
@@ -79488,21 +79740,27 @@ var NativeSourceWatcher = class extends EventEmitter2 {
   classify(path3, renamed) {
     if (this.closed) return;
     let isFile;
+    let sig;
     try {
       const s = statSync7(path3);
       if (s.isDirectory()) return;
       isFile = s.isFile();
+      sig = signature(s);
     } catch {
       this.known.delete(path3);
       this.emit("unlink", path3);
       return;
     }
     if (!isFile) return;
-    const first = !this.known.has(path3);
-    this.known.add(path3);
-    this.emit(renamed && first ? "add" : "change", path3);
+    const prev = this.known.get(path3);
+    if (prev === sig) return;
+    this.known.set(path3, sig);
+    this.emit(renamed && prev === void 0 ? "add" : "change", path3);
   }
 };
+function signature(s) {
+  return `${Math.trunc(s.mtimeMs)}:${s.size}:${Math.trunc(s.ctimeMs)}`;
+}
 
 // src/engine.ts
 init_generalize_graph();
@@ -79756,6 +80014,47 @@ async function chat(req) {
 init_src11();
 init_src6();
 init_session_registry();
+
+// src/snapshot-reuse.ts
+import { readFileSync as readFileSync18, renameSync as renameSync3, statSync as statSync8, writeFileSync as writeFileSync14 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname11, join as join22 } from "node:path";
+function snapshotReusable(held, want) {
+  return held !== null && held.key === want.key && held.atCommit === want.atCommit && held.workingFile === want.workingFile;
+}
+var codeIdentityMemo;
+function snapshotCodeIdentity(version3) {
+  if (codeIdentityMemo === void 0) {
+    let built = "unknown";
+    try {
+      built = String(statSync8(fileURLToPath2(import.meta.url)).mtimeMs);
+    } catch {
+    }
+    codeIdentityMemo = `${version3}@${built}`;
+  }
+  return codeIdentityMemo;
+}
+function heldSnapshotPath(configDir) {
+  return join22(configDir, "snapshot-held.json");
+}
+function loadHeldSnapshot(path3) {
+  try {
+    const held = JSON.parse(readFileSync18(path3, "utf8"));
+    return typeof held?.key === "string" && typeof held.at === "number" ? held : null;
+  } catch {
+    return null;
+  }
+}
+function saveHeldSnapshot(path3, held) {
+  try {
+    const tmp = join22(dirname11(path3), `.${process.pid}.snapshot-held.tmp`);
+    writeFileSync14(tmp, JSON.stringify(held));
+    renameSync3(tmp, path3);
+  } catch {
+  }
+}
+
+// src/engine.ts
 init_recall_signal();
 
 // src/subagent-state.ts
@@ -79944,8 +80243,8 @@ init_review2();
 
 // src/turn.ts
 init_checkout_root();
-import { closeSync as closeSync2, existsSync as existsSync19, fstatSync, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, realpathSync as realpathSync2, statSync as statSync8 } from "node:fs";
-import { basename as basename6, delimiter, dirname as dirname11, join as join22, normalize as normalize3 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync19, fstatSync, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, realpathSync as realpathSync2, statSync as statSync9 } from "node:fs";
+import { basename as basename6, delimiter, dirname as dirname12, join as join23, normalize as normalize3 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { createHash as createHash16 } from "node:crypto";
 function completeJsonlPrefix(buf) {
@@ -80333,7 +80632,7 @@ function turnsSince(turns, mark) {
   return at >= 0 ? turns.slice(at + 1) : turns;
 }
 function claudeProjectDir(cwd, home = homedir4()) {
-  return join22(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
+  return join23(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
 }
 function recentTranscripts(cwd, opts = {}) {
   const dir = claudeProjectDir(cwd, opts.home ?? homedir4());
@@ -80348,10 +80647,10 @@ function recentTranscripts(cwd, opts = {}) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path3 = join22(dir, name2);
+    const path3 = join23(dir, name2);
     let mtimeMs;
     try {
-      mtimeMs = statSync8(path3).mtimeMs;
+      mtimeMs = statSync9(path3).mtimeMs;
     } catch {
       continue;
     }
@@ -80363,7 +80662,7 @@ function recentTranscripts(cwd, opts = {}) {
 }
 function subagentTranscripts(mainTranscriptPath, sessionId) {
   if (!mainTranscriptPath || !sessionId) return [];
-  const dir = join22(dirname11(mainTranscriptPath), sessionId, "subagents");
+  const dir = join23(dirname12(mainTranscriptPath), sessionId, "subagents");
   if (!existsSync19(dir)) return [];
   let names;
   try {
@@ -80374,10 +80673,10 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path3 = join22(dir, name2);
+    const path3 = join23(dir, name2);
     let mtimeMs;
     try {
-      mtimeMs = statSync8(path3).mtimeMs;
+      mtimeMs = statSync9(path3).mtimeMs;
     } catch {
       continue;
     }
@@ -80386,15 +80685,15 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
   refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return refs;
 }
-function splitPathList(value, sep6 = delimiter) {
+function splitPathList(value, sep7 = delimiter) {
   if (!value) return [];
-  return value.split(sep6).map((d) => d.trim()).filter(Boolean).map((d) => normalize3(d));
+  return value.split(sep7).map((d) => d.trim()).filter(Boolean).map((d) => normalize3(d));
 }
 function codexSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
   for (const d of splitPathList(env2["ERRATA_CODEX_SESSIONS_DIRS"])) roots.add(d);
-  if (env2["CODEX_HOME"]) roots.add(join22(env2["CODEX_HOME"], "sessions"));
-  roots.add(join22(home, ".codex", "sessions"));
+  if (env2["CODEX_HOME"]) roots.add(join23(env2["CODEX_HOME"], "sessions"));
+  roots.add(join23(home, ".codex", "sessions"));
   return [...roots];
 }
 function readCodexRolloutIdentity(path3) {
@@ -80466,10 +80765,10 @@ function codexRolloutsForCwd(cwd, opts = {}) {
         continue;
       }
       for (const name2 of names) {
-        const full = join22(dir, name2);
+        const full = join23(dir, name2);
         let st;
         try {
-          st = statSync8(full);
+          st = statSync9(full);
         } catch {
           continue;
         }
@@ -80508,8 +80807,8 @@ function codexRolloutsForCwd(cwd, opts = {}) {
 function geminiSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
   for (const d of splitPathList(env2["ERRATA_GEMINI_SESSIONS_DIRS"])) roots.add(d);
-  if (env2["GEMINI_CLI_HOME"]) roots.add(join22(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
-  roots.add(join22(home, ".gemini", "tmp"));
+  if (env2["GEMINI_CLI_HOME"]) roots.add(join23(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
+  roots.add(join23(home, ".gemini", "tmp"));
   return [...roots];
 }
 function geminiProjectHash(cwd) {
@@ -80557,7 +80856,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       continue;
     }
     for (const slug2 of slugs) {
-      const chats = join22(root, slug2, "chats");
+      const chats = join23(root, slug2, "chats");
       let names;
       try {
         names = readdirSync7(chats);
@@ -80566,10 +80865,10 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       }
       for (const name2 of names) {
         if (!name2.startsWith("session-") || !name2.endsWith(".jsonl")) continue;
-        const full = join22(chats, name2);
+        const full = join23(chats, name2);
         let st;
         try {
-          st = statSync8(full);
+          st = statSync9(full);
         } catch {
           continue;
         }
@@ -80586,8 +80885,8 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
 function opencodeSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
   for (const d of splitPathList(env2["ERRATA_OPENCODE_SESSIONS_DIRS"])) roots.add(d);
-  if (env2["XDG_DATA_HOME"]) roots.add(join22(env2["XDG_DATA_HOME"], "opencode", "errata"));
-  roots.add(join22(home, ".local", "share", "opencode", "errata"));
+  if (env2["XDG_DATA_HOME"]) roots.add(join23(env2["XDG_DATA_HOME"], "opencode", "errata"));
+  roots.add(join23(home, ".local", "share", "opencode", "errata"));
   return [...roots];
 }
 function readOpencodeTranscriptDirectory(path3) {
@@ -80629,10 +80928,10 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
     }
     for (const name2 of names) {
       if (!name2.endsWith(".jsonl")) continue;
-      const full = join22(root, name2);
+      const full = join23(root, name2);
       let st;
       try {
-        st = statSync8(full);
+        st = statSync9(full);
       } catch {
         continue;
       }
@@ -80652,7 +80951,7 @@ init_src2();
 init_agent_signals();
 init_tool_index();
 init_src5();
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "node:fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync15 } from "node:fs";
 var NEG = /n['']t|\b(?:not|never|no|none|neither|nor|unrelated|irrelevant|would|might|could|if)\b/i;
 var CITE_GROUP_RE = /\(((?:[^()\n]|\([^()\n]*\)){1,200})\)/g;
 var HANDLE_RE2 = new RegExp(TAG_HANDLE_SOURCE, "gi");
@@ -81452,13 +81751,13 @@ function writePrimingHandles(path3, nodes, now = Date.now()) {
       entries.sort((a, b) => (b[1].seenAt ?? 0) - (a[1].seenAt ?? 0));
       entries.length = HANDLE_MAP_MAX;
     }
-    writeFileSync14(path3, JSON.stringify(Object.fromEntries(entries)));
+    writeFileSync15(path3, JSON.stringify(Object.fromEntries(entries)));
   } catch {
   }
 }
 function readPrimingHandles(path3) {
   try {
-    return JSON.parse(readFileSync18(path3, "utf8"));
+    return JSON.parse(readFileSync19(path3, "utf8"));
   } catch {
     return {};
   }
@@ -81947,8 +82246,8 @@ ${conversation}` }]
 // src/constraint-backfill.ts
 init_src5();
 init_src2();
-import { existsSync as existsSync20, readFileSync as readFileSync19, readdirSync as readdirSync8, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync20, readdirSync as readdirSync8, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join24 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var BACKFILL_VERSION = 1;
 var EMPTY = {
@@ -81962,13 +82261,13 @@ var EMPTY = {
   recoverable: 0
 };
 function markerPath(configDir) {
-  return join23(configDir, "constraint-backfill.json");
+  return join24(configDir, "constraint-backfill.json");
 }
 function alreadyDone(configDir) {
   const p = markerPath(configDir);
   if (!existsSync20(p)) return false;
   try {
-    const raw2 = JSON.parse(readFileSync19(p, "utf8"));
+    const raw2 = JSON.parse(readFileSync20(p, "utf8"));
     return raw2?.version === BACKFILL_VERSION;
   } catch {
     return false;
@@ -81988,7 +82287,7 @@ function replay(root) {
   for (const f of names) {
     let lines;
     try {
-      lines = readFileSync19(join23(dir, f), "utf8").split("\n");
+      lines = readFileSync20(join24(dir, f), "utf8").split("\n");
     } catch {
       continue;
     }
@@ -82102,7 +82401,7 @@ function backfillConstraintKind(store, opts) {
     }
   });
   try {
-    writeFileSync15(
+    writeFileSync16(
       markerPath(opts.configDir),
       JSON.stringify({ version: BACKFILL_VERSION, at: opts.now, ...report, cloudTwins: report.cloudTwins.length }, null, 2),
       "utf8"
@@ -82115,8 +82414,8 @@ function backfillConstraintKind(store, opts) {
 // src/edge-repair.ts
 init_src();
 init_src5();
-import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join25 } from "node:path";
 function citeEdgeId(from, type, to) {
   return `edge_${digest({ from, type, to })}`.slice(0, 24);
 }
@@ -82131,13 +82430,13 @@ var EMPTY2 = {
   byType: {}
 };
 function markerPath2(configDir) {
-  return join24(configDir, "edge-repair.json");
+  return join25(configDir, "edge-repair.json");
 }
 function alreadyDone2(configDir) {
   const p = markerPath2(configDir);
   if (!existsSync21(p)) return false;
   try {
-    return JSON.parse(readFileSync20(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
+    return JSON.parse(readFileSync21(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
   } catch {
     return false;
   }
@@ -82186,7 +82485,7 @@ function repairInvalidEdges(store, opts) {
   });
   store.pruneEdgeRejections(opts.now - REJECTION_RETENTION_MS);
   try {
-    writeFileSync16(
+    writeFileSync17(
       markerPath2(opts.configDir),
       JSON.stringify({ version: EDGE_REPAIR_VERSION, at: opts.now, ...report }, null, 2),
       "utf8"
@@ -82200,8 +82499,8 @@ function repairInvalidEdges(store, opts) {
 init_reconcile();
 
 // src/pass-ledger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join25 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join26 } from "node:path";
 
 // src/isolate-census.ts
 var live2 = 0;
@@ -82219,6 +82518,11 @@ function isolateCensus() {
   return { live: live2, spawnedTotal, peak };
 }
 
+// src/io-reads.ts
+function ioReadOps() {
+  return process.resourceUsage().fsRead;
+}
+
 // src/pass-ledger.ts
 var PER_KIND_MAX = 100;
 var LEVEL_TAIL_KINDS = /* @__PURE__ */ new Set(["wm-calibration"]);
@@ -82227,7 +82531,7 @@ var HOUR_MS = 36e5;
 var TRIM_EVERY = 50;
 var appendsSinceTrim = /* @__PURE__ */ new Map();
 function passLedgerPath(configDir) {
-  return join25(configDir, "pass-ledger.jsonl");
+  return join26(configDir, "pass-ledger.jsonl");
 }
 function appendPassLedger(configDir, kind, durationMs, counts) {
   const path3 = passLedgerPath(configDir);
@@ -82246,7 +82550,10 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
         arrayBuffersMB: Math.round(mem.arrayBuffers / 1048576),
         isolatesLive: census2.live,
         isolatesSpawned: census2.spawnedTotal,
-        isolatesPeak: census2.peak
+        isolatesPeak: census2.peak,
+        // Cumulative process-wide file reads (io-reads.ts): the difference
+        // between two rows is what ran between them.
+        ioReadOps: ioReadOps()
       }
     };
     appendFileSync2(path3, JSON.stringify(entry) + "\n");
@@ -82256,7 +82563,7 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       return;
     }
     appendsSinceTrim.set(path3, 0);
-    const lines = readFileSync21(path3, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync22(path3, "utf8").split("\n").filter(Boolean);
     const keptByKind = /* @__PURE__ */ new Map();
     const tailHours = /* @__PURE__ */ new Map();
     const tailFloor = Date.now() - LEVEL_TAIL_DAYS * 24 * HOUR_MS;
@@ -82284,7 +82591,7 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       kept.push(lines[i2]);
     }
     if (kept.length < lines.length) {
-      writeFileSync17(path3, kept.reverse().join("\n") + "\n");
+      writeFileSync18(path3, kept.reverse().join("\n") + "\n");
     }
   } catch {
   }
@@ -82293,7 +82600,7 @@ function readPassLedger(configDir) {
   const path3 = passLedgerPath(configDir);
   if (!existsSync22(path3)) return [];
   try {
-    return readFileSync21(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
+    return readFileSync22(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
       (e) => typeof e?.ts === "number" && typeof e?.kind === "string" && typeof e?.durationMs === "number"
     ).map((e) => ({ ...e, counts: e.counts ?? {} }));
   } catch {
@@ -82540,6 +82847,7 @@ function withHeavyPassSlot(label, fn) {
     const waited = Date.now() - queuedAt;
     waiting.delete(id);
     const startedAt = Date.now();
+    const readsAtStart = ioReadOps();
     active = { label, startedAt, waitedMs: waited };
     if (waited > QUEUE_WARN_MS) {
       console.warn(`[errata] heavy-pass slot: ${label} waited ${Math.round(waited / 1e3)}s`);
@@ -82551,7 +82859,7 @@ function withHeavyPassSlot(label, fn) {
       failed = true;
       throw err2;
     } finally {
-      recent2.push({ label, waitedMs: waited, durationMs: Date.now() - startedAt, failed });
+      recent2.push({ label, waitedMs: waited, durationMs: Date.now() - startedAt, readOps: ioReadOps() - readsAtStart, failed });
       if (recent2.length > 16) recent2.shift();
       active = null;
     }
@@ -82704,11 +83012,11 @@ init_outbox();
 init_src10();
 init_src();
 init_src2();
-import { readFileSync as readFileSync22 } from "node:fs";
-import { join as join26 } from "node:path";
+import { readFileSync as readFileSync23 } from "node:fs";
+import { join as join27 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync22(join26(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync23(join27(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -83091,9 +83399,9 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 // src/retrieval-stack.ts
 init_src();
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync23, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync24, statSync as statSync10 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 var RETRIEVAL_STACK_CAP = 24;
 var MANIFEST_SCAN_CAP = 400;
 var RUNTIME_TOKENS = /* @__PURE__ */ new Set([
@@ -83383,51 +83691,51 @@ function mavenGroupIsSelfDisclosing(name2, selfTokens) {
 function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
   const read2 = (p) => {
     try {
-      return readFileSync23(p, "utf8");
+      return readFileSync24(p, "utf8");
     } catch {
       return null;
     }
   };
   const texts = (...paths) => paths.map(read2).filter((t) => t !== null);
   const home = homedir6();
-  const npm = parseNpmrcPolicy(texts(join27(root, ".npmrc"), join27(home, ".npmrc")));
+  const npm = parseNpmrcPolicy(texts(join28(root, ".npmrc"), join28(home, ".npmrc")));
   const blocked = /* @__PURE__ */ new Set();
   if (!npm.defaultPublic) blocked.add("npm");
   if (pypiIndexIsPrivate(
     texts(
-      join27(root, "pip.conf"),
-      join27(root, "pip.ini"),
-      join27(root, "pyproject.toml"),
-      join27(root, "requirements.txt"),
-      join27(home, ".pip", "pip.conf"),
-      join27(home, ".config", "pip", "pip.conf"),
-      join27(env2["APPDATA"] ?? home, "pip", "pip.ini")
+      join28(root, "pip.conf"),
+      join28(root, "pip.ini"),
+      join28(root, "pyproject.toml"),
+      join28(root, "requirements.txt"),
+      join28(home, ".pip", "pip.conf"),
+      join28(home, ".config", "pip", "pip.conf"),
+      join28(env2["APPDATA"] ?? home, "pip", "pip.ini")
     )
   )) {
     blocked.add("pypi");
   }
   if (cargoRegistryIsPrivate(
     texts(
-      join27(root, ".cargo", "config.toml"),
-      join27(root, ".cargo", "config"),
-      join27(home, ".cargo", "config.toml"),
-      join27(home, ".cargo", "config")
+      join28(root, ".cargo", "config.toml"),
+      join28(root, ".cargo", "config"),
+      join28(home, ".cargo", "config.toml"),
+      join28(home, ".cargo", "config")
     )
   )) {
     blocked.add("cargo");
   }
   if (nugetSourcesArePrivate(
     texts(
-      join27(root, "NuGet.config"),
-      join27(root, "nuget.config"),
-      join27(root, "NuGet.Config"),
-      join27(env2["APPDATA"] ?? home, "NuGet", "NuGet.Config"),
-      join27(home, ".nuget", "NuGet", "NuGet.Config")
+      join28(root, "NuGet.config"),
+      join28(root, "nuget.config"),
+      join28(root, "NuGet.Config"),
+      join28(env2["APPDATA"] ?? home, "NuGet", "NuGet.Config"),
+      join28(home, ".nuget", "NuGet", "NuGet.Config")
     )
   )) {
     blocked.add("nuget");
   }
-  const goEnvFile = env2["GOENV"] ?? join27(env2["APPDATA"] ?? join27(home, ".config"), "go", "env");
+  const goEnvFile = env2["GOENV"] ?? join28(env2["APPDATA"] ?? join28(home, ".config"), "go", "env");
   const goEnvText = read2(goEnvFile) ?? "";
   const fromFile = ["GOPRIVATE", "GONOSUMDB", "GONOSUMCHECK"].map(
     (k) => new RegExp(`^${k}=(.*)$`, "m").exec(goEnvText)?.[1]
@@ -83438,10 +83746,10 @@ function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
     env2["GONOSUMCHECK"],
     ...fromFile
   ]);
-  const gemfiles = texts(join27(root, "Gemfile"));
+  const gemfiles = texts(join28(root, "Gemfile"));
   if (gemSourceIsPrivate(gemfiles)) blocked.add("gem");
   if (mavenReposArePrivate(
-    texts(join27(root, "pom.xml"), join27(home, ".m2", "settings.xml"))
+    texts(join28(root, "pom.xml"), join28(home, ".m2", "settings.xml"))
   )) {
     blocked.add("maven");
   }
@@ -83608,10 +83916,10 @@ function readDirectDependencies(root) {
   const familiesSeen = /* @__PURE__ */ new Set();
   for (const c of LOCKFILES) {
     if (familiesSeen.has(c.family)) continue;
-    const p = join27(root, c.file);
+    const p = join28(root, c.file);
     if (!existsSync23(p)) continue;
     try {
-      const s = statSync9(p);
+      const s = statSync10(p);
       stamps.push(`${c.file}:${s.mtimeMs}:${s.size}`);
     } catch {
       continue;
@@ -83629,7 +83937,7 @@ function readDirectDependencies(root) {
   const direct = [];
   for (const { c, path: path3 } of found) {
     try {
-      direct.push(...c.parse(readFileSync23(path3, "utf8")).direct ?? []);
+      direct.push(...c.parse(readFileSync24(path3, "utf8")).direct ?? []);
     } catch {
     }
   }
@@ -83672,14 +83980,14 @@ function manifestPaths(root) {
     "project.godot"
   ];
   return {
-    paths: ROOT_MANIFESTS.filter((f) => existsSync23(join27(root, f))),
+    paths: ROOT_MANIFESTS.filter((f) => existsSync23(join28(root, f))),
     tracked: false,
     truncated: false
   };
 }
 var WORKSPACE_MARKERS = ["pnpm-workspace.yaml", "lerna.json", "go.work", "settings.gradle", "settings.gradle.kts"];
 function rootDeclaresWorkspace(root, texts) {
-  if (WORKSPACE_MARKERS.some((f) => existsSync23(join27(root, f)))) return true;
+  if (WORKSPACE_MARKERS.some((f) => existsSync23(join28(root, f)))) return true;
   return /"workspaces"\s*:/.test(texts.get("package.json") ?? "") || /<modules>/.test(texts.get("pom.xml") ?? "") || /^\s*\[workspace\]/m.test(texts.get("Cargo.toml") ?? "");
 }
 var EMPTY_SCAN = { deps: [], self: [], complete: true };
@@ -83693,11 +84001,11 @@ function scanManifests(root) {
   const texts = /* @__PURE__ */ new Map();
   const stamps = [];
   for (const rel of paths) {
-    const abs = join27(root, rel);
+    const abs = join28(root, rel);
     try {
-      const s = statSync9(abs);
+      const s = statSync10(abs);
       stamps.push(`${rel}:${s.mtimeMs}:${s.size}`);
-      texts.set(rel, readFileSync23(abs, "utf8"));
+      texts.set(rel, readFileSync24(abs, "utf8"));
     } catch {
     }
   }
@@ -83733,22 +84041,22 @@ function readRetrievalInputs(root, repoLocator) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync24, readFileSync as readFileSync24, watch as fsWatch } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync25, watch as fsWatch } from "node:fs";
+import { join as join29 } from "node:path";
 function readFirstLine(path3) {
   try {
-    return readFileSync24(path3, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync25(path3, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join28(gitDir, "HEAD"));
+  const head2 = readFirstLine(join29(gitDir, "HEAD"));
   const m = head2 ? /^ref:\s*refs\/heads\/(.+)$/.exec(head2) : null;
   const branch = m ? m[1] : null;
   let sha2 = null;
   if (branch) {
-    sha2 = readFirstLine(join28(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join29(gitDir, "refs", "heads", branch));
     if (!sha2) sha2 = shaFromPackedRefs(gitDir, `refs/heads/${branch}`);
   } else if (head2 && /^[0-9a-f]{7,40}$/i.test(head2)) {
     sha2 = head2;
@@ -83756,13 +84064,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync24(join28(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync24(join28(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync24(join29(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync24(join29(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync24(join28(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync25(join29(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -83796,7 +84104,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync24(join28(gitDir, "index.lock"))) {
+      if (existsSync24(join29(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -83807,7 +84115,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join28(gitDir, sub);
+    const p = join29(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -84037,8 +84345,8 @@ var TelemetryRecorder = class {
 };
 
 // src/file-activity.ts
-import { readFileSync as readFileSync26 } from "node:fs";
-import { join as join30 } from "node:path";
+import { readFileSync as readFileSync27 } from "node:fs";
+import { join as join31 } from "node:path";
 import { createHash as createHash17 } from "node:crypto";
 
 // ../../packages/privacy/src/patterns/credentials.ts
@@ -84790,8 +85098,8 @@ init_git_remote();
 // src/history-bundle.ts
 init_src();
 import { execFile as execFile2 } from "node:child_process";
-import { readFileSync as readFileSync25 } from "node:fs";
-import { join as join29 } from "node:path";
+import { readFileSync as readFileSync26 } from "node:fs";
+import { join as join30 } from "node:path";
 var DEFAULT_MAX_TOKENS = 6e3;
 var FILE_LIST_CAP = 60;
 var DIFF_FILE_CAP = 40;
@@ -84830,7 +85138,7 @@ function pathAllowedByFloor(path3) {
 function loadRepoIgnore(root, extraPatterns = []) {
   let source = "";
   try {
-    source = readFileSync25(join29(root, ".errataignore"), "utf8");
+    source = readFileSync26(join30(root, ".errataignore"), "utf8");
   } catch {
     source = "";
   }
@@ -85005,24 +85313,28 @@ function headerPaths(diff) {
   }
   return out2.filter((p) => p !== "/dev/null");
 }
-function git2(repoDir, args2) {
+var GIT_MAX_BUFFER = 64 * 1024 * 1024;
+function git2(repoDir, args2, maxBuffer = GIT_MAX_BUFFER) {
   return new Promise((resolve10, reject) => {
     execFile2(
       "git",
       ["-C", repoDir, ...args2],
-      { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, windowsHide: true },
+      { encoding: "utf8", maxBuffer, windowsHide: true },
       (err2, stdout) => err2 ? reject(err2) : resolve10(stdout)
     );
   });
 }
-async function unitDiff(root, unit, paths) {
+async function unitDiff(root, unit, paths, maxChars = GIT_MAX_BUFFER) {
   if (paths.length === 0) return "";
   const common = ["--unified=3", "--no-color", "-M", "--no-ext-diff"];
   const firstParent = unit.parents[0];
-  if (unit.isMerge && firstParent) {
-    return git2(root, ["diff", ...common, firstParent, unit.sha, "--", ...paths]);
+  const args2 = unit.isMerge && firstParent ? ["diff", ...common, firstParent, unit.sha, "--", ...paths] : ["show", "--format=", ...common, unit.sha, "--", ...paths];
+  try {
+    return await git2(root, args2, maxChars);
+  } catch (err2) {
+    if (err2.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" && maxChars < GIT_MAX_BUFFER) return null;
+    throw err2;
   }
-  return git2(root, ["show", "--format=", ...common, unit.sha, "--", ...paths]);
 }
 function fileRow(token, f) {
   const tag = f.binary ? "bin" : `+${f.adds}/-${f.dels}`;
@@ -85059,7 +85371,9 @@ async function buildUnitBundle(root, unit, opts = {}) {
   const sourceFiles = ordered.filter(isSourceFile);
   const diffPaths = sourceFiles.slice(0, DIFF_FILE_CAP).map((f) => f.path);
   if (sourceFiles.length > DIFF_FILE_CAP) truncated = true;
-  const rawDiff = await unitDiff(root, unit, diffPaths);
+  const cappedDiff = await unitDiff(root, unit, diffPaths, opts.maxRawDiffChars);
+  if (cappedDiff === null) truncated = true;
+  const rawDiff = cappedDiff ?? "";
   for (const p of headerPaths(rawDiff)) tokens.token(p);
   const narrativeRaw = opts.narrative ?? [unit.subject.trim(), stripTrailers(unit.body)].filter((s) => s.length > 0).join("\n\n");
   const n = scrubHistoryText(tokens.apply(stripTrailers(narrativeRaw)));
@@ -85129,7 +85443,7 @@ function readActivityBranch(root) {
   try {
     const gitDir = resolveGitDir(root);
     if (!gitDir) return null;
-    const head2 = readFileSync26(join30(gitDir, "HEAD"), "utf8").trim();
+    const head2 = readFileSync27(join31(gitDir, "HEAD"), "utf8").trim();
     const branch = head2.startsWith("ref: refs/heads/") ? head2.slice(16) : /^[a-f0-9]{40,64}$/i.test(head2) ? "HEAD" : null;
     return branch && branch.length <= 256 && !/[\x00-\x1f\x7f]/.test(branch) ? branch : null;
   } catch {
@@ -85288,19 +85602,19 @@ var FileActivityReporter = class {
 import {
   existsSync as existsSync25,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync27,
+  readFileSync as readFileSync28,
   readdirSync as readdirSync9,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync18
+  writeFileSync as writeFileSync19
 } from "node:fs";
-import { basename as basename7, join as join31 } from "node:path";
+import { basename as basename7, join as join32 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
   if (!existsSync25(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync27(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync28(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -85324,7 +85638,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync18(join31(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync19(join32(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -85337,7 +85651,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync18(join31(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync19(join32(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -85351,13 +85665,13 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename7(f))) continue;
     try {
-      unlinkSync4(join31(paths.skillsDir, f));
+      unlinkSync4(join32(paths.skillsDir, f));
       pruned++;
     } catch {
     }
   }
   rows.sort((a, b) => a.id.localeCompare(b.id));
-  writeFileSync18(
+  writeFileSync19(
     paths.skillsManifest,
     JSON.stringify({ generatedAt: Date.now(), skills: rows }, null, 2),
     "utf8"
@@ -85372,19 +85686,19 @@ import {
   existsSync as existsSync26,
   lstatSync,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   readdirSync as readdirSync10,
   rmSync as rmSync3,
   symlinkSync,
-  writeFileSync as writeFileSync19
+  writeFileSync as writeFileSync20
 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join32(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join33(".claude", "skills") },
   // Cursor adopted the standard; its exact project dir is still moving — kept
   // best-effort and gated on `.cursor/` presence so we never create it blind.
-  { configDir: ".cursor", skillsDir: join32(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join33(".cursor", "skills") }
 ];
 function skillSlug(title, id) {
   const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "skill";
@@ -85434,7 +85748,7 @@ function reconcileNamespaced(dir, keep) {
   for (const name2 of readdirSync10(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync3(join32(dir, name2), { recursive: true, force: true });
+      rmSync3(join33(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -85464,7 +85778,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join32(root, ".agents", "skills");
+  const agentsSkillsDir = join33(root, ".agents", "skills");
   mkdirSync8(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -85472,7 +85786,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync28(s.bodyPath, "utf8");
+      body2 = readFileSync29(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -85481,9 +85795,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync8(join32(agentsSkillsDir, slug2), { recursive: true });
-    writeFileSync19(
-      join32(agentsSkillsDir, slug2, "SKILL.md"),
+    mkdirSync8(join33(agentsSkillsDir, slug2), { recursive: true });
+    writeFileSync20(
+      join33(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -85492,11 +85806,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync26(join32(root, h.configDir))) continue;
-    const dir = join32(root, h.skillsDir);
+    if (!existsSync26(join33(root, h.configDir))) continue;
+    const dir = join33(root, h.skillsDir);
     mkdirSync8(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join32(dir, slug2), join32(agentsSkillsDir, slug2));
+      linkOrCopy(join33(dir, slug2), join33(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -85507,13 +85821,13 @@ function emitAndProjectSkills(root, skills) {
 function emitInputsFromManifest(erretaDir, manifestPath) {
   if (!existsSync26(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync28(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync29(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
       layer: s.layer ?? "technique",
       confidence: s.confidence ?? 0,
-      bodyPath: join32(erretaDir, s.file)
+      bodyPath: join33(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -85527,17 +85841,17 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path3 = join32(root, ".gitignore");
+  const path3 = join33(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync26(path3) ? readFileSync28(path3, "utf8") : "";
+    current = existsSync26(path3) ? readFileSync29(path3, "utf8") : "";
   } catch {
     return;
   }
   if (current.includes(GITIGNORE_MARK)) return;
   const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
   try {
-    writeFileSync19(path3, `${current}${prefix}
+    writeFileSync20(path3, `${current}${prefix}
 ${GITIGNORE_LINES.join("\n")}
 `, "utf8");
   } catch {
@@ -85633,18 +85947,18 @@ init_paths();
 init_profile2();
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync29, renameSync as renameSync3, writeFileSync as writeFileSync20 } from "node:fs";
-import { dirname as dirname12, join as join33 } from "node:path";
+import { readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname13, join as join34 } from "node:path";
 var WITNESS_QUEUE_CAP = 500;
 var WITNESS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var WITNESS_MAX_ATTEMPTS = 5;
 function witnessQueuePath(workspaceConfigDir) {
-  return join33(workspaceConfigDir, "witness-queue.json");
+  return join34(workspaceConfigDir, "witness-queue.json");
 }
 function loadWitnessQueueWithLosses(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync29(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync30(path3, "utf8"));
   } catch (err2) {
     const absent = err2?.code === "ENOENT";
     return { queue: [], fileUnreadable: !absent, malformedEntries: 0 };
@@ -85657,9 +85971,9 @@ function loadWitnessQueueWithLosses(path3) {
 }
 function saveWitnessQueue(path3, queue) {
   try {
-    const tmp = join33(dirname12(path3), `.${Date.now()}.witness-queue.tmp`);
-    writeFileSync20(tmp, JSON.stringify(queue), "utf8");
-    renameSync3(tmp, path3);
+    const tmp = join34(dirname13(path3), `.${Date.now()}.witness-queue.tmp`);
+    writeFileSync21(tmp, JSON.stringify(queue), "utf8");
+    renameSync4(tmp, path3);
   } catch {
   }
 }
@@ -85967,8 +86281,8 @@ function maybeFlushDigests() {
 
 // src/liveness-watch.ts
 init_src5();
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join35 } from "node:path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync23 } from "node:fs";
+import { join as join36 } from "node:path";
 
 // src/loop-lag.ts
 var HEARTBEAT_MS = 500;
@@ -85980,13 +86294,14 @@ var recent3 = [];
 function markPass(name2) {
   const id = nextPassId++;
   const startedAt = Date.now();
+  const readsAtStart = ioReadOps();
   active2.set(id, { name: name2, startedAt });
   let ended = false;
   return () => {
     if (ended) return;
     ended = true;
     active2.delete(id);
-    recent3.unshift({ name: name2, ms: Date.now() - startedAt, endedAt: Date.now() });
+    recent3.unshift({ name: name2, ms: Date.now() - startedAt, endedAt: Date.now(), readOps: ioReadOps() - readsAtStart });
     if (recent3.length > RECENT_PASS_LIMIT) recent3.pop();
   };
 }
@@ -86099,11 +86414,11 @@ function watchCensusLine(c = watchCensus(), now = Date.now()) {
 var LIVENESS_WATCH_INTERVAL_MS = 60 * 60 * 1e3;
 var ALARM_RENOTIFY_MS = 24 * 60 * 60 * 1e3;
 function alarmStatePath(configDir) {
-  return join35(configDir, "liveness-alarms.json");
+  return join36(configDir, "liveness-alarms.json");
 }
 function loadAlarmState(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync31(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync32(path3, "utf8"));
     return new Map(Object.entries(raw2).filter((e) => typeof e[1] === "number"));
   } catch {
     return /* @__PURE__ */ new Map();
@@ -86111,7 +86426,7 @@ function loadAlarmState(path3) {
 }
 function saveAlarmState(path3, state) {
   try {
-    writeFileSync22(path3, JSON.stringify(Object.fromEntries(state)));
+    writeFileSync23(path3, JSON.stringify(Object.fromEntries(state)));
   } catch {
   }
 }
@@ -86141,12 +86456,15 @@ function toastLivenessAlarms(gate, workspace, alarms, deliver, nowMs) {
   return fresh;
 }
 function createLivenessWatch(deps) {
-  let lastRunAt = 0;
+  let lastRunAt = null;
   let running = false;
   const lastAlarmedAt = loadAlarmState(alarmStatePath(deps.configDir));
   return {
     async maybeRun(nowMs = Date.now()) {
-      if (running || nowMs - lastRunAt < LIVENESS_WATCH_INTERVAL_MS) return null;
+      if (running) return null;
+      lastRunAt ??= summarizePassLedger(deps.configDir).get("liveness-watch")?.lastTs ?? 0;
+      if (lastRunAt > nowMs) lastRunAt = 0;
+      if (nowMs - lastRunAt < LIVENESS_WATCH_INTERVAL_MS) return null;
       lastRunAt = nowMs;
       running = true;
       try {
@@ -86238,6 +86556,25 @@ function runWorkspaceMaintenance(store, workspaceId2) {
   };
 }
 
+// src/pass-inputs.ts
+function passInputs(store, pass, scopes) {
+  const key = `pass-inputs:${pass}`;
+  const seq = store.changeSeq?.(scopes);
+  let held = null;
+  try {
+    held = JSON.parse(store.getMeta?.(key) ?? "null");
+  } catch {
+    held = null;
+  }
+  return {
+    unchanged: seq !== void 0 && held !== null && held.seq === seq,
+    last: held?.result ?? null,
+    complete(result) {
+      if (seq !== void 0) store.setMeta?.(key, JSON.stringify({ seq, result }));
+    }
+  };
+}
+
 // src/watch-breaker.ts
 function numEnv3(key, fallback) {
   const n = Number(process.env[key]);
@@ -86339,7 +86676,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4430" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.22-dev.4530" : "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;
@@ -86351,8 +86688,8 @@ var CODEX_SWEEP_LOOKBACK_MS = 10 * 6e4;
 function appendIdentityAudit(path3, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync28(path3) && statSync10(path3).size >= IDENTITY_AUDIT_MAX_BYTES) {
-      renameSync4(path3, `${path3}.1`);
+    if (existsSync28(path3) && statSync11(path3).size >= IDENTITY_AUDIT_MAX_BYTES) {
+      renameSync5(path3, `${path3}.1`);
     }
     appendFileSync4(path3, line);
   } catch {
@@ -86361,7 +86698,7 @@ function appendIdentityAudit(path3, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync32(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync33(path3, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -86371,7 +86708,7 @@ function loadTurnCursors(path3) {
 }
 function loadTurnOffsets(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync32(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync33(path3, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off2 = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -86387,7 +86724,7 @@ function saveTurnCursors(path3, cursors, offsets) {
     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 };
-    writeFileSync23(path3, JSON.stringify(merged), "utf8");
+    writeFileSync24(path3, JSON.stringify(merged), "utf8");
   } catch {
   }
 }
@@ -86409,7 +86746,7 @@ function gitSourceWatchTargets(root) {
         ["-C", root, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"],
         { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
       );
-      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join36(root, d) + sep4));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join37(root, d) + sep5));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -86421,19 +86758,19 @@ function gitSourceWatchTargets(root) {
         if (!f.startsWith(prefix)) continue;
         const rest2 = f.slice(prefix.length);
         if (rest2.includes("/")) children.add(dir === "" ? rest2.slice(0, rest2.indexOf("/")) : dir + "/" + rest2.slice(0, rest2.indexOf("/")));
-        else targets.add(join36(root, f));
+        else targets.add(join37(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join36(root, c) + sep4)) continue;
+        if (IGNORED_PATH.test(join37(root, c) + sep5)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join36(root, c));
+        else targets.add(join37(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync11(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join36(root, String(e.name)) + sep4)).map((e) => join36(root, String(e.name)));
+  return readdirSync11(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join37(root, String(e.name)) + sep5)).map((e) => join37(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -86489,6 +86826,7 @@ function createWorkspaceEngine(opts) {
   let watcher = null;
   let watchBreaker = null;
   let lastActivityTs = Date.now();
+  let storeReconciled = !!opts.skipWatchers;
   let stopGit = null;
   let fsReindex;
   let stopping = false;
@@ -86525,7 +86863,7 @@ function createWorkspaceEngine(opts) {
       }
       let size = 0;
       try {
-        size = statSync10(path3).size;
+        size = statSync11(path3).size;
       } catch {
       }
       lastActivityTs = Date.now();
@@ -86572,7 +86910,7 @@ function createWorkspaceEngine(opts) {
     fsReindex = createCoalescedFilePass(REINDEX_DEBOUNCE_MS, async (changed) => {
       if (stopping) return;
       const t = Date.now();
-      const relChanged = changed.map((p) => relative7(opts.workspaceRoot, p).split(sep4).join("/"));
+      const relChanged = changed.map((p) => relative6(opts.workspaceRoot, p).split(sep5).join("/"));
       const causal = causalBuffer.correlate(relChanged, t) ?? void 0;
       await runReindexPass(
         `fs-reindex:${profile.name} (${changed.length} files)`,
@@ -86632,7 +86970,7 @@ function createWorkspaceEngine(opts) {
       const srcPaths = diff.changedPaths.filter((p) => /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i.test(p));
       let episodeId2;
       if (srcPaths.length > 0) {
-        const abs = srcPaths.map((p) => join36(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join37(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -86668,7 +87006,7 @@ function createWorkspaceEngine(opts) {
         `[errata] git: ${ev.kind} ${ev.newSha.slice(0, 7)} by ${meta3.authorName} \u2014 ${diff.changedPaths.length} file(s), ${diff.renames.length} rename(s)`
       );
     };
-    const gitDir = join36(opts.workspaceRoot, ".git");
+    const gitDir = join37(opts.workspaceRoot, ".git");
     if (existsSync28(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
@@ -86678,6 +87016,10 @@ function createWorkspaceEngine(opts) {
     }
     setImmediate(() => {
       const reconcileStartedAt = Date.now();
+      try {
+        store.pruneChangeLog?.();
+      } catch {
+      }
       const reconcile = passWorker ? passWorker.reconcile().catch(() => reconcileStaleFiles(store, opts.workspaceRoot, profile.id)) : reconcileStaleFiles(store, opts.workspaceRoot, profile.id);
       void reconcile.then((n) => {
         appendPassLedger(paths.configDir, "reconcile", Date.now() - reconcileStartedAt, {
@@ -86712,6 +87054,7 @@ function createWorkspaceEngine(opts) {
         } catch (err2) {
           console.warn("[errata] orphan reap failed:", err2 instanceof Error ? err2.message : err2);
         }
+        storeReconciled = true;
       });
     });
   }
@@ -86725,7 +87068,7 @@ function createWorkspaceEngine(opts) {
     },
     onAlarms: (alarms) => {
       toastLivenessAlarms(
-        sharedAlarmToastGate(join36(globalDir(), "liveness-toasts.json")),
+        sharedAlarmToastGate(join37(globalDir(), "liveness-toasts.json")),
         { root: opts.workspaceRoot, name: profile.name },
         alarms,
         (body2, key) => notifyEvent("mechanism-stalled", body2, { key }),
@@ -86742,7 +87085,7 @@ function createWorkspaceEngine(opts) {
   let subagentBase = null;
   let subagentBaseVersion = 0;
   const subagentRenders = /* @__PURE__ */ new Map();
-  const sessions = createSessionRegistry({ originsPath: join36(paths.configDir, "session-origins.json") });
+  const sessions = createSessionRegistry({ originsPath: join37(paths.configDir, "session-origins.json") });
   const sessionRenders = /* @__PURE__ */ new Map();
   const selfCiteSkipsBySession = /* @__PURE__ */ new Map();
   const toolRuns = createToolRunState();
@@ -86756,6 +87099,7 @@ function createWorkspaceEngine(opts) {
   let intentRemoteInFlight = false;
   let ctxRefreshInFlight = false;
   let ctxRefreshQueued = false;
+  let lastWorkerSnapshot = null;
   let lastSelfCiteSkips = 0;
   const refreshContextNow = () => {
     void refreshContextAsync().catch((err2) => {
@@ -86834,26 +87178,35 @@ function createWorkspaceEngine(opts) {
     const elicit = isEdgeElicitationEnabled();
     const snapOpts = {
       profile,
-      atCommit: readGitRefState(join36(opts.workspaceRoot, ".git")).sha ?? void 0,
+      atCommit: readGitRefState(join37(opts.workspaceRoot, ".git")).sha ?? void 0,
       reviewCount: pendingCount(paths),
       reviewUiUrl: opts.reviewUrl(),
       workingFile: workingFiles.mostRecent() ?? void 0,
       skills: readSkillManifest(paths.skillsManifest),
       ...lastSelfCiteSkips > 0 ? { selfCiteSkips: lastSelfCiteSkips } : {}
     };
-    const prebuilt = passWorker ? await passWorker.snapshot(snapOpts).catch((err2) => {
+    const changes = store.changeSeq ? store.changeSeq() - store.changeSeq([EXPOSURE_SCOPE]) : store.changeStamp();
+    const { id, name: name2, stack, languages, domains, goals } = snapOpts.profile;
+    const snapshotKey = `${snapshotCodeIdentity(DAEMON_VERSION)}|${changes}|${JSON.stringify({ ...snapOpts, profile: { id, name: name2, stack, languages, domains, goals } })}`;
+    lastWorkerSnapshot ??= loadHeldSnapshot(heldSnapshotPath(paths.configDir));
+    const held = lastWorkerSnapshot;
+    const prebuilt = snapshotReusable(held, { key: snapshotKey, atCommit: snapOpts.atCommit, workingFile: snapOpts.workingFile }) ? structuredClone(held.snapshot) : passWorker ? await passWorker.snapshot(snapOpts).then((snapshot2) => {
+      lastWorkerSnapshot = { key: snapshotKey, at: Date.now(), atCommit: snapOpts.atCommit, workingFile: snapOpts.workingFile, snapshot: structuredClone(snapshot2) };
+      saveHeldSnapshot(heldSnapshotPath(paths.configDir), lastWorkerSnapshot);
+      return snapshot2;
+    }).catch((err2) => {
       console.warn(
         `[errata] snapshot worker failed \u2014 rendering INLINE on main:`,
         err2 instanceof Error ? err2.message : err2
       );
       return null;
     }) : null;
-    if (snapOpts.atCommit !== (readGitRefState(join36(opts.workspaceRoot, ".git")).sha ?? void 0)) {
+    if (snapOpts.atCommit !== (readGitRefState(join37(opts.workspaceRoot, ".git")).sha ?? void 0)) {
       contextDirty = true;
       return;
     }
     const doneRender = markPass(`${prebuilt ? "context-render" : "context-render-inline"}:${profile.name}`);
-    const base = prebuilt ?? buildSnapshot({ store, ...snapOpts });
+    const base = freshenRecentBands(prebuilt ?? buildSnapshot({ store, ...snapOpts }), (id2) => store.getNode(id2));
     subagentBase = structuredClone(base);
     subagentBaseVersion++;
     const sharedSnapshot = scopeSnapshot(base, (n) => !isQuarantined(n, sessions));
@@ -86894,10 +87247,10 @@ function createWorkspaceEngine(opts) {
     } catch (err2) {
       console.warn("[errata] context card failed:", err2.message?.slice(0, 120));
     }
-    const target = join36(opts.workspaceRoot, "AGENTS.md");
+    const target = join37(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join36(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join37(paths.configDir, "priming-handles.json"), [
         ...snapshot.recentProblems.map((r) => r.node),
         // Resolved-band handles: the ✓ problem AND its Solution are citable
         // (a fix tag on an already-resolved problem no-ops idempotently; the
@@ -87205,8 +87558,8 @@ function createWorkspaceEngine(opts) {
     const cached2 = subagentRenders.get(a.agentId);
     if (cached2?.key === key) return cached2.block;
     const elicit = isEdgeElicitationEnabled();
-    const handlesPath = join36(paths.configDir, "priming-handles.json");
-    const atCommit = readGitRefState(join36(opts.workspaceRoot, ".git")).sha ?? void 0;
+    const handlesPath = join37(paths.configDir, "priming-handles.json");
+    const atCommit = readGitRefState(join37(opts.workspaceRoot, ".git")).sha ?? void 0;
     const block = renderSubagentBlock({
       store,
       entry,
@@ -87260,7 +87613,7 @@ function createWorkspaceEngine(opts) {
     const cached2 = sessionRenders.get(sessionId);
     if (cached2?.key === key) return cached2.block;
     const elicit = isEdgeElicitationEnabled();
-    const atCommit = readGitRefState(join36(opts.workspaceRoot, ".git")).sha ?? void 0;
+    const atCommit = readGitRefState(join37(opts.workspaceRoot, ".git")).sha ?? void 0;
     const scoped = scopeSnapshot(structuredClone(subagentBase), (n) => !hiddenFrom(n, sessionId, sessions, now));
     delete scoped.workingFile;
     if (workingFile) {
@@ -87301,7 +87654,7 @@ function createWorkspaceEngine(opts) {
       ]
     };
     if (elicit && block.handleNodes.length) {
-      writePrimingHandles(join36(paths.configDir, "priming-handles.json"), block.handleNodes);
+      writePrimingHandles(join37(paths.configDir, "priming-handles.json"), block.handleNodes);
     }
     sessionRenders.delete(sessionId);
     sessionRenders.set(sessionId, { key, block });
@@ -87361,7 +87714,7 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join36(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = join37(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
   const readLosses = { parseFailures: 0, ioFailures: 0, bytesUnreachable: 0, sliceGuardHits: 0 };
@@ -87423,7 +87776,7 @@ function createWorkspaceEngine(opts) {
     let processedTurns = 0;
     const seqAtStart = store.currentIngestSeq();
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join36(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join37(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -87634,7 +87987,7 @@ function createWorkspaceEngine(opts) {
             let anchorReadFailed = false;
             if (p.location) {
               try {
-                fileText = readFileSync32(join36(opts.workspaceRoot, p.location.path), "utf8");
+                fileText = readFileSync33(join37(opts.workspaceRoot, p.location.path), "utf8");
               } catch {
                 anchorReadFailed = true;
               }
@@ -87796,10 +88149,10 @@ function createWorkspaceEngine(opts) {
                 let enclosing = {};
                 if (p.location?.line !== void 0) {
                   try {
-                    const headSha = readGitRefState(join36(opts.workspaceRoot, ".git")).sha ?? void 0;
+                    const headSha = readGitRefState(join37(opts.workspaceRoot, ".git")).sha ?? void 0;
                     enclosing = {
                       line: p.location.line,
-                      fileText: readFileSync32(join36(opts.workspaceRoot, anchorPath), "utf8"),
+                      fileText: readFileSync33(join37(opts.workspaceRoot, anchorPath), "utf8"),
                       ...headSha ? { headSha } : {}
                     };
                   } catch {
@@ -88638,7 +88991,7 @@ B: ${b}`,
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join36(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join37(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -88674,6 +89027,7 @@ B: ${b}`,
     lastActivityAt() {
       return lastActivityTs;
     },
+    storeReconciled: () => storeReconciled,
     quarantinedSessions: () => sessions.originSessions(),
     markContextDirty() {
       contextDirty = true;
@@ -88734,7 +89088,46 @@ B: ${b}`,
       return report;
     },
     async semanticMaintenance() {
-      const { report, hintUpgrade, seqAdvanced, calibration, calibrationMs } = passWorker ? await passWorker.semanticMaintenance() : runWorkspaceMaintenance(store, profile.id);
+      const inputs = passInputs(store, "semantic-maintenance");
+      if (inputs.unchanged && inputs.last) {
+        const last = inputs.last;
+        const report2 = {
+          ...last.report,
+          designResolved: 0,
+          revisitsCleared: 0,
+          fixCandidatesSettled: 0,
+          claimsEvaluated: 0,
+          claimsDerived: 0,
+          durationMs: 0,
+          fixCandidates: { ...last.report.fixCandidates, answered: 0, ignored: 0, unsubstantiated: 0 }
+        };
+        appendPassLedger(paths.configDir, "semantic-maintenance", 0, {
+          revisitsCleared: 0,
+          revisitsStanding: report2.revisitsStanding,
+          fixCandidatesSettled: 0,
+          fixCandidatesAnswered: 0,
+          fixCandidatesIgnored: 0,
+          fixCandidatesUnsubstantiated: 0,
+          fixCandidatesStanding: report2.fixCandidates.standing,
+          designResolved: 0,
+          claimsEvaluated: 0,
+          seqAdvanced: 0,
+          anchorHintsUpgraded: 0,
+          anchorHintsStanding: last.hintUpgrade.standing,
+          anchorHintsUnresolvable: last.hintUpgrade.unresolvable,
+          anchorHintsBlocked: last.hintUpgrade.blocked,
+          // Telemetry, not a counter: a descriptor must not gate on it.
+          inputsUnchanged: 1
+        });
+        if (last.calibration) {
+          appendPassLedger(paths.configDir, "wm-calibration", 0, { ...last.calibration, inputsUnchanged: 1 });
+        }
+        await livenessWatch.maybeRun();
+        return report2;
+      }
+      const result = passWorker ? await passWorker.semanticMaintenance() : runWorkspaceMaintenance(store, profile.id);
+      inputs.complete(result);
+      const { report, hintUpgrade, seqAdvanced, calibration, calibrationMs } = result;
       appendPassLedger(paths.configDir, "semantic-maintenance", report.durationMs, {
         revisitsCleared: report.revisitsCleared,
         revisitsStanding: report.revisitsStanding,
@@ -89081,7 +89474,7 @@ async function startDaemon(opts) {
     reviewUrl: () => webUiUrl + "/review"
   });
   const writeLockFile = (url2) => {
-    writeFileSync24(
+    writeFileSync25(
       engine.paths.daemonLock,
       daemonLockPayload({ pid: process.pid, webUiUrl: url2, processStartedAt, version: DAEMON_VERSION }),
       "utf8"
@@ -89330,8 +89723,8 @@ async function linkRegisteredWorkspaces(cfg, loggedInProfile = cfg.activeInstall
 }
 
 // src/edge-park.ts
-import { readFileSync as readFileSync33, renameSync as renameSync5, writeFileSync as writeFileSync25 } from "node:fs";
-import { dirname as dirname13, join as join37 } from "node:path";
+import { readFileSync as readFileSync34, renameSync as renameSync6, writeFileSync as writeFileSync26 } from "node:fs";
+import { dirname as dirname14, join as join38 } from "node:path";
 var EDGE_PARK_CAP = 2e3;
 var EDGE_PARK_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var EDGE_PARK_MAX_ATTEMPTS = 6;
@@ -89346,12 +89739,12 @@ function wireEdgeKey(from, type, to) {
   return JSON.stringify([from, type, to]);
 }
 function edgeParkPath(workspaceConfigDir, destinationKey) {
-  return join37(workspaceConfigDir, `edge-park.${destinationKey.slice(0, 16)}.json`);
+  return join38(workspaceConfigDir, `edge-park.${destinationKey.slice(0, 16)}.json`);
 }
 function loadEdgePark(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync33(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync34(path3, "utf8"));
   } catch {
     return [];
   }
@@ -89362,9 +89755,9 @@ function loadEdgePark(path3) {
 }
 function saveEdgePark(path3, queue) {
   try {
-    const tmp = join37(dirname13(path3), `.${Date.now()}.edge-park.tmp`);
-    writeFileSync25(tmp, JSON.stringify(queue), "utf8");
-    renameSync5(tmp, path3);
+    const tmp = join38(dirname14(path3), `.${Date.now()}.edge-park.tmp`);
+    writeFileSync26(tmp, JSON.stringify(queue), "utf8");
+    renameSync6(tmp, path3);
   } catch {
   }
 }
@@ -89379,6 +89772,14 @@ function edgeHolds(queue, now) {
   }
   return holds;
 }
+function nextEdgeParkChange(queue) {
+  let next = null;
+  for (const e of queue) {
+    const at = e.state === "dropped" ? (e.droppedAt ?? e.ts) + tombstoneTtl(e) : e.dueAt;
+    if (next === null || at < next) next = at;
+  }
+  return next;
+}
 function classifyEdgeVerdict(decision, reason) {
   if (decision === "created" || decision === "reinforced") return "landed";
   const why = reason ?? "";
@@ -89676,8 +90077,8 @@ function invalidateInstanceReceipt(current, destination, failedId, mirrorLegacy)
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync34, writeFileSync as writeFileSync28 } from "node:fs";
-import { resolve as pathResolve } from "node:path";
+import { existsSync as existsSync34, readFileSync as readFileSync40, writeFileSync as writeFileSync29 } from "node:fs";
+import { join as join47, resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
 init_src5();
@@ -89705,8 +90106,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync30, readFileSync as readFileSync34 } from "node:fs";
-import { join as join38 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync35 } from "node:fs";
+import { join as join39 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -89731,10 +90132,23 @@ function buildContextNode(id, label, description, attrs, ts) {
     attrs
   };
 }
+function mintContextNode(store, node2) {
+  const existing = store.getNode(node2.id);
+  if (!existing || (existing.validTo ?? null) !== null) {
+    store.mergeNode(node2);
+    return true;
+  }
+  const facts = Object.keys(node2.attrs);
+  const same = existing.label === node2.label && existing.description === node2.description && facts.every((k) => JSON.stringify(existing.attrs[k]) === JSON.stringify(node2.attrs[k]));
+  if (same) return false;
+  store.updateNode(node2.id, { description: node2.description, attrs: { ...existing.attrs, ...node2.attrs }, lastUpdatedAt: node2.lastUpdatedAt });
+  return true;
+}
 function mintPackageGraph(store, sbom, workspaceId2, ts) {
   const minted = /* @__PURE__ */ new Set();
   for (const c of sbom.components) {
-    store.mergeNode(
+    mintContextNode(
+      store,
       buildContextNode(
         c.purl,
         "Package",
@@ -89757,8 +90171,14 @@ function mintPackageGraph(store, sbom, workspaceId2, ts) {
     if (!minted.has(d.ref)) continue;
     for (const to of d.dependsOn) {
       if (!minted.has(to)) continue;
+      const id = `edge_${digest({ from: d.ref, type: "DEPENDS_ON", to })}`.slice(0, 24);
+      const live3 = store.getEdge(id);
+      if (live3 && (live3.validTo ?? null) === null) {
+        edges++;
+        continue;
+      }
       store.mergeEdge({
-        id: `edge_${digest({ from: d.ref, type: "DEPENDS_ON", to })}`.slice(0, 24),
+        id,
         from: d.ref,
         to,
         type: "DEPENDS_ON",
@@ -89780,9 +90200,7 @@ function mintLanguageNodes(store, languages, workspaceId2, ts) {
   for (const raw2 of languages) {
     const name2 = raw2.trim();
     if (!name2) continue;
-    store.mergeNode(
-      buildContextNode(`lang:${name2.toLowerCase()}`, "Language", name2, { name: name2, workspaceId: workspaceId2 }, ts)
-    );
+    mintContextNode(store, buildContextNode(`lang:${name2.toLowerCase()}`, "Language", name2, { name: name2, workspaceId: workspaceId2 }, ts));
     n++;
   }
   return n;
@@ -89829,10 +90247,14 @@ function buildContextIngest(store, profile, daemonVersion, ignorePatterns = [],
     }
   }
   if (nodes.length === 0) return null;
+  const contributed = (id) => {
+    const n = store.getNode(id);
+    return !!n && (n.label === "Package" || n.label === "Language") && n.attrs["source"] !== "cloud" && typeof n.attrs["contributedAtSeq"] === "number" && !ignored(n.description) && !ignored(String(n.attrs["name"] ?? ""));
+  };
   const edges = [];
   for (const id of seen) {
     for (const e of store.outEdges(id, ["DEPENDS_ON"])) {
-      if (seen.has(e.to)) edges.push({ ...e, attrs: {} });
+      if (seen.has(e.to) || contributed(e.to)) edges.push({ ...e, attrs: {} });
     }
   }
   const base = {
@@ -89858,11 +90280,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join38(opts.root, c.file);
+    const p = join39(opts.root, c.file);
     if (!existsSync30(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync34(p, "utf8"));
+      sbom = c.parse(readFileSync35(p, "utf8"));
     } catch {
       continue;
     }
@@ -89923,8 +90345,8 @@ init_profile2();
 init_session_registry();
 
 // src/public-symbols.ts
-import { readFileSync as readFileSync35, readdirSync as readdirSync12, existsSync as existsSync31 } from "node:fs";
-import { join as join39 } from "node:path";
+import { readFileSync as readFileSync36, readdirSync as readdirSync12, existsSync as existsSync31 } from "node:fs";
+import { join as join40 } from "node:path";
 var HEAD_BYTES = 8 * 1024;
 var INDEX_TTL_MS = 10 * 60 * 1e3;
 var MIN_SYMBOL_LEN = 4;
@@ -89957,20 +90379,20 @@ function bindingNames(clause) {
 function internalPackageNames(workspaceRoot) {
   const names = /* @__PURE__ */ new Set();
   const tryRead = (dir) => {
-    const pj = join39(dir, "package.json");
+    const pj = join40(dir, "package.json");
     if (!existsSync31(pj)) return;
     try {
-      const name2 = JSON.parse(readFileSync35(pj, "utf8")).name;
+      const name2 = JSON.parse(readFileSync36(pj, "utf8")).name;
       if (typeof name2 === "string" && name2.length > 0) names.add(name2);
     } catch {
     }
   };
   tryRead(workspaceRoot);
   for (const group of ["packages", "apps"]) {
-    const groupDir = join39(workspaceRoot, group);
+    const groupDir = join40(workspaceRoot, group);
     if (!existsSync31(groupDir)) continue;
     try {
-      for (const entry of readdirSync12(groupDir)) tryRead(join39(groupDir, entry));
+      for (const entry of readdirSync12(groupDir)) tryRead(join40(groupDir, entry));
     } catch {
     }
   }
@@ -89989,7 +90411,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
-      return readFileSync35(absPath, "utf8").slice(0, HEAD_BYTES);
+      return readFileSync36(absPath, "utf8").slice(0, HEAD_BYTES);
     } catch {
       return "";
     }
@@ -90009,7 +90431,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const symbols = /* @__PURE__ */ new Set();
   for (const rel of files) {
-    const head2 = readHead(join39(workspaceRoot, rel));
+    const head2 = readHead(join40(workspaceRoot, rel));
     if (!head2) continue;
     for (const re of [NAMED_IMPORT_RE, REQUIRE_RE]) {
       re.lastIndex = 0;
@@ -90994,7 +91416,7 @@ init_config();
 
 // src/update.ts
 import { spawn as spawn2 } from "node:child_process";
-import { isAbsolute as isAbsolute6, join as join40 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join41 } from "node:path";
 var PACKAGE_NAME = "@inerrata-corporation/errata";
 function parse3(v) {
   const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z][0-9A-Za-z.-]*))?/.exec(v.trim());
@@ -91139,9 +91561,9 @@ async function runInstalledHookRefresh() {
     child.on("error", () => resolve10(""));
     child.on("close", (code) => resolve10(code === 0 ? output.trim() : ""));
   });
-  if (!isAbsolute6(root)) return 1;
+  if (!isAbsolute5(root)) return 1;
   return new Promise((resolve10) => {
-    const child = spawn2(process.execPath, [join40(root, PACKAGE_NAME, "errata.mjs"), "install-hooks", "codex", "--refresh-existing"], {
+    const child = spawn2(process.execPath, [join41(root, PACKAGE_NAME, "errata.mjs"), "install-hooks", "codex", "--refresh-existing"], {
       windowsHide: true,
       stdio: "inherit",
       timeout: 3e4
@@ -91287,12 +91709,12 @@ function landCloudEdge(store, e, from, to) {
 }
 
 // src/causal-edge-queue.ts
-import { readFileSync as readFileSync36, renameSync as renameSync6, writeFileSync as writeFileSync26 } from "node:fs";
-import { dirname as dirname14, join as join41 } from "node:path";
+import { readFileSync as readFileSync37, renameSync as renameSync7, writeFileSync as writeFileSync27 } from "node:fs";
+import { dirname as dirname15, join as join42 } from "node:path";
 var CAUSAL_EDGE_QUEUE_CAP = 5e3;
 var CAUSAL_EDGE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 function causalEdgeQueuePath(workspaceConfigDir) {
-  return join41(workspaceConfigDir, "causal-edge-queue.json");
+  return join42(workspaceConfigDir, "causal-edge-queue.json");
 }
 function parkedEdgeKey(e) {
   return `${e.from}|${e.type}|${e.to}`;
@@ -91300,7 +91722,7 @@ function parkedEdgeKey(e) {
 function loadCausalEdgeQueue(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync36(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync37(path3, "utf8"));
   } catch {
     return [];
   }
@@ -91311,9 +91733,9 @@ function loadCausalEdgeQueue(path3) {
 }
 function saveCausalEdgeQueue(path3, queue) {
   try {
-    const tmp = join41(dirname14(path3), `.${Date.now()}.causal-edge-queue.tmp`);
-    writeFileSync26(tmp, JSON.stringify(queue), "utf8");
-    renameSync6(tmp, path3);
+    const tmp = join42(dirname15(path3), `.${Date.now()}.causal-edge-queue.tmp`);
+    writeFileSync27(tmp, JSON.stringify(queue), "utf8");
+    renameSync7(tmp, path3);
   } catch {
   }
 }
@@ -91449,6 +91871,10 @@ async function lookupLive(store, m, id) {
   const second = (await m.refresh()).get(id);
   return second && isLive(store, second) ? second : null;
 }
+function reverseSymbolResolver(opts) {
+  const m = cachedMap(reverseCache, opts.store, `${opts.projectId}|${opts.salt}`, () => buildReverseSymbolMap(opts));
+  return (symbolId) => lookupLive(opts.store, m, symbolId);
+}
 function isLive(store, id) {
   const n = store.getNode(id);
   return n !== null && (n.validTo === null || n.validTo === void 0);
@@ -91739,7 +92165,9 @@ init_src11();
 init_src();
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { extname as extname3 } from "node:path";
+import { extname as extname3, join as join43 } from "node:path";
+import { createHash as createHash19 } from "node:crypto";
+import { readFileSync as readFileSync38 } from "node:fs";
 
 // src/history-dependency-snapshot.ts
 init_src();
@@ -91750,22 +92178,20 @@ async function readHistoryDependencySnapshot(opts) {
   const git3 = opts.git ?? (async (args2) => (await exec("git", ["-C", opts.root, ...args2], { windowsHide: true, maxBuffer: 16 * 1024 * 1024 })).stdout);
   const read2 = opts.readBlob ?? (async (oid) => git3(["show", oid]));
   let complete = true;
-  const tree = await git3(["ls-tree", "-r", opts.commit]).catch(() => null);
+  const tree = await git3(["ls-tree", "-r", "-z", opts.commit]).catch(() => null);
   if (tree === null) return { schemaVersion: "history-deps-1", complete: false, dependencies: [] };
-  const entries = tree.split("\n").flatMap((line) => {
-    const match2 = /^\d+ blob ([a-f0-9]+)\t(.+)$/.exec(line);
-    if (!match2) return [];
-    const path3 = match2[2].replace(/^"|"$/g, "");
-    if (path3.includes("\\") || /[\r\n]/.test(path3)) {
-      complete = false;
-      return [];
-    }
-    return [{ path: path3, oid: match2[1] }];
+  const entries = tree.split("\0").flatMap((row) => {
+    const match2 = /^\d+ blob ([a-f0-9]+)\t([^]+)$/.exec(row);
+    return match2 ? [{ path: match2[2], oid: match2[1] }] : [];
   });
   const manifests = {}, locks = {};
   for (const { path: path3, oid } of entries) {
-    const lock = /(?:^|\/)(?:pnpm-lock.yaml|package-lock.json)$/.test(path3);
+    const lock = /(?:^|\/)(?:pnpm-lock\.yaml|package-lock\.json)$/.test(path3);
     if (!lock && (!isManifestPath(path3) || opts.manifestIds && !opts.manifestIds.has(historyManifestId(path3)))) continue;
+    if (path3.includes("\\") || /[\r\n]/.test(path3)) {
+      complete = false;
+      continue;
+    }
     if (opts.paths && !Object.values(opts.paths).some((p) => !path3.includes("/") || p.startsWith(path3.slice(0, path3.lastIndexOf("/") + 1)))) continue;
     if (opts.allowPath && !opts.allowPath(path3)) {
       complete = false;
@@ -91848,6 +92274,38 @@ init_profile2();
 var exec2 = promisify4(execFile5);
 var KINDS = { function: "Function", class: "Class", method: "Method", interface: "Interface", const: "Const", enum: "Enum", typealias: "TypeAlias", namespace: "Namespace", property: "Property" };
 var inFlight = /* @__PURE__ */ new Map();
+var carryRefused = /* @__PURE__ */ new Set();
+var carryFailures = /* @__PURE__ */ new Map();
+var CARRY_ATTEMPTS = 3;
+var Bounded = class extends Map {
+  constructor(cap) {
+    super();
+    this.cap = cap;
+  }
+  set(key, value) {
+    if (!this.has(key) && this.size >= this.cap) this.delete(this.keys().next().value);
+    return super.set(key, value);
+  }
+};
+var DEFAULT_GIT = {};
+function readFileSafe(path3) {
+  try {
+    return readFileSync38(path3, "utf8");
+  } catch {
+    return "";
+  }
+}
+var revisionCaches = /* @__PURE__ */ new WeakMap();
+function cachesFor(git3) {
+  let caches = revisionCaches.get(git3);
+  if (!caches) {
+    caches = { parents: new Bounded(4), dependencies: new Bounded(8), trees: new Bounded(4), symbols: new Bounded(4e3), diffs: new Bounded(2e3) };
+    revisionCaches.set(git3, caches);
+  }
+  return caches;
+}
+var REVISION_DIFF_TOKENS = 4e3;
+var REVISION_RAW_DIFF_CHARS = REVISION_DIFF_TOKENS * 4 * 4;
 async function syncHistoryRevision(opts) {
   const current = inFlight.get(opts.root);
   if (current) return current;
@@ -91855,12 +92313,13 @@ async function syncHistoryRevision(opts) {
     const started2 = Date.now();
     let changed = 0, remaining = false;
     const pages = Math.min(20, Math.max(1, opts.maxPages ?? 10));
+    const resolve10 = opts.profile.projectId ? reverseSymbolResolver({ store: opts.store, salt: opts.salt, projectId: opts.profile.projectId }) : async () => null;
     for (let i2 = 0; i2 < pages; i2++) {
-      const result = await syncHistoryRevisionPage(opts);
+      const result = await syncHistoryRevisionPage(opts, resolve10);
       changed += result.changed;
       remaining = result.remaining;
-      if (!remaining || Date.now() - started2 >= (opts.budgetMs ?? 45e3)) break;
-      await new Promise((resolve10) => setImmediate(resolve10));
+      if (!remaining || result.nextBeat || Date.now() - started2 >= (opts.budgetMs ?? 45e3)) break;
+      await new Promise((resolve11) => setImmediate(resolve11));
     }
     return { changed, remaining };
   })();
@@ -91871,78 +92330,147 @@ async function syncHistoryRevision(opts) {
     if (inFlight.get(opts.root) === work) inFlight.delete(opts.root);
   }
 }
-async function syncHistoryRevisionPage(opts) {
+async function syncHistoryRevisionPage(opts, resolve10) {
   const { root, profile, store, cloud, salt } = opts;
   if (!profile.projectId) return { changed: 0, remaining: false };
   const projectId = profile.projectId;
   const git3 = opts.git ?? (async (args2) => (await exec2("git", ["-C", root, ...args2], { windowsHide: true, maxBuffer: 8 * 1024 * 1024 })).stdout);
+  const caches = cachesFor(opts.git ?? DEFAULT_GIT);
+  const ignoreKey = createHash19("sha256").update(JSON.stringify(profile.ignoreExtra ?? [])).update(readFileSafe(join43(root, ".errataignore"))).digest("hex").slice(0, 16);
   const atCommit = (await git3(["rev-parse", "--verify", "HEAD"])).trim();
   if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(atCommit)) throw new Error("history revision is not a full Git object id");
   const oldCursor = profile.historyRevisionCursor;
-  const same = oldCursor?.atCommit === atCommit;
-  if (same && oldCursor.complete && Date.now() - oldCursor.updatedAt < 60 * 6e4) return { changed: 0, remaining: false };
-  const after = oldCursor && !oldCursor.complete ? oldCursor.after : void 0;
-  const sweepCommit = after ? oldCursor.atCommit : atCommit;
-  const page = await cloud.getHistoryOccurrences(projectId, atCommit, after);
+  const save = () => (opts.save ?? ((p) => saveProfile(root, p)))(profile);
+  if (oldCursor && oldCursor.ignoreKey !== ignoreKey && oldCursor.reprove !== ignoreKey) {
+    profile.historyRevisionCursor = { ...oldCursor, atCommit, complete: false, after: void 0, reprove: ignoreKey, updatedAt: Date.now() };
+    delete profile.historyRevisionCursor.after;
+    save();
+  }
+  const cursor = profile.historyRevisionCursor;
+  const head2 = cursor?.head ?? cursor?.atCommit;
+  if (cursor && head2 && head2 !== atCommit && cloud.carryHistory && !carryRefused.has(root)) {
+    const range = `${root}|${head2}|${atCommit}`;
+    try {
+      const carry = await carryRequest({
+        git: git3,
+        caches,
+        root,
+        salt,
+        projectId,
+        providers: defaultProviders(),
+        from: head2,
+        at: atCommit,
+        rulesChanged: cursor.ignoreKey !== ignoreKey
+      });
+      await cloud.carryHistory(projectId, carry);
+      carryFailures.delete(range);
+    } catch (err2) {
+      if (err2.status === 404) {
+        carryRefused.add(root);
+        console.warn(`[errata] the cloud predates history carry; every new commit re-proves all history verdicts for ${profile.name}`);
+      } else {
+        const failures = (carryFailures.get(range) ?? 0) + 1;
+        carryFailures.set(range, failures);
+        console.warn(`[errata] history carry ${head2.slice(0, 12)}..${atCommit.slice(0, 12)} failed (${failures}/${CARRY_ATTEMPTS})${failures >= CARRY_ATTEMPTS ? "; re-proving this commit instead" : ""}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        if (failures < CARRY_ATTEMPTS) return { changed: 0, remaining: true, nextBeat: true };
+        carryFailures.delete(range);
+      }
+    }
+    profile.historyRevisionCursor = { ...cursor, head: atCommit };
+    save();
+  }
+  const current = profile.historyRevisionCursor;
+  const reproving = current?.reprove === ignoreKey;
+  const same = current?.atCommit === atCommit;
+  if (same && current.complete && Date.now() - current.updatedAt < 60 * 6e4) return { changed: 0, remaining: false };
+  const after = current && !current.complete ? current.after : void 0;
+  const sweepCommit = after ? current.atCommit : atCommit;
+  const page = await cloud.getHistoryOccurrences(projectId, atCommit, after, { pendingOnly: !reproving });
   if (!Array.isArray(page.occurrences) || page.occurrences.length > 50 || page.occurrences.some((o, i2) => o.occurrenceId <= (page.occurrences[i2 - 1]?.occurrenceId ?? after ?? "")) || page.cursor !== null && page.cursor !== page.occurrences.at(-1)?.occurrenceId) throw new Error("invalid history occurrence page");
-  const parents = page.occurrences.length ? (await git3(["rev-list", "--parents", "--max-count=8192", atCommit])).trim().split("\n").filter(Boolean).map((row) => {
-    const [commit, ...parents2] = row.trim().split(/\s+/);
-    return { commit, parents: parents2 };
-  }) : [];
-  const reverse = page.occurrences.length ? await buildReverseSymbolMap({ store, projectId, salt }) : /* @__PURE__ */ new Map();
+  const toPost = page.occurrences.filter((o) => !settledHistoryReceipt(o.quality["reconciliationEvidence"]) || reproving && o.quality["historicalAnchors"]?.length);
+  let parents = [];
+  if (toPost.length) {
+    const key = `${root}|${atCommit}`;
+    parents = caches.parents.get(key) ?? (await git3(["rev-list", "--parents", "--max-count=8192", atCommit])).trim().split("\n").filter(Boolean).map((row) => {
+      const [commit, ...parents2] = row.trim().split(/\s+/);
+      return { commit, parents: parents2 };
+    });
+    caches.parents.set(key, parents);
+  }
   const ignore2 = loadRepoIgnore(root, profile.ignoreExtra ?? []);
   const providers = defaultProviders();
-  const parsedFiles = /* @__PURE__ */ new Map();
   const observations = [];
-  const contexts = page.occurrences.map((o) => HistoryDependencyContextSchema.safeParse(o.quality["dependencyContext"]));
+  const contexts = toPost.map((o) => HistoryDependencyContextSchema.safeParse(o.quality["dependencyContext"]));
   const manifestIds = new Set(contexts.flatMap((c) => c.success ? c.data.dependencies.map((d) => d.manifestId) : []));
-  const currentDependencies = manifestIds.size ? await readHistoryDependencySnapshot({
-    root,
-    commit: atCommit,
-    side: "after",
-    manifestIds,
-    git: git3,
-    allowPath: (p) => pathAllowedByFloor(p) && !isPathBlocked(ignore2, p)
-  }) : void 0;
-  for (const occurrence of page.occurrences) {
+  let currentDependencies;
+  if (manifestIds.size) {
+    const key = `${root}|${atCommit}|${ignoreKey}|${[...manifestIds].sort().join(",")}`;
+    let snapshot = caches.dependencies.get(key);
+    if (!snapshot) {
+      snapshot = readHistoryDependencySnapshot({
+        root,
+        commit: atCommit,
+        side: "after",
+        manifestIds,
+        git: git3,
+        allowPath: (p) => pathAllowedByFloor(p) && !isPathBlocked(ignore2, p)
+      });
+      caches.dependencies.set(key, snapshot);
+      snapshot.catch(() => caches.dependencies.delete(key));
+    }
+    currentDependencies = await snapshot;
+  }
+  const treeKey = `${root}|${atCommit}`;
+  let tree = caches.trees.get(treeKey);
+  if (!tree && toPost.length) {
+    tree = git3(["ls-tree", "-r", "-z", "--full-tree", atCommit]).then((out2) => new Map(out2.split("\0").flatMap((row) => {
+      const tab = row.indexOf("	"), [, type, blob] = row.slice(0, tab).split(" ");
+      return tab > 0 && type === "blob" && blob ? [[row.slice(tab + 1), blob]] : [];
+    })));
+    caches.trees.set(treeKey, tree);
+    tree.catch(() => caches.trees.delete(treeKey));
+  }
+  const blobs = await (tree ?? Promise.resolve(/* @__PURE__ */ new Map())).catch(() => /* @__PURE__ */ new Map());
+  const fileId = (path3) => blobs.get(path3) ?? `commit:${atCommit}`;
+  for (const occurrence of toPost) {
     const anchors = occurrence.quality["historicalAnchors"];
     const paths = /* @__PURE__ */ new Set(), symbols = [];
+    let partial2 = false;
     for (const anchor of anchors ?? []) {
-      const localId = reverse.get(anchor.symbolId), local = localId ? store.getNode(localId) : null;
+      const localId = await resolve10(anchor.symbolId), local = localId ? store.getNode(localId) : null;
       const path3 = local?.attrs["relPath"];
       if (typeof path3 !== "string" || !pathAllowedByFloor(path3) || isPathBlocked(ignore2, path3) || /[\r\n]/.test(path3)) continue;
       paths.add(path3);
-      if (!parsedFiles.has(path3)) {
-        const hashes = /* @__PURE__ */ new Map();
-        parsedFiles.set(path3, hashes);
-        const provider = providers.find((p) => p.fileExtensions.includes(extname3(path3).toLowerCase()));
-        if (!provider) continue;
-        const source2 = await git3(["show", `${atCommit}:${path3}`]).catch(() => null);
-        if (source2 === null || Buffer.byteLength(source2) > 1e6 || source2.includes("\0")) continue;
-        await provider.preload?.();
-        for (const symbol2 of provider.extractSymbols(source2, path3)) {
-          const kind = KINDS[symbol2.kind];
-          if (kind && symbol2.bodyHash) hashes.set(projectSymbolId(salt, projectId, path3, symbol2.qname ?? symbol2.name, kind), symbol2.bodyHash);
-        }
-      }
-      const bodyHash = parsedFiles.get(path3).get(anchor.symbolId);
+      const hashes = await fileSymbols({ caches, providers, root, salt, projectId }, path3, fileId(path3), () => git3(["show", `${atCommit}:${path3}`]));
+      if (!hashes) partial2 = true;
+      const bodyHash = hashes?.get(anchor.symbolId);
       if (bodyHash) symbols.push({ symbolId: anchor.symbolId, bodyHash });
     }
     const source = occurrenceSourceCommit(occurrence);
     let diff;
     if (source && source !== atCommit && paths.size) {
-      const bundle = await buildUnitBundle(root, {
-        sha: atCommit,
-        parents: [source],
-        isMerge: true,
-        index: 0,
-        subIndex: 0,
-        subject: "",
-        body: "",
-        authorDate: "",
-        files: [...paths].map((path3) => ({ path: path3, adds: 1, dels: 1, binary: false }))
-      }, { maxTokens: 4e3, ignorePatterns: profile.ignoreExtra ?? [] }).catch(() => null);
-      if (bundle && !bundle.truncated) diff = bundle.diff;
+      const diffKey = `${root}|${ignoreKey}|${source}|${[...paths].sort().map((path3) => `${path3}\0${fileId(path3)}`).join("\0")}`;
+      if (caches.diffs.has(diffKey)) diff = caches.diffs.get(diffKey);
+      else {
+        const bundle = await buildUnitBundle(
+          root,
+          {
+            sha: atCommit,
+            parents: [source],
+            isMerge: true,
+            index: 0,
+            subIndex: 0,
+            subject: "",
+            body: "",
+            authorDate: "",
+            files: [...paths].map((path3) => ({ path: path3, adds: 1, dels: 1, binary: false }))
+          },
+          { maxTokens: REVISION_DIFF_TOKENS, maxRawDiffChars: REVISION_RAW_DIFF_CHARS, ignorePatterns: profile.ignoreExtra ?? [] }
+        ).catch(() => null);
+        if (bundle && !bundle.truncated) diff = bundle.diff;
+        if (bundle) caches.diffs.set(diffKey, diff);
+        else partial2 = true;
+      }
     }
     const old = HistoryDependencyContextSchema.safeParse(occurrence.quality["dependencyContext"]);
     const dependencyContext = old.success ? {
@@ -91950,16 +92478,24 @@ async function syncHistoryRevisionPage(opts) {
       complete: old.data.dependencies.length === 0 || currentDependencies?.complete === true,
       dependencies: currentDependencies?.dependencies.filter((d) => old.data.dependencies.some((o) => o.packageId === d.packageId && o.manifestId === d.manifestId)) ?? []
     } : void 0;
+    if (partial2) continue;
     observations.push({ occurrenceId: occurrence.occurrenceId, symbols, ...diff ? { diff } : {}, ...dependencyContext ? { dependencyContext } : {} });
   }
-  const response = page.occurrences.length ? await cloud.reconcileHistory(projectId, { atCommit, parents, observations }) : { atCommit, receipts: [] };
-  if (response.atCommit !== atCommit || response.receipts.length !== page.occurrences.length || new Set(response.receipts.map((r) => r.occurrenceId)).size !== response.receipts.length || response.receipts.some((r) => r.atCommit !== atCommit || !observations.some((o) => o.occurrenceId === r.occurrenceId))) throw new Error("incomplete history reconciliation response");
+  const response = observations.length ? await cloud.reconcileHistory(projectId, { atCommit, parents, observations }) : { atCommit, receipts: [] };
+  if (response.atCommit !== atCommit || response.receipts.length !== observations.length || new Set(response.receipts.map((r) => r.occurrenceId)).size !== response.receipts.length || response.receipts.some((r) => r.atCommit !== atCommit || !observations.some((o) => o.occurrenceId === r.occurrenceId))) throw new Error("incomplete history reconciliation response");
+  const receipts = new Map(response.receipts.map((r) => [r.occurrenceId, r]));
+  for (const o of page.occurrences) {
+    if (!receipts.has(o.occurrenceId) && settledHistoryReceipt(o.quality["reconciliationEvidence"])) {
+      receipts.set(o.occurrenceId, { verdict: o.quality["applicability"], evidence: o.quality["reconciliationEvidence"] });
+    }
+  }
   const headChanged = (await git3(["rev-parse", "--verify", "HEAD"])).trim() !== atCommit;
   let changed = 0;
   for (const occurrence of page.occurrences) {
-    const node2 = store.getNode(occurrence.canonicalId) ?? (occurrence.nodeId ? store.getNode(occurrence.nodeId) : null);
+    const node2 = historyNode(store, occurrence);
     if (!node2 || node2.attrs["source"] !== "cloud" || node2.attrs["historyQuality"]?.["sourceSupport"] === "quarantined") continue;
-    const receipt = response.receipts.find((r) => r.occurrenceId === occurrence.occurrenceId);
+    const receipt = receipts.get(occurrence.occurrenceId);
+    if (!receipt || unchangedRecord(node2, occurrence, receipt, atCommit)) continue;
     const previous = node2.attrs["historyQuality"];
     if (previous?.["evaluatedAtCommit"] === atCommit && previous["applicability"] === "applicable" && receipt.verdict !== "applicable" && previous["sourceReviewId"] === occurrence.quality["sourceReviewId"] && previous["dependencyReviewId"] === occurrence.quality["dependencyReviewId"] && historyDependencyIdentity(previous["dependencyContext"]) !== null && historyDependencyIdentity(previous["dependencyContext"]) === historyDependencyIdentity(occurrence.quality["dependencyContext"]) && previous["reconciliationEvidence"]?.["build"] === HISTORY_RECONCILE_BUILD) continue;
     const dependencies = HistoryDependencyContextSchema.safeParse(occurrence.quality["dependencyContext"]);
@@ -91975,17 +92511,115 @@ async function syncHistoryRevisionPage(opts) {
     } });
     changed++;
   }
-  profile.historyRevisionCursor = { atCommit: sweepCommit, ...page.cursor ? { after: page.cursor } : {}, complete: page.cursor === null, updatedAt: Date.now() };
-  (opts.save ?? ((p) => saveProfile(root, p)))(profile);
+  const complete = page.cursor === null;
+  const proven = reproving && complete && sweepCommit === atCommit;
+  const provenKey = proven || !current ? ignoreKey : current.ignoreKey;
+  profile.historyRevisionCursor = {
+    atCommit: sweepCommit,
+    ...page.cursor ? { after: page.cursor } : {},
+    complete,
+    updatedAt: Date.now(),
+    head: atCommit,
+    ...provenKey !== void 0 ? { ignoreKey: provenKey } : {},
+    ...reproving && !proven ? { reprove: ignoreKey } : {}
+  };
+  save();
   return { changed, remaining: page.cursor !== null || headChanged || sweepCommit !== atCommit };
 }
+function historyNode(store, occurrence) {
+  return store.getNode(occurrence.canonicalId) ?? (occurrence.nodeId ? store.getNode(occurrence.nodeId) : null);
+}
+function unchangedRecord(node2, occurrence, receipt, atCommit) {
+  const previous = node2.attrs["historyQuality"];
+  if (!previous) return false;
+  const stamp = receipt.verdict === "unknown" && previous["applicability"] === "unknown" ? previous["evaluatedAtCommit"] : atCommit;
+  const dependencies = HistoryDependencyContextSchema.safeParse(occurrence.quality["dependencyContext"]);
+  const next = compactHistoryQuality({
+    ...occurrence.quality,
+    evaluatedAtCommit: stamp,
+    applicability: receipt.verdict,
+    reconciliationEvidence: receipt.evidence
+  });
+  return digest(JSON.parse(JSON.stringify(next))) === digest(previous) && digest(dependencies.success ? historyDependencyVersions(dependencies.data) : null) === digest(node2.attrs["depVersions"] ?? null);
+}
+async function fileSymbols(ctx, path3, fileId, read2) {
+  const fileKey = `${ctx.root}|${ctx.salt}|${ctx.projectId}|${fileId}|${path3}`;
+  const cached2 = ctx.caches.symbols.get(fileKey);
+  if (cached2) return cached2;
+  const hashes = /* @__PURE__ */ new Map();
+  const provider = ctx.providers.find((p) => p.fileExtensions.includes(extname3(path3).toLowerCase()));
+  if (!provider) {
+    ctx.caches.symbols.set(fileKey, hashes);
+    return hashes;
+  }
+  const source = await read2().catch(() => null);
+  if (source === null) return void 0;
+  ctx.caches.symbols.set(fileKey, hashes);
+  if (Buffer.byteLength(source) > 1e6 || source.includes("\0")) return hashes;
+  await provider.preload?.();
+  for (const symbol2 of provider.extractSymbols(source, path3)) {
+    const kind = KINDS[symbol2.kind];
+    if (kind && symbol2.bodyHash) hashes.set(projectSymbolId(ctx.salt, ctx.projectId, path3, symbol2.qname ?? symbol2.name, kind), symbol2.bodyHash);
+  }
+  return hashes;
+}
+var CARRY_MAX_CODE_FILES = 400;
+var CARRY_MAX_SYMBOLS = 5e3;
+var CARRY_MAX_MANIFESTS = 512;
+var CARRY_MAX_COMMITS = 8192;
+var LOCKFILE = /(?:^|\/)(?:pnpm-lock\.yaml|package-lock\.json)$/;
+var NO_BLOB = /^0+$/;
+async function carryRequest(o) {
+  const { git: git3, from, at } = o;
+  let parents = [];
+  if (await git3(["merge-base", "--is-ancestor", from, at]).then(() => true, () => false)) {
+    const rows = `${await git3(["rev-list", "--parents", "--ancestry-path", `--max-count=${CARRY_MAX_COMMITS}`, `${from}..${at}`])}
+${await git3(["rev-list", "--parents", "-1", from])}`.split("\n").map((row) => row.trim()).filter(Boolean).map((row) => {
+      const [commit, ...parents2] = row.split(/\s+/);
+      return { commit, parents: parents2 };
+    });
+    if (rows.length <= CARRY_MAX_COMMITS) parents = rows;
+  }
+  const fields = (await git3(["diff", "--raw", "--no-renames", "--no-abbrev", "-z", from, at])).split("\0");
+  const changes = [];
+  for (let i2 = 0; i2 + 1 < fields.length; i2 += 2) {
+    const meta3 = fields[i2].trim().split(/\s+/), path3 = fields[i2 + 1];
+    if (meta3.length >= 4 && path3) changes.push({ path: path3, blobs: [meta3[2], meta3[3]].filter((b) => !NO_BLOB.test(b)) });
+  }
+  const manifests = /* @__PURE__ */ new Set(), symbols = /* @__PURE__ */ new Set();
+  let allManifests = o.rulesChanged, allSymbols = o.rulesChanged;
+  const code = changes.filter((c) => o.providers.some((p) => p.fileExtensions.includes(extname3(c.path).toLowerCase())));
+  if (code.length > CARRY_MAX_CODE_FILES) allSymbols = true;
+  for (const change of changes) {
+    if (LOCKFILE.test(change.path)) allManifests = true;
+    else if (isManifestPath(change.path)) manifests.add(historyManifestId(change.path));
+  }
+  for (const change of allSymbols ? [] : code) {
+    for (const blob of change.blobs) {
+      const hashes = await fileSymbols(o, change.path, blob, () => git3(["show", blob]));
+      if (!hashes) {
+        allSymbols = true;
+        break;
+      }
+      for (const id of hashes.keys()) symbols.add(id);
+    }
+    if (allSymbols) break;
+  }
+  return {
+    fromCommit: from,
+    atCommit: at,
+    parents,
+    changedSymbols: allSymbols || symbols.size > CARRY_MAX_SYMBOLS ? null : [...symbols].sort(),
+    changedManifests: allManifests || manifests.size > CARRY_MAX_MANIFESTS ? null : [...manifests].sort()
+  };
+}
 
 // src/project-history.ts
 init_src7();
 init_src();
 import { execFile as execFile6 } from "node:child_process";
-import { readFileSync as readFileSync37 } from "node:fs";
-import { join as join42 } from "node:path";
+import { readFileSync as readFileSync39 } from "node:fs";
+import { join as join44 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/history-walk.ts
@@ -92537,7 +93171,7 @@ async function defaultGit(root, args2) {
 function readIgnoreLines(root, profile) {
   let lines = [];
   try {
-    lines = readFileSync37(join42(root, ".errataignore"), "utf8").split("\n");
+    lines = readFileSync39(join44(root, ".errataignore"), "utf8").split("\n");
   } catch {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -93111,10 +93745,10 @@ async function startHistoryStage(root, input, client, walk11 = {}) {
 
 // src/link-flow.ts
 init_cloud_auth();
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { existsSync as existsSync32, writeFileSync as writeFileSync27 } from "node:fs";
-import { join as join43 } from "node:path";
+import { existsSync as existsSync32, writeFileSync as writeFileSync28 } from "node:fs";
+import { join as join45 } from "node:path";
 
 // src/device-poll.ts
 var THROTTLED_POLL_MIN_WAIT_MS = 11e3;
@@ -93406,7 +94040,7 @@ async function loginOAuthLoopback(opts) {
 
 // src/link-flow.ts
 function remoteFingerprint(locator) {
-  return createHash19("sha256").update(locator).digest("hex");
+  return createHash20("sha256").update(locator).digest("hex");
 }
 function isDecision(value) {
   if (!value || typeof value !== "object") return false;
@@ -93573,9 +94207,9 @@ function applyLinkDecision(root, profile, config2, decision, now = Date.now) {
   delete nextProfile.projectLinkHold;
   let wroteIgnore = false;
   if (decision.writeIgnoreStarter !== false) {
-    const target = join43(root, ".errataignore");
+    const target = join45(root, ".errataignore");
     if (!existsSync32(target)) {
-      writeFileSync27(target, IGNORE_STARTER, "utf8");
+      writeFileSync28(target, IGNORE_STARTER, "utf8");
       wroteIgnore = true;
     }
   }
@@ -93589,12 +94223,12 @@ init_registry();
 // src/adopt.ts
 init_git_remote();
 import { existsSync as existsSync33 } from "node:fs";
-import { dirname as dirname15, join as join44 } from "node:path";
+import { dirname as dirname16, join as join46 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync33(join44(dir, ".git"))) return dir;
-    const parent = dirname15(dir);
+    if (existsSync33(join46(dir, ".git"))) return dir;
+    const parent = dirname16(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -94068,7 +94702,6 @@ async function startMultiDaemon(opts = {}) {
   const boundaryListeners = [];
   let boundaryFlushing = false;
   let pushRequested = false;
-  let shippedFingerprint = "";
   let settleRunning = false;
   let boundaryFlushStartedAt = 0;
   let boundaryFlushStage = "";
@@ -94149,16 +94782,63 @@ async function startMultiDaemon(opts = {}) {
       });
     }
   };
-  const instanceFingerprint = () => {
+  const SHIP_MARK_KEY = "watermark:instance-ship";
+  const sendableSeq = (store) => store.changeSeq ? store.changeSeq() - store.changeSeq([EXPOSURE_SCOPE]) : null;
+  const shipLanes = () => {
     const cfg2 = loadConfig();
-    const parts2 = [];
+    const lanes = [], destinations = [], held = [];
     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()}`}`);
+      const consent = effectiveConsent(cfg2, r.engine.profile);
+      if (!consent.sync) continue;
+      const identity = identityFor(liveWorkspaceEntry(r.entry));
+      const destination = `${opts.cloudUrl ?? identity.profile?.cloudUrl ?? cfg2.cloudUrl ?? ""}|${identity.profileName ?? ""}`;
+      destinations.push(destination);
+      const quarantined = r.engine.quarantinedSessions().slice().sort();
+      held.push(...quarantined);
+      let ignoreFile = "";
+      try {
+        ignoreFile = readFileSync40(join47(r.root, ".errataignore"), "utf8");
+      } catch {
+      }
+      const retryInputs = JSON.stringify([
+        quarantined,
+        DAEMON_VERSION,
+        ignoreFile,
+        r.engine.profile.ignoreExtra ?? [],
+        r.engine.profile.projectHistoryCorrectionCursor ?? 0
+      ]);
+      const context = JSON.stringify([destination, consent.contributePackages ?? null, loadProfile(r.root)?.projectId ?? r.engine.profile.projectId ?? null]);
+      const fp = r.engine.store.labelFingerprint?.(INSTANCE_LABELS);
+      lanes.push({ store: r.engine.store, fp: fp === void 0 ? null : `${context}#${fp}`, seq: sendableSeq(r.engine.store), held: retryInputs });
+    }
+    if (lanes.length === 0) return lanes;
+    const shared = sharedStore.labelFingerprint?.(["RootCause"]);
+    const sharedContext = JSON.stringify([...new Set(destinations)].sort());
+    lanes.push({ store: sharedStore, fp: shared === void 0 ? null : `${sharedContext}#${shared}`, seq: sendableSeq(sharedStore), held: JSON.stringify([[...new Set(held)].sort(), DAEMON_VERSION]) });
+    return lanes;
+  };
+  const shipMark = (store) => {
+    try {
+      return JSON.parse(store.getMeta?.(SHIP_MARK_KEY) ?? "null");
+    } catch {
+      return null;
     }
-    if (parts2.length === 0) return "";
-    parts2.push(`shared=${sharedStore.labelFingerprint?.(["RootCause"]) ?? `?${Date.now()}`}`);
-    return parts2.join("|");
+  };
+  const unshipped = (lanes, retries) => lanes.filter((l) => {
+    const mark = l.fp === null ? null : shipMark(l.store);
+    if (!mark || mark.fp !== l.fp) return true;
+    if (!retries) return false;
+    return !mark.ok || l.seq === null || mark.seq !== l.seq || mark.held !== l.held || mark.retryAt !== void 0 && mark.retryAt <= Date.now();
+  });
+  const recordShipped = (lanes, result) => {
+    const mark = (l) => ({
+      fp: l.fp,
+      ok: !result.errors?.length,
+      ...result.retryAt !== void 0 ? { retryAt: result.retryAt } : {},
+      ...l.seq !== null ? { seq: l.seq } : {},
+      held: l.held
+    });
+    for (const l of lanes) if (l.fp !== null) l.store.setMeta?.(SHIP_MARK_KEY, JSON.stringify(mark(l)));
   };
   const runSettle = async () => {
     if (settleRunning) return;
@@ -94311,7 +94991,7 @@ async function startMultiDaemon(opts = {}) {
     records.push(rec);
     void ambientLinkAll();
     try {
-      writeFileSync28(
+      writeFileSync29(
         rec.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -94380,11 +95060,19 @@ async function startMultiDaemon(opts = {}) {
   const strandedCount = (r) => {
     const hit = strandedCache.get(r.id);
     if (hit && Date.now() - hit.at < STRANDED_TTL_MS) return hit.count;
+    const store = r.engine.store;
+    const standing = standingStrandedCount(store);
+    if (standing !== null) {
+      strandedCache.set(r.id, { at: Date.now(), count: standing });
+      return standing;
+    }
     if (!strandedRefreshing.has(r.id)) {
       strandedRefreshing.add(r.id);
+      const seq = store.changeSeq?.();
       const finish = (count) => {
         strandedCache.set(r.id, { at: Date.now(), count });
         strandedRefreshing.delete(r.id);
+        recordStrandedCount(store, seq, count);
       };
       if (consolidateWorker && r.engine.paths.castalia !== ":memory:") {
         consolidateWorker.run({ kind: "strandedCount", sharedDbPath, castaliaPath: r.engine.paths.castalia }).then((n) => finish(Number(n))).catch(() => {
@@ -94690,7 +95378,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync28(
+    writeFileSync29(
       lockPath,
       daemonLockPayload({ pid: process.pid, webUiUrl: baseUrl, processStartedAt: PROCESS_STARTED_AT, entry: SELF_ENTRY, version: DAEMON_VERSION }),
       "utf8"
@@ -94699,7 +95387,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync28(
+      writeFileSync29(
         r.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -94739,7 +95427,15 @@ async function startMultiDaemon(opts = {}) {
   });
   const revisionBacklog = /* @__PURE__ */ new Set();
   const lastAnchorPull = /* @__PURE__ */ new Map();
-  const pullProjectAnchors = async (r, client, salt) => {
+  const anchorPullInFlight = /* @__PURE__ */ new Map();
+  const pullProjectAnchors = (r, client, salt) => {
+    const running = anchorPullInFlight.get(r.root);
+    if (running) return running;
+    const pull = pullProjectAnchorsOnce(r, client, salt).finally(() => anchorPullInFlight.delete(r.root));
+    anchorPullInFlight.set(r.root, pull);
+    return pull;
+  };
+  const pullProjectAnchorsOnce = async (r, client, salt) => {
     const donePass = markPass(`anchor-pull:${r.engine.profile.name}`);
     const pullStartedAt = Date.now();
     const beforeCorrections = r.engine.profile.projectHistoryCorrectionCursor ?? 0;
@@ -94755,10 +95451,13 @@ async function startMultiDaemon(opts = {}) {
       for (const record2 of records) record2.engine.markContextDirty();
     }
     try {
-      const revision = await syncHistoryRevision({ root: r.root, profile: r.engine.profile, store: r.engine.store, cloud: client, salt });
-      if (revision.remaining) revisionBacklog.add(r.root);
-      else revisionBacklog.delete(r.root);
-      if (revision.changed) r.engine.markContextDirty();
+      if (!r.engine.storeReconciled()) revisionBacklog.add(r.root);
+      else {
+        const revision = await syncHistoryRevision({ root: r.root, profile: r.engine.profile, store: r.engine.store, cloud: client, salt });
+        if (revision.remaining) revisionBacklog.add(r.root);
+        else revisionBacklog.delete(r.root);
+        if (revision.changed) r.engine.markContextDirty();
+      }
     } catch (err2) {
       console.warn(`[errata] history revision reconciliation failed for ${r.engine.profile.name}: ${err2 instanceof Error ? err2.message : String(err2)}`);
     }
@@ -95248,6 +95947,10 @@ async function startMultiDaemon(opts = {}) {
       };
       let uploaded = 0;
       const errors = [];
+      let retryAt = null;
+      const retryBy = (at) => {
+        if (at !== null && (retryAt === null || at < retryAt)) retryAt = at;
+      };
       const workerFor = (r) => consolidateWorker && r.engine.paths.castalia !== ":memory:" ? consolidateWorker : null;
       const buildContextBatch = async (r, input) => {
         const w = workerFor(r);
@@ -95371,6 +96074,7 @@ async function startMultiDaemon(opts = {}) {
                   }
                 });
                 if (p.blockedNodeIds?.length) {
+                  retryBy(Date.now());
                   console.log(
                     `[sync\u2192cloud] [${projectName}] context: ${p.blockedNodeIds.length} node(s) refused by an edge/CDN filter on content \u2014 left pending, will retry`
                   );
@@ -95402,6 +96106,7 @@ async function startMultiDaemon(opts = {}) {
         });
         const parkPath = edgeParkPath(r.engine.paths.configDir, destinationKey);
         const parkQueue = loadEdgePark(parkPath);
+        retryBy(nextEdgeParkChange(parkQueue));
         const built = await buildInstanceBatch(r, {
           edgeHolds: edgeHolds(parkQueue, Date.now()),
           destinationKey,
@@ -95471,6 +96176,7 @@ async function startMultiDaemon(opts = {}) {
               }
             });
             if (blocked.size > 0) {
+              retryBy(Date.now());
               console.log(
                 `[sync\u2192cloud] [${projectName}] instances: ${blocked.size} node(s) refused by an edge/CDN filter on content \u2014 left pending, will retry. First: ${store.getNode([...blocked][0])?.description.slice(0, 120) ?? [...blocked][0]}`
               );
@@ -95506,6 +96212,7 @@ async function startMultiDaemon(opts = {}) {
               Date.now()
             );
             saveEdgePark(parkPath, settled.queue);
+            retryBy(nextEdgeParkChange(settled.queue));
             const edgeCounts = settled.counts;
             if (rejectedEdges.length > 0) {
               const byReason = /* @__PURE__ */ new Map();
@@ -95632,7 +96339,7 @@ async function startMultiDaemon(opts = {}) {
           });
         }
       }
-      return { uploaded, ...errors.length > 0 ? { errors } : {} };
+      return { uploaded, ...errors.length > 0 ? { errors } : {}, ...retryAt !== null ? { retryAt } : {} };
     },
     async backfillCausalEdges() {
       if (!loadConfig().consent.sync) return { accepted: 0, rejected: 0, skipped: "consent-off" };
@@ -95707,9 +96414,9 @@ async function startMultiDaemon(opts = {}) {
       beginFlush("instances");
       try {
         flushStage("instances");
-        const startedFrom = instanceFingerprint();
-        const inst = await daemon.syncInstancesPublic();
-        shippedFingerprint = startedFrom;
+        const lanes = shipLanes();
+        const inst = lanes.length > 0 && unshipped(lanes, true).length === 0 ? { uploaded: 0, skipped: "unchanged", errors: void 0 } : await daemon.syncInstancesPublic();
+        if (!inst.skipped) recordShipped(lanes, inst);
         flushStage("skills");
         const skills = await daemon.syncSkillsAll();
         return {
@@ -95723,8 +96430,8 @@ async function startMultiDaemon(opts = {}) {
       }
     },
     pendingLiveFingerprint() {
-      const fp = instanceFingerprint();
-      return fp && fp !== shippedFingerprint ? fp : null;
+      const pending = unshipped(shipLanes(), false);
+      return pending.length ? pending.map((l) => l.fp ?? `?${Date.now()}`).join("|") : null;
     },
     async liveShip() {
       if (!liveSyncEnabled()) return { uploaded: 0, skipped: "disabled" };
@@ -95740,9 +96447,9 @@ async function startMultiDaemon(opts = {}) {
       }
       beginFlush("live");
       try {
-        const startedFrom = instanceFingerprint();
+        const lanes = shipLanes();
         const inst = await daemon.syncInstancesPublic();
-        shippedFingerprint = startedFrom;
+        if (!inst.skipped) recordShipped(lanes, inst);
         return {
           uploaded: inst.uploaded,
           ...inst.skipped ? { skipped: inst.skipped } : {},
@@ -95792,7 +96499,9 @@ async function startMultiDaemon(opts = {}) {
       flushStage("triage");
       const triage = await daemon.syncTriagePublic();
       flushStage("instances");
+      const lanes = shipLanes();
       const instances = await daemon.syncInstancesPublic();
+      if (!instances.skipped) recordShipped(lanes, instances);
       flushStage("edge-backfill");
       const edgeBackfill = await daemon.backfillCausalEdges();
       return c.json({ principles, triage, instances, edgeBackfill });
@@ -96217,15 +96926,15 @@ function shouldUseOAuthLogin(flags2, env2 = process.env) {
 import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/codex-runtime.ts
-import { readdirSync as readdirSync13, statSync as statSync11 } from "node:fs";
-import { join as join45 } from "node:path";
+import { readdirSync as readdirSync13, statSync as statSync12 } from "node:fs";
+import { join as join48 } from "node:path";
 function resolveCodexExecutable(options = {}) {
   const platform = options.platform ?? process.platform;
   const env2 = options.env ?? process.env;
   if (platform !== "win32") return "codex";
   const fileTime = (path3) => {
     try {
-      const s = statSync11(path3);
+      const s = statSync12(path3);
       return s.isFile() ? s.mtimeMs : null;
     } catch {
       return null;
@@ -96233,13 +96942,13 @@ function resolveCodexExecutable(options = {}) {
   };
   for (const dir of (env2["PATH"] ?? env2["Path"] ?? "").split(";")) {
     if (!dir.trim()) continue;
-    const path3 = join45(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
+    const path3 = join48(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
     if (fileTime(path3) !== null) return path3;
   }
   if (!env2["LOCALAPPDATA"]) return "codex";
-  const root = join45(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
+  const root = join48(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
   try {
-    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join45(root, entry.name, "codex.exe")).map((path3) => ({ path: path3, mtime: fileTime(path3) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
+    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join48(root, entry.name, "codex.exe")).map((path3) => ({ path: path3, mtime: fileTime(path3) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
     return candidates[0]?.path ?? "codex";
   } catch {
     return "codex";
@@ -96378,14 +97087,14 @@ async function diagnoseInstallation(cfg, dependencies) {
 }
 
 // src/credential-scan.ts
-import { readFileSync as readFileSync39, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync42, statSync as statSync13 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join47 } from "node:path";
+import { join as join50 } from "node:path";
 
 // src/claude-statusline.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync38, writeFileSync as writeFileSync29 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync41, writeFileSync as writeFileSync30 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname16, join as join46 } from "node:path";
+import { dirname as dirname17, join as join49 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
 import { readFileSync } from 'node:fs';
 
@@ -96433,8 +97142,8 @@ function isSameInstall(value, relay) {
   return command.includes(relay.replace(/\\/g, "/").toLowerCase());
 }
 function userClaudeSettingsPath() {
-  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join46(homedir7(), ".claude");
-  return join46(base, "settings.json");
+  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join49(homedir7(), ".claude");
+  return join49(base, "settings.json");
 }
 function ensureUserStatusLine(opts) {
   const env2 = opts.env ?? process.env;
@@ -96444,21 +97153,21 @@ function ensureUserStatusLine(opts) {
   let settings = {};
   if (existsSync35(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync38(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync41(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
       return "unreadable";
     }
   }
-  const relay = join46(opts.relayDir, STATUSLINE_RELAY_FILE);
+  const relay = join49(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";
   mkdirSync9(opts.relayDir, { recursive: true });
-  if (!existsSync35(relay) || readFileSync38(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
-    writeFileSync29(relay, STATUSLINE_RELAY_SOURCE, "utf8");
+  if (!existsSync35(relay) || readFileSync41(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+    writeFileSync30(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const nodePath = opts.nodePath ?? process.execPath;
   const next = {
@@ -96469,8 +97178,8 @@ function ensureUserStatusLine(opts) {
     return ownMain ? "kept-own" : "unchanged";
   }
   Object.assign(settings, next);
-  mkdirSync9(dirname16(settingsPath), { recursive: true });
-  writeFileSync29(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync9(dirname17(settingsPath), { recursive: true });
+  writeFileSync30(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return "installed";
 }
 function describeStatusLineOutcome(outcome) {
@@ -96511,36 +97220,36 @@ function findCredentialLines(text) {
 function harnessConfigPaths(root) {
   const env2 = process.env;
   const home = homedir8();
-  const codexHome = env2["CODEX_HOME"] || join47(home, ".codex");
-  const geminiHome = join47(env2["GEMINI_CLI_HOME"] ?? home, ".gemini");
+  const codexHome = env2["CODEX_HOME"] || join50(home, ".codex");
+  const geminiHome = join50(env2["GEMINI_CLI_HOME"] ?? home, ".gemini");
   return [
     // Claude Code: user settings, `claude mcp add` (local/user scope), project.
     userClaudeSettingsPath(),
-    join47(env2["CLAUDE_CONFIG_DIR"] ?? home, ".claude.json"),
-    join47(root, ".claude", "settings.json"),
-    join47(root, ".claude", "settings.local.json"),
-    join47(root, ".mcp.json"),
+    join50(env2["CLAUDE_CONFIG_DIR"] ?? home, ".claude.json"),
+    join50(root, ".claude", "settings.json"),
+    join50(root, ".claude", "settings.local.json"),
+    join50(root, ".mcp.json"),
     // Codex
-    join47(codexHome, "config.toml"),
-    join47(root, ".codex", "config.toml"),
+    join50(codexHome, "config.toml"),
+    join50(root, ".codex", "config.toml"),
     // Gemini CLI
-    join47(geminiHome, "settings.json"),
-    join47(root, ".gemini", "settings.json"),
+    join50(geminiHome, "settings.json"),
+    join50(root, ".gemini", "settings.json"),
     // Cursor
-    join47(home, ".cursor", "mcp.json"),
-    join47(root, ".cursor", "mcp.json"),
+    join50(home, ".cursor", "mcp.json"),
+    join50(root, ".cursor", "mcp.json"),
     // VS Code (user profile mcp.json + workspace)
-    join47(vscodeUserDir(home, env2), "mcp.json"),
-    join47(root, ".vscode", "mcp.json"),
+    join50(vscodeUserDir(home, env2), "mcp.json"),
+    join50(root, ".vscode", "mcp.json"),
     // OpenCode (XDG on every platform; the daemon's installer writes the project one)
-    join47(env2["XDG_CONFIG_HOME"] ?? join47(home, ".config"), "opencode", "opencode.json"),
-    join47(root, "opencode.json")
+    join50(env2["XDG_CONFIG_HOME"] ?? join50(home, ".config"), "opencode", "opencode.json"),
+    join50(root, "opencode.json")
   ];
 }
 function vscodeUserDir(home, env2) {
-  if (process.platform === "win32") return join47(env2["APPDATA"] ?? join47(home, "AppData", "Roaming"), "Code", "User");
-  if (process.platform === "darwin") return join47(home, "Library", "Application Support", "Code", "User");
-  return join47(env2["XDG_CONFIG_HOME"] ?? join47(home, ".config"), "Code", "User");
+  if (process.platform === "win32") return join50(env2["APPDATA"] ?? join50(home, "AppData", "Roaming"), "Code", "User");
+  if (process.platform === "darwin") return join50(home, "Library", "Application Support", "Code", "User");
+  return join50(env2["XDG_CONFIG_HOME"] ?? join50(home, ".config"), "Code", "User");
 }
 function scanHarnessConfigs(paths, read2 = readBounded) {
   const findings = [];
@@ -96555,9 +97264,9 @@ function scanHarnessConfigs(paths, read2 = readBounded) {
 }
 function readBounded(path3) {
   try {
-    const stat4 = statSync12(path3);
+    const stat4 = statSync13(path3);
     if (!stat4.isFile() || stat4.size > MAX_SCAN_BYTES) return null;
-    return readFileSync39(path3, "utf8");
+    return readFileSync42(path3, "utf8");
   } catch {
     return null;
   }
@@ -96582,14 +97291,14 @@ function credentialHygieneCheck(scan2) {
 
 // src/codex-doctor.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync41, statSync as statSync13 } from "node:fs";
-import { join as join49 } from "node:path";
+import { readFileSync as readFileSync44, statSync as statSync14 } from "node:fs";
+import { join as join52 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync40, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync30 } from "node:fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync43, renameSync as renameSync8, unlinkSync as unlinkSync5, writeFileSync as writeFileSync31 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { join as join48 } from "node:path";
+import { join as join51 } from "node:path";
 
 // src/hook-commands.ts
 function hookCurlCommand(port, path3 = "/api/hook") {
@@ -96793,34 +97502,34 @@ function buildCodexRelaySource(workspaceRoot) {
 init_checkout_root();
 var CODEX_HOOK_REVIEW_HELP = "Codex desktop: Settings > Hooks, select this project, expand each event and Trust the Errata hook. CLI users can use /hooks.";
 function writeRelay(file2, source) {
-  if (existsSync36(file2) && readFileSync40(file2, "utf8") === source) return;
+  if (existsSync36(file2) && readFileSync43(file2, "utf8") === source) return;
   const temp = `${file2}.${process.pid}.tmp`;
   try {
-    writeFileSync30(temp, source, { encoding: "utf8", mode: 384 });
-    renameSync7(temp, file2);
+    writeFileSync31(temp, source, { encoding: "utf8", mode: 384 });
+    renameSync8(temp, file2);
   } finally {
     if (existsSync36(temp)) unlinkSync5(temp);
   }
 }
 function refreshCodexRelay(root) {
-  const config2 = join48(root, ".codex", "config.toml");
+  const config2 = join51(root, ".codex", "config.toml");
   if (!existsSync36(config2)) return "absent";
-  const existing = readFileSync40(config2, "utf8");
+  const existing = readFileSync43(config2, "utf8");
   if (!existing.includes(CODEX_HOOKS_BEGIN) && !existing.includes(CODEX_HOOKS_END)) return "absent";
   replaceCodexHooks(existing, "");
-  const relay = join48(root, ".codex", "hooks", "errata-relay.mjs");
-  const prior = existsSync36(relay) ? readFileSync40(relay, "utf8") : "";
+  const relay = join51(root, ".codex", "hooks", "errata-relay.mjs");
+  const prior = existsSync36(relay) ? readFileSync43(relay, "utf8") : "";
   if (prior && !prior.startsWith("// errata-managed: regenerated by errata install-hooks codex")) {
     throw new Error("Codex relay is not Errata-managed; preserved it. Run errata install-hooks codex to explicitly replace it.");
   }
   const source = buildCodexRelaySource(checkoutRootOf(root));
   if (prior === source) return "current";
-  mkdirSync10(join48(root, ".codex", "hooks"), { recursive: true });
+  mkdirSync10(join51(root, ".codex", "hooks"), { recursive: true });
   writeRelay(relay, source);
   return "updated";
 }
-function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join48(homedir9(), ".codex")) {
-  return existsSync36(join48(root, ".codex")) || existsSync36(codexHome);
+function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join51(homedir9(), ".codex")) {
+  return existsSync36(join51(root, ".codex")) || existsSync36(codexHome);
 }
 function replaceCodexHooks(existing, block) {
   const begin = existing.indexOf(CODEX_HOOKS_BEGIN);
@@ -96836,14 +97545,14 @@ function replaceCodexHooks(existing, block) {
   return existing.trimEnd() + (existing.trim() ? "\n\n" : "") + block;
 }
 function writeCodexHooks(root, port, nodePath = process.execPath) {
-  const dir = join48(root, ".codex");
-  const file2 = join48(dir, "config.toml");
-  const relay = join48(dir, "hooks", "errata-relay.mjs");
+  const dir = join51(root, ".codex");
+  const file2 = join51(dir, "config.toml");
+  const relay = join51(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync36(file2) ? readFileSync40(file2, "utf8") : "", block);
-  mkdirSync10(join48(dir, "hooks"), { recursive: true });
+  const final = replaceCodexHooks(existsSync36(file2) ? readFileSync43(file2, "utf8") : "", block);
+  mkdirSync10(join51(dir, "hooks"), { recursive: true });
   writeRelay(relay, buildCodexRelaySource(checkoutRootOf(root)));
-  if (!existsSync36(file2) || readFileSync40(file2, "utf8") !== final) writeFileSync30(file2, final, "utf8");
+  if (!existsSync36(file2) || readFileSync43(file2, "utf8") !== final) writeFileSync31(file2, final, "utf8");
   return file2;
 }
 
@@ -96852,7 +97561,7 @@ init_checkout_root();
 function inspectCodexRelay(cwd) {
   const root = nearestGitRoot(cwd) ?? cwd;
   try {
-    const source = readFileSync41(join49(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
+    const source = readFileSync44(join52(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
     if (source === buildCodexRelaySource(checkoutRootOf(root))) {
       return { id: "codex_relay", status: "pass", detail: "Installed Codex relay matches this Errata version" };
     }
@@ -96863,8 +97572,8 @@ function inspectCodexRelay(cwd) {
 function inspectCodexContext(cwd) {
   const root = checkoutRootOf(nearestGitRoot(cwd) ?? cwd);
   try {
-    const file2 = join49(root, ".errata", "context.md");
-    if (statSync13(file2).size <= 128 * 1024 && readFileSync41(file2, "utf8").trim()) {
+    const file2 = join52(root, ".errata", "context.md");
+    if (statSync14(file2).size <= 128 * 1024 && readFileSync44(file2, "utf8").trim()) {
       return { id: "codex_context", status: "pass", detail: "Saved workspace context is readable by the relay; this does not prove live daemon freshness" };
     }
   } catch {
@@ -97041,11 +97750,11 @@ function consolidationGapMs(lastPassMs, policy) {
 }
 
 // src/codex-context-plugin.ts
-import { createHash as createHash20 } from "node:crypto";
-import { cpSync as cpSync2, existsSync as existsSync37, mkdirSync as mkdirSync11, readFileSync as readFileSync42, renameSync as renameSync8, writeFileSync as writeFileSync31 } from "node:fs";
+import { createHash as createHash21 } from "node:crypto";
+import { cpSync as cpSync2, existsSync as existsSync37, mkdirSync as mkdirSync11, readFileSync as readFileSync45, renameSync as renameSync9, writeFileSync as writeFileSync32 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { join as join50 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { join as join53 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string4, ptr) {
@@ -97127,7 +97836,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
   }
   return ptr;
 }
-function skipUntil(str, ptr, sep6, end, banNewLines = false) {
+function skipUntil(str, ptr, sep7, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -97136,7 +97845,7 @@ function skipUntil(str, ptr, sep6, end, banNewLines = false) {
     let c = str[i2];
     if (c === "#") {
       i2 = indexOfNewline(str, i2);
-    } else if (c === sep6) {
+    } else if (c === sep7) {
       return i2 + 1;
     } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i2 + 1] === "\n")) {
       return i2;
@@ -97742,23 +98451,23 @@ var NAME = "errata-context";
 var PREFIX2 = `./.errata/plugins/${NAME}/`;
 var object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 function readText(file2) {
-  return existsSync37(file2) ? readFileSync42(file2, "utf8") : "";
+  return existsSync37(file2) ? readFileSync45(file2, "utf8") : "";
 }
 function writeChanged(file2, content) {
   if (readText(file2) === content) return;
   const temp = `${file2}.${process.pid}.tmp`;
-  writeFileSync31(temp, content, "utf8");
-  renameSync8(temp, file2);
+  writeFileSync32(temp, content, "utf8");
+  renameSync9(temp, file2);
 }
 function bundledContextPlugin() {
-  const packaged = fileURLToPath2(new URL("./resources/context-plugin/", import.meta.url));
-  if (existsSync37(join50(packaged, ".codex-plugin/plugin.json"))) return packaged;
-  return fileURLToPath2(new URL("../dist/resources/context-plugin/", import.meta.url));
+  const packaged = fileURLToPath3(new URL("./resources/context-plugin/", import.meta.url));
+  if (existsSync37(join53(packaged, ".codex-plugin/plugin.json"))) return packaged;
+  return fileURLToPath3(new URL("../dist/resources/context-plugin/", import.meta.url));
 }
 function refreshCodexContextPlugin(root) {
-  const file2 = join50(root, ".agents", "plugins", "marketplace.json");
+  const file2 = join53(root, ".agents", "plugins", "marketplace.json");
   if (!existsSync37(file2)) return false;
-  const marketplace = JSON.parse(readFileSync42(file2, "utf8"));
+  const marketplace = JSON.parse(readFileSync45(file2, "utf8"));
   const entries = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
   const entry = entries.map(object2).find((value) => value.name === NAME && String(object2(value.source).path).startsWith(PREFIX2));
   if (!entry) return false;
@@ -97769,24 +98478,24 @@ function refreshCodexContextPlugin(root) {
 function installCodexContextPlugin(root, options = {}) {
   const bundle = options.bundle ?? bundledContextPlugin();
   const manifest = JSON.parse(
-    readFileSync42(join50(bundle, ".codex-plugin/plugin.json"), "utf8")
+    readFileSync45(join53(bundle, ".codex-plugin/plugin.json"), "utf8")
   );
   if (manifest.name !== NAME || typeof manifest.version !== "string" || !/^[\w.-]+$/.test(manifest.version)) {
     throw new Error("Invalid bundled Errata Context manifest.");
   }
-  const checksums = readFileSync42(join50(bundle, "SHA256SUMS"), "utf8");
+  const checksums = readFileSync45(join53(bundle, "SHA256SUMS"), "utf8");
   for (const line of checksums.trim().split("\n")) {
     const match2 = /^([a-f0-9]{64})  ([\w./-]+)$/.exec(line);
     if (!match2 || match2[2].startsWith("/") || match2[2].split("/").includes("..")) {
       throw new Error("Invalid bundled Errata Context checksum manifest.");
     }
-    const actual = createHash20("sha256").update(readFileSync42(join50(bundle, match2[2]))).digest("hex");
+    const actual = createHash21("sha256").update(readFileSync45(join53(bundle, match2[2]))).digest("hex");
     if (actual !== match2[1])
       throw new Error(`Bundled Errata Context checksum mismatch: ${match2[2]}`);
   }
-  const release = `${manifest.version}-${createHash20("sha256").update(checksums).digest("hex").slice(0, 12)}`;
-  const plugin = join50(root, ".errata", "plugins", NAME, release);
-  const marketplaceFile = join50(root, ".agents", "plugins", "marketplace.json");
+  const release = `${manifest.version}-${createHash21("sha256").update(checksums).digest("hex").slice(0, 12)}`;
+  const plugin = join53(root, ".errata", "plugins", NAME, release);
+  const marketplaceFile = join53(root, ".agents", "plugins", "marketplace.json");
   const priorMarketplace = readText(marketplaceFile);
   const marketplace = priorMarketplace ? JSON.parse(priorMarketplace) : {
     name: "errata-local",
@@ -97807,12 +98516,12 @@ function installCodexContextPlugin(root, options = {}) {
     );
   }
   const key = `${NAME}@${marketplace.name}`;
-  const configFile = join50(root, ".codex", "config.toml");
+  const configFile = join53(root, ".codex", "config.toml");
   const config2 = readText(configFile);
   const parsed = parse4(config2);
   const plugins = object2(parsed.plugins);
-  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join50(homedir10(), ".codex");
-  const globalPlugins = object2(parse4(readText(join50(codexHome, "config.toml"))).plugins);
+  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join53(homedir10(), ".codex");
+  const globalPlugins = object2(parse4(readText(join53(codexHome, "config.toml"))).plugins);
   const disabledGlobally = Object.entries(globalPlugins).some(
     ([name2, value]) => (name2 === NAME || name2.startsWith(`${NAME}@`)) && object2(value).enabled === false
   );
@@ -97836,13 +98545,13 @@ enabled = ${enabled}
   mkdirSync11(plugin, { recursive: true });
   cpSync2(bundle, plugin, { recursive: true });
   writeChanged(
-    join50(plugin, ".mcp.json"),
+    join53(plugin, ".mcp.json"),
     JSON.stringify(
       {
         mcpServers: {
           errata_context: {
             command: options.nodePath ?? process.execPath,
-            args: [join50(plugin, "dist", "mcp-server.mjs")],
+            args: [join53(plugin, "dist", "mcp-server.mjs")],
             env: { ERRATA_WORKSPACE: root, ERRATA_CONTEXT_VERSION: manifest.version }
           }
         }
@@ -97851,8 +98560,8 @@ enabled = ${enabled}
       2
     ) + "\n"
   );
-  mkdirSync11(join50(root, ".agents", "plugins"), { recursive: true });
-  mkdirSync11(join50(root, ".codex"), { recursive: true });
+  mkdirSync11(join53(root, ".agents", "plugins"), { recursive: true });
+  mkdirSync11(join53(root, ".codex"), { recursive: true });
   writeChanged(marketplaceFile, JSON.stringify(marketplace, null, 2) + "\n");
   writeChanged(configFile, nextConfig);
   return { plugin, enabled, marketplace: marketplaceFile };
@@ -97860,15 +98569,15 @@ enabled = ${enabled}
 
 // src/codex-hook-refresh.ts
 init_checkout_root();
-import { existsSync as existsSync38, readdirSync as readdirSync14, readFileSync as readFileSync43 } from "node:fs";
-import { dirname as dirname17, join as join51, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync38, readdirSync as readdirSync14, readFileSync as readFileSync46 } from "node:fs";
+import { dirname as dirname18, join as join54, resolve as resolve8 } from "node:path";
 init_registry();
 function codexHookRoots(roots) {
   const found = new Set(roots.map((root) => resolve8(root)));
   for (const root of [...found]) {
     const main2 = mainCheckoutOfWorktree(root) ?? root;
     found.add(main2);
-    const dir = join51(main2, ".git", "worktrees");
+    const dir = join54(main2, ".git", "worktrees");
     if (!existsSync38(dir)) continue;
     let names;
     try {
@@ -97878,7 +98587,7 @@ function codexHookRoots(roots) {
     }
     for (const name2 of names) {
       try {
-        const checkout = dirname17(readFileSync43(join51(dir, name2, "gitdir"), "utf8").trim());
+        const checkout = dirname18(readFileSync46(join54(dir, name2, "gitdir"), "utf8").trim());
         if (mainCheckoutOfWorktree(checkout) === main2) found.add(checkout);
       } catch {
       }
@@ -97900,50 +98609,50 @@ function refreshInstalledCodexRelays(roots = listWorkspaceEntries().map((entry)
 }
 
 // src/claude-mods.ts
-import { createHash as createHash21 } from "node:crypto";
-import { cpSync as cpSync3, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync44, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync14, writeFileSync as writeFileSync32 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname18, join as join52, relative as relative8, resolve as resolve9, sep as sep5 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { createHash as createHash22 } from "node:crypto";
+import { cpSync as cpSync3, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync47, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync15, writeFileSync as writeFileSync33 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname19, join as join55, relative as relative7, resolve as resolve9, sep as sep6 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 var CLAUDE_PLUGIN_DIRS_ENV = "CLAUDE_CODE_PLUGIN_DIRS";
 var HASH_FILE = ".errata-mod-hash";
 function bundledClaudeModsDir() {
   const rel = import.meta.url.endsWith(".mjs") ? "./resources/claude-mods/" : "../claude-mods/";
-  return fileURLToPath3(new URL(rel, import.meta.url));
+  return fileURLToPath4(new URL(rel, import.meta.url));
 }
 function isEngineOwned(relPath) {
-  const p = relPath.split(sep5).join("/");
+  const p = relPath.split(sep6).join("/");
   return p === ".claude-plugin/types" || p.startsWith(".claude-plugin/types/") || p === HASH_FILE;
 }
 function listFiles(root, dir = root) {
   const out2 = [];
   for (const name2 of readdirSync15(dir)) {
-    const abs = join52(dir, name2);
-    if (isEngineOwned(relative8(root, abs))) continue;
-    if (statSync14(abs).isDirectory()) out2.push(...listFiles(root, abs));
+    const abs = join55(dir, name2);
+    if (isEngineOwned(relative7(root, abs))) continue;
+    if (statSync15(abs).isDirectory()) out2.push(...listFiles(root, abs));
     else out2.push(abs);
   }
   return out2;
 }
 function modHash(dir) {
-  const h = createHash21("sha256");
+  const h = createHash22("sha256");
   for (const abs of listFiles(dir).sort()) {
-    h.update(relative8(dir, abs).split(sep5).join("/"));
+    h.update(relative7(dir, abs).split(sep6).join("/"));
     h.update("\0");
-    h.update(readFileSync44(abs));
+    h.update(readFileSync47(abs));
     h.update("\0");
   }
   return h.digest("hex");
 }
 function bundledMods(bundleDir) {
   if (!existsSync39(bundleDir)) return [];
-  return readdirSync15(bundleDir).filter((name2) => existsSync39(join52(bundleDir, name2, ".claude-plugin", "plugin.json")));
+  return readdirSync15(bundleDir).filter((name2) => existsSync39(join55(bundleDir, name2, ".claude-plugin", "plugin.json")));
 }
 function sameDir(a, b) {
   const norm = (p) => resolve9(p).replace(/[\\/]+$/, "").toLowerCase();
   return norm(a) === norm(b);
 }
 function isUnder(path3, root) {
-  const rel = relative8(resolve9(root), resolve9(path3));
+  const rel = relative7(resolve9(root), resolve9(path3));
   return rel !== "" && !rel.startsWith("..") && !rel.includes(":");
 }
 function off(env2) {
@@ -97953,7 +98662,7 @@ function off(env2) {
 function readSettings(path3) {
   if (!existsSync39(path3)) return {};
   try {
-    const parsed = JSON.parse(readFileSync44(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync47(path3, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -97977,13 +98686,13 @@ function currentDirs(settings) {
   return raw2.split(delimiter2).map((s) => s.trim()).filter(Boolean);
 }
 function writeSettings(path3, settings) {
-  mkdirSync12(dirname18(path3), { recursive: true });
-  writeFileSync32(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync12(dirname19(path3), { recursive: true });
+  writeFileSync33(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
 function ensureClaudeMods(opts) {
   const env2 = opts.env ?? process.env;
   const settingsPath = opts.userSettingsPath ?? userClaudeSettingsPath();
-  const modsRoot = join52(opts.installRoot, "claude-mods");
+  const modsRoot = join55(opts.installRoot, "claude-mods");
   if (off(env2)) {
     const settings2 = readSettings(settingsPath);
     if (!settings2) return { kind: "unreadable" };
@@ -98000,14 +98709,14 @@ function ensureClaudeMods(opts) {
   let changed = false;
   const installed = [];
   for (const name2 of names) {
-    const src = join52(bundleDir, name2);
-    const dest = join52(modsRoot, name2);
+    const src = join55(bundleDir, name2);
+    const dest = join55(modsRoot, name2);
     const hash2 = modHash(src);
-    const hashFile = join52(dest, HASH_FILE);
-    if (!existsSync39(hashFile) || readFileSync44(hashFile, "utf8") !== hash2) {
+    const hashFile = join55(dest, HASH_FILE);
+    if (!existsSync39(hashFile) || readFileSync47(hashFile, "utf8") !== hash2) {
       rmSync4(dest, { recursive: true, force: true });
-      cpSync3(src, dest, { recursive: true, filter: (p) => !isEngineOwned(relative8(src, p)) });
-      writeFileSync32(hashFile, hash2, "utf8");
+      cpSync3(src, dest, { recursive: true, filter: (p) => !isEngineOwned(relative7(src, p)) });
+      writeFileSync33(hashFile, hash2, "utf8");
       changed = true;
     }
     installed.push(dest);
@@ -98426,9 +99135,9 @@ function resolveHookPort(explicit) {
       }
     }
   }
-  const settingsPath = join53(ROOT, ".claude", "settings.json");
+  const settingsPath = join56(ROOT, ".claude", "settings.json");
   try {
-    if (existsSync40(settingsPath)) return installedHookPort(readFileSync45(settingsPath, "utf8")) ?? 7891;
+    if (existsSync40(settingsPath)) return installedHookPort(readFileSync48(settingsPath, "utf8")) ?? 7891;
   } catch {
   }
   return 7891;
@@ -98454,13 +99163,13 @@ async function cmdInit() {
     console.log("");
     console.log("installing harness hooks...");
     const { existsSync: existsSync41 } = await import("node:fs");
-    const { join: join54 } = await import("node:path");
+    const { join: join57 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync41(join54(ROOT, ".cursor"))) {
+    if (existsSync41(join57(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
@@ -99683,7 +100392,7 @@ async function cmdReview() {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync45(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync48(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -100422,7 +101131,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync33 } = await import("node:fs");
+  const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync34 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -100435,8 +101144,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync13(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync33(join53(outDir, f.name), f.html, "utf8");
-  const indexPath = join53(outDir, "report.html");
+  for (const f of files) writeFileSync34(join56(outDir, f.name), f.html, "utf8");
+  const indexPath = join56(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(
     `  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`
@@ -100492,7 +101201,7 @@ function spawnDaemonDetached(options = {}) {
   try {
     const logPath = daemonLogPath();
     try {
-      if (statSync15(logPath).size > 5 * 1024 * 1024) renameSync9(logPath, `${logPath}.1`);
+      if (statSync16(logPath).size > 5 * 1024 * 1024) renameSync10(logPath, `${logPath}.1`);
     } catch {
     }
     out2 = openSync3(logPath, "a");
@@ -100561,24 +101270,24 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync46, writeFileSync: writeFileSync33 } = await import("node:fs");
-  const { join: join54 } = await import("node:path");
-  const dir = join54(ROOT, ".opencode", "plugin");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync49, writeFileSync: writeFileSync34 } = await import("node:fs");
+  const { join: join57 } = await import("node:path");
+  const dir = join57(ROOT, ".opencode", "plugin");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join54(dir, "inerrata.js");
+  const file2 = join57(dir, "inerrata.js");
   if (existsSync41(file2)) {
-    const head2 = readFileSync46(file2, "utf8").split("\n")[0] ?? "";
+    const head2 = readFileSync49(file2, "utf8").split("\n")[0] ?? "";
     if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
       console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
       process.exit(2);
     }
   }
-  writeFileSync33(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
-  const cfgFile = join54(ROOT, "opencode.json");
+  writeFileSync34(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
+  const cfgFile = join57(ROOT, "opencode.json");
   let cfg = { $schema: "https://opencode.ai/config.json" };
   if (existsSync41(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync46(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync49(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -100589,7 +101298,7 @@ async function installOpencodePlugin(port) {
   if (!hadErrata) {
     const inv = errataMcpInvocation();
     cfg.mcp["errata"] = { type: "local", command: [inv.command, ...inv.args] };
-    writeFileSync33(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    writeFileSync34(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   }
   console.log(`installed OpenCode plugin \u2192 ${file2}`);
   if (hadErrata) console.log(`  mcp.errata already present in ${cfgFile} \u2014 left untouched`);
@@ -100624,15 +101333,15 @@ function installClaudeMods() {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync46, writeFileSync: writeFileSync33 } = await import("node:fs");
-  const { join: join54 } = await import("node:path");
-  const dir = join54(ROOT, ".claude");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync49, writeFileSync: writeFileSync34 } = await import("node:fs");
+  const { join: join57 } = await import("node:path");
+  const dir = join57(ROOT, ".claude");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join54(dir, "settings.json");
+  const file2 = join57(dir, "settings.json");
   let settings = {};
   if (existsSync41(file2)) {
     try {
-      settings = JSON.parse(readFileSync46(file2, "utf8"));
+      settings = JSON.parse(readFileSync49(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -100681,12 +101390,12 @@ async function installClaudeHooks(port) {
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
   removeProjectStatusLine(settings);
-  writeFileSync33(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync34(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   console.log(`  ${ensureStatusLine(port)}`);
   console.log(`  ${installClaudeMods().line}`);
   await installClaudeMcpConfig();
-  const claudeMd = join54(ROOT, "CLAUDE.md");
+  const claudeMd = join57(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -100698,15 +101407,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync46, writeFileSync: writeFileSync33 } = await import("node:fs");
-  const { join: join54, dirname: dirname19 } = await import("node:path");
-  const file2 = join54(ROOT, ".mcp.json");
-  const dir = dirname19(file2);
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync49, writeFileSync: writeFileSync34 } = await import("node:fs");
+  const { join: join57, dirname: dirname20 } = await import("node:path");
+  const file2 = join57(ROOT, ".mcp.json");
+  const dir = dirname20(file2);
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
   let cfg = {};
   if (existsSync41(file2)) {
     try {
-      cfg = JSON.parse(readFileSync46(file2, "utf8"));
+      cfg = JSON.parse(readFileSync49(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -100714,21 +101423,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync33(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync34(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync46, writeFileSync: writeFileSync33 } = await import("node:fs");
-  const { join: join54 } = await import("node:path");
-  const dir = join54(ROOT, ".cursor");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync49, writeFileSync: writeFileSync34 } = await import("node:fs");
+  const { join: join57 } = await import("node:path");
+  const dir = join57(ROOT, ".cursor");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join54(dir, "mcp.json");
+  const file2 = join57(dir, "mcp.json");
   let cfg = {};
   if (existsSync41(file2)) {
     try {
-      cfg = JSON.parse(readFileSync46(file2, "utf8"));
+      cfg = JSON.parse(readFileSync49(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -100736,7 +101445,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync33(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync34(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -100747,7 +101456,7 @@ async function installCodexHooks(port) {
   const gitRoot = nearestGitRoot(process.cwd());
   const hookRoot = gitRoot && mainCheckoutOfWorktree(gitRoot) ? gitRoot : ROOT;
   const file2 = writeCodexHooks(hookRoot, port);
-  const instructions = writeManagedBlock(join53(hookRoot, "AGENTS.md"), {
+  const instructions = writeManagedBlock(join56(hookRoot, "AGENTS.md"), {
     body: AGENTS_POINTER_BODY,
     stable: true
   });
@@ -101193,9 +101902,9 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile, {
-          atCommit: readGitRefState(join53(r.root, ".git")).sha ?? void 0
+          atCommit: readGitRefState(join56(r.root, ".git")).sha ?? void 0
         });
-        const res = bleedRules(join53(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join56(r.root, ".claude", "rules"), items);
         if (res.written || res.pruned) {
           console.log(
             `[rules:${r.entry.name}] ${res.written} collective principle(s) \u2192 .claude/rules` + (res.pruned ? `, ${res.pruned} pruned` : "")