@adhdev/daemon-standalone 1.0.58-rc.27 → 1.0.58-rc.29

package/dist/index.js

@@ -36885,10 +36885,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "6db781afb0c67986e7f3c0a1fab11fb6c464bfad" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "6db781af" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.27" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-27T08:09:59.178Z" : void 0);
+      const commit = readInjected(true ? "e767bd9b61dce1fd657b98aae517e9c405bdcb92" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "e767bd9b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.29" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-27T16:04:41.136Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38287,11 +38287,11 @@ var require_dist3 = __commonJS({
       const override = env2.ADHDEV_CONFIG_DIR;
       if (!override || !override.trim()) return false;
       const sibling = otherTrackConfigDir(env2, homeDir2);
-      const normalize6 = (p) => {
+      const normalize7 = (p) => {
         const unified = p.trim().replace(/[\\/]+$/, "").replace(/\\/g, "/");
         return platform11 === "win32" ? unified.toLowerCase() : unified;
       };
-      return normalize6(override) === normalize6(sibling);
+      return normalize7(override) === normalize7(sibling);
     }
     function configDirChannelMismatch(resolvedConfigDir, resolvedChannel, hasExplicitChannelSignal) {
       if (hasExplicitChannelSignal) return null;
@@ -40012,7 +40012,7 @@ child.on('exit', () => process.exit(0));
       };
     }
     function buildWrapperCommand(wrapperFile) {
-      return `node ${JSON.stringify(wrapperFile)}`;
+      return `node "${wrapperFile}"`;
     }
     function readBackup(file2) {
       const result = readJsonFile(file2);
@@ -51012,12 +51012,20 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           // 30 d
           TOMBSTONE_RETAIN_MS: 3456e7,
           // 400 d
+          // sync_hot rate window (extension per proposals-v3.5 P24): served+applied
+          // sync bytes reaching SYNC_HOT_BYTES within one SYNC_HOT_WINDOW_MS window
+          // emits one informational sync_hot anomaly (at most one per window).
+          // Observation only — never a throttle: the traffic it flags is normal bulk
+          // catch-up, and suppressing it would only slow legitimate recovery.
+          SYNC_HOT_WINDOW_MS: 6e4,
+          SYNC_HOT_BYTES: 33554432,
+          // 32 MiB per window ≈ 0.5 MiB/s sustained
           durability: "normal"
         };
       }
     });
     var require_canonicalize = __commonJS2({
-      "../../node_modules/canonicalize/lib/canonicalize.js"(exports22, module22) {
+      "../../vendor/seqscribe/node_modules/canonicalize/lib/canonicalize.js"(exports22, module22) {
         "use strict";
         module22.exports = function serialize(object2) {
           if (typeof object2 === "number" && isNaN(object2)) {
@@ -51127,7 +51135,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var hexes;
     var Hash;
     var init_utils = __esm2({
-      "../../node_modules/@noble/hashes/esm/utils.js"() {
+      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/utils.js"() {
         "use strict";
         hasHexBuiltin = /* @__PURE__ */ (() => (
           // @ts-ignore
@@ -51159,7 +51167,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var HashMD;
     var SHA256_IV;
     var init_md = __esm2({
-      "../../node_modules/@noble/hashes/esm/_md.js"() {
+      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/_md.js"() {
         "use strict";
         init_utils();
         HashMD = class extends Hash {
@@ -51269,7 +51277,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var SHA256;
     var sha256;
     var init_sha2 = __esm2({
-      "../../node_modules/@noble/hashes/esm/sha2.js"() {
+      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/sha2.js"() {
         "use strict";
         init_md();
         init_utils();
@@ -51415,7 +51423,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     });
     var sha2562;
     var init_sha256 = __esm2({
-      "../../node_modules/@noble/hashes/esm/sha256.js"() {
+      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/sha256.js"() {
         "use strict";
         init_sha2();
         sha2562 = sha256;
@@ -52009,9 +52017,20 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     });
     function betterSqlite3Handle(db, lockDb) {
       let owned = false;
+      const stmts = /* @__PURE__ */ new Map();
+      const prep = (sql) => {
+        let s2 = stmts.get(sql);
+        if (s2 === void 0) {
+          if (stmts.size >= 512)
+            stmts.clear();
+          s2 = db.prepare(sql);
+          stmts.set(sql, s2);
+        }
+        return s2;
+      };
       return {
         run(sql, params = []) {
-          const stmt = db.prepare(sql);
+          const stmt = prep(sql);
           if (stmt.reader) {
             stmt.all(...params);
             return { changes: 0, lastInsertRowid: 0 };
@@ -52020,10 +52039,10 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           return { changes: r.changes, lastInsertRowid: r.lastInsertRowid };
         },
         get(sql, params = []) {
-          return db.prepare(sql).get(...params);
+          return prep(sql).get(...params);
         },
         all(sql, params = []) {
-          return db.prepare(sql).all(...params);
+          return prep(sql).all(...params);
         },
         transaction(fn) {
           return db.transaction(fn)();
@@ -52063,7 +52082,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var HMAC;
     var hmac;
     var init_hmac = __esm2({
-      "../../node_modules/@noble/hashes/esm/hmac.js"() {
+      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/hmac.js"() {
         "use strict";
         init_utils();
         HMAC = class extends Hash {
@@ -52285,9 +52304,15 @@ The instruction it carried was never delivered to anyone. If it still matters, r
                 this.deps.timers.clearTimeout(c.retryTimer);
                 c.retryTimer = null;
               }
+              this.rejectWaiters(c, misuse("node closed before catch-up"));
             }
             this.consumers.clear();
           }
+          rejectWaiters(c, err) {
+            const ws = c.waiters.splice(0);
+            for (const w of ws)
+              w.reject(err);
+          }
           onEntry(topic, name, cb) {
             if (this.closed)
               throw misuse("node is closed");
@@ -52307,7 +52332,8 @@ The instruction it carried was never delivered to anyone. If it still matters, r
               rerun: false,
               failures: 0,
               retryTimer: null,
-              gone: false
+              gone: false,
+              waiters: []
             };
             this.consumers.set(key2, c);
             this.pump(c);
@@ -52315,9 +52341,102 @@ The instruction it carried was never delivered to anyone. If it still matters, r
               c.gone = true;
               if (c.retryTimer !== null)
                 this.deps.timers.clearTimeout(c.retryTimer);
+              this.rejectWaiters(c, misuse(`consumer unsubscribed before catch-up: ${key2}`));
               this.consumers.delete(key2);
             };
           }
+          // ---- durable-consumer lifecycle (proposals-v3.5 P17–P19) ----
+          isActive(topic, name) {
+            return this.consumers.has(`${topic} ${name}`);
+          }
+          assertInactive(topic, name, op) {
+            if (this.closed)
+              throw misuse("node is closed");
+            this.deps.topics.get(topic);
+            if (this.consumers.has(`${topic} ${name}`))
+              throw misuse(`${op} on active consumer ${topic} ${name} \u2014 unsubscribe first`);
+          }
+          // P17: discard-derived-state rebuild for the SAME stable consumer name.
+          // Inactive-only (registration would race the cursor write); the next
+          // onEntry with this name resumes at the installed boundary. NOTE: the reset
+          // materializes a cursor row, which gates §7.6 archiving from this moment —
+          // re-register promptly, or the row ages into consumer_abandoned.
+          resetConsumer(topic, name, o) {
+            this.assertInactive(topic, name, "resetConsumer");
+            const from = o?.from ?? "earliest-retained";
+            const existed = this.deps.store.cursorsForTopic(topic).some((c) => c.consumer === name);
+            const replayFromRowid = from === "head" ? this.deps.store.maxRowid(topic) : 0;
+            this.deps.store.cursorSet(name, topic, replayFromRowid, new Date(this.deps.clock()).toISOString());
+            return {
+              existed,
+              from,
+              replayFromRowid,
+              archivedRows: from === "earliest-retained" ? this.deps.store.archivedCount(topic) : 0
+            };
+          }
+          // P18: explicit durable-cursor deletion — never implicit (forgetting a
+          // cursor changes at-least-once restart semantics). Inactive-only; a deleted
+          // cursor no longer gates archiving, so the archive floor re-evaluates.
+          deleteConsumer(topic, name) {
+            this.assertInactive(topic, name, "deleteConsumer");
+            const existed = this.deps.store.cursorsForTopic(topic).some((c) => c.consumer === name);
+            if (existed) {
+              this.deps.store.cursorDelete(name, topic);
+              this.onAdvance?.(topic);
+            }
+            return { existed };
+          }
+          listConsumers(topic) {
+            if (this.closed)
+              throw misuse("node is closed");
+            this.deps.topics.get(topic);
+            return this.deps.store.cursorsForTopic(topic).map((c) => ({ ...c, active: this.isActive(topic, c.consumer) }));
+          }
+          // P18 GC: deliberate cleanup of versioned/renamed consumers. Only inactive
+          // cursors are eligible; filters compose (prefix AND inactiveBefore).
+          pruneConsumers(topic, o) {
+            if (this.closed)
+              throw misuse("node is closed");
+            this.deps.topics.get(topic);
+            const pruned = [];
+            for (const c of this.deps.store.cursorsForTopic(topic)) {
+              if (this.isActive(topic, c.consumer))
+                continue;
+              if (o?.prefix !== void 0 && !c.consumer.startsWith(o.prefix))
+                continue;
+              if (o?.inactiveBefore !== void 0) {
+                const at = Date.parse(c.updatedAt);
+                if (!Number.isFinite(at) || at >= o.inactiveBefore)
+                  continue;
+              }
+              this.deps.store.cursorDelete(c.consumer, topic);
+              pruned.push(c.consumer);
+            }
+            if (pruned.length > 0)
+              this.onAdvance?.(topic);
+            return pruned;
+          }
+          // P19: deterministic caught-up signal. Snapshots the topic head NOW and
+          // resolves once the durable cursor reaches it (i.e. every entry through that
+          // head has completed its callback); later appends start a new interval.
+          // Callback failure/backoff delays resolution by construction (the cursor
+          // does not advance); unsubscribe and node close reject.
+          caughtUp(topic, name) {
+            try {
+              if (this.closed)
+                throw misuse("node is closed");
+              this.deps.topics.get(topic);
+              const c = this.consumers.get(`${topic} ${name}`);
+              if (!c)
+                throw misuse(`caughtUp on unregistered consumer ${topic} ${name}`);
+              const through = this.deps.store.maxRowid(topic);
+              if (this.deps.store.cursorGet(name, topic) >= through)
+                return Promise.resolve({ throughRowid: through });
+              return new Promise((resolve31, reject) => c.waiters.push({ through, resolve: resolve31, reject }));
+            } catch (e) {
+              return Promise.reject(e);
+            }
+          }
           notifyApplied(topic) {
             for (const c of this.consumers.values()) {
               if (c.topic === topic)
@@ -52379,6 +52498,14 @@ The instruction it carried was never delivered to anyone. If it still matters, r
                 c.failures = 0;
                 this.deps.store.cursorSet(c.name, c.topic, rowid, new Date(this.deps.clock()).toISOString());
                 onProgress();
+                if (c.waiters.length > 0) {
+                  const done = c.waiters.filter((w) => rowid >= w.through);
+                  if (done.length > 0) {
+                    c.waiters = c.waiters.filter((w) => rowid < w.through);
+                    for (const w of done)
+                      w.resolve({ throughRowid: w.through });
+                  }
+                }
               }
             }
           }
@@ -55888,6 +56015,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     });
     var MAX_WANT_CONCURRENT;
     var ENTRIES_BATCH_MAX;
+    var SYNC_HOTSPOT_TOP_N;
     var SyncEngine;
     var init_sync = __esm2({
       "../../vendor/seqscribe/dist/sync.js"() {
@@ -55898,9 +56026,24 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_session();
         MAX_WANT_CONCURRENT = 4;
         ENTRIES_BATCH_MAX = 100;
+        SYNC_HOTSPOT_TOP_N = 5;
         SyncEngine = class {
           o;
           peers = /* @__PURE__ */ new Map();
+          // P22 observability: cumulative non-applied wire-apply outcomes per topic
+          // (rejected_finality, sealed, forked, dropped_overflow, error) — the spin
+          // was invisible precisely because rejects were silently discarded
+          rejects = /* @__PURE__ */ new Map();
+          // P24 observability: interval throughput counters (drained by stats()) —
+          // the "hot and busy" complement to P22's "hot and stuck" stall signal
+          interval = /* @__PURE__ */ new Map();
+          intervalPairBytes = /* @__PURE__ */ new Map();
+          // `${topic}\u0000${peerId}` → served+applied bytes
+          // sync_hot rate window — informational only, never a throttle (§16
+          // SYNC_HOT_* constants; the traffic it flags is normal bulk catch-up)
+          hotWindowStart = 0;
+          hotWindowBytes = 0;
+          hotEmitted = false;
           finalityHub = null;
           subHub = null;
           directiveHub = null;
@@ -56004,6 +56147,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               wantQueue: [],
               wantedStreams: /* @__PURE__ */ new Set(),
               recoveryProgress: /* @__PURE__ */ new Map(),
+              syncProgress: /* @__PURE__ */ new Map(),
+              stalled: /* @__PURE__ */ new Set(),
               antiEntropyTimer: null,
               probes: /* @__PURE__ */ new Map(),
               known: /* @__PURE__ */ new Map(),
@@ -56030,9 +56175,63 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               peerId: ps.session.peerId,
               state: ps.session.state(),
               dirtyStreams: ps.dirty.size,
-              queuedData: ps.session.queuedData()
+              queuedData: ps.session.queuedData(),
+              stalledStreams: ps.stalled.size
             }));
           }
+          rejectStats(topic) {
+            return { ...this.rejects.get(topic) ?? {} };
+          }
+          // P24 — drain-and-reset: each stats() read returns the counters accumulated
+          // since the previous read, plus the bounded (topic, peer) byte leaderboard.
+          drainIntervalStats() {
+            const topics = new Map(this.interval);
+            this.interval.clear();
+            const hotspots = [...this.intervalPairBytes].map(([k, bytes]) => {
+              const i = k.indexOf("\0");
+              return { topic: k.slice(0, i), peerId: k.slice(i + 1), bytes };
+            }).sort((a, b) => b.bytes - a.bytes || (a.topic < b.topic ? -1 : a.topic > b.topic ? 1 : a.peerId < b.peerId ? -1 : 1)).slice(0, SYNC_HOTSPOT_TOP_N);
+            this.intervalPairBytes.clear();
+            return { topics, hotspots };
+          }
+          counters(topic) {
+            let c = this.interval.get(topic);
+            if (!c) {
+              c = {
+                servedEntries: 0,
+                servedBytes: 0,
+                appliedEntries: 0,
+                appliedBytes: 0,
+                wantRoundsRequested: 0,
+                wantRoundsServed: 0
+              };
+              this.interval.set(topic, c);
+            }
+            return c;
+          }
+          noteThroughput(topic, peerId, entries, bytes, dir) {
+            const c = this.counters(topic);
+            if (dir === "served") {
+              c.servedEntries += entries;
+              c.servedBytes += bytes;
+            } else {
+              c.appliedEntries += entries;
+              c.appliedBytes += bytes;
+            }
+            const pk = `${topic}\0${peerId}`;
+            this.intervalPairBytes.set(pk, (this.intervalPairBytes.get(pk) ?? 0) + bytes);
+            const now = this.o.clock();
+            if (now - this.hotWindowStart >= this.o.constants.SYNC_HOT_WINDOW_MS) {
+              this.hotWindowStart = now;
+              this.hotWindowBytes = 0;
+              this.hotEmitted = false;
+            }
+            this.hotWindowBytes += bytes;
+            if (!this.hotEmitted && this.hotWindowBytes >= this.o.constants.SYNC_HOT_BYTES) {
+              this.hotEmitted = true;
+              this.o.emitAnomaly({ kind: "sync_hot" });
+            }
+          }
           // ---- lifecycle ----
           onReady(s2) {
             const ps = this.peers.get(s2);
@@ -56213,6 +56412,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               }));
               if (!accepted)
                 return;
+              this.noteThroughput(d.topic, ps.session.peerId, batch.length, bytes, "served");
               ps.known.set(key2, last.seq);
               if (done)
                 ps.dirty.delete(key2);
@@ -56257,6 +56457,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
                 fromSeq: recovery ? recoveryFrom : head.contigSeq + 1
               };
               ps.activeWants.set(req, want);
+              this.counters(want.topic).wantRoundsRequested += 1;
               ps.session.request(`WANT:${req}`, () => ({
                 t: "WANT",
                 req,
@@ -56379,6 +56580,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               ps.session.sendControl({ t: "ERR", code: "ERR_ACL_DENIED", ref: m.topic });
               return;
             }
+            this.counters(m.topic).wantRoundsServed += 1;
             if (this.snapshotHub?.maybeOffer(ps.session, m.topic, m.writer, m.fromSeq)) {
               const contig = this.o.core.getStream(m.topic, m.writer).contigSeq;
               ps.session.sendData((mid) => ({
@@ -56443,6 +56645,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               }));
               if (!accepted)
                 return;
+              this.noteThroughput(m.topic, ps.session.peerId, batch.length, bytes, "served");
               from = last.seq + 1;
             }
           }
@@ -56468,6 +56671,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
             if ((ps.known.get(key2) ?? 0) < m.toSeq)
               ps.known.set(key2, m.toSeq);
             const applies = [];
+            const costs = [];
             for (const raw of m.entries) {
               let entry;
               try {
@@ -56479,19 +56683,35 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               }
               if (entry.topic !== m.topic || entry.writer !== m.writer)
                 continue;
-              applies.push(this.o.core.applyExternal(entry, ps.session.peerId).catch(() => void 0));
-            }
-            void Promise.all(applies).then(() => {
+              costs.push(utf8ByteLength(JSON.stringify(entry)));
+              applies.push(this.o.core.applyExternal(entry, ps.session.peerId).catch(() => "error"));
+            }
+            void Promise.all(applies).then((results) => {
+              let appliedN = 0;
+              let appliedB = 0;
+              for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                if (r === "applied" || r === "duplicate" || r === "pending") {
+                  appliedN += 1;
+                  appliedB += costs[i];
+                  continue;
+                }
+                const rec = this.rejects.get(m.topic) ?? {};
+                rec[r] = (rec[r] ?? 0) + 1;
+                this.rejects.set(m.topic, rec);
+              }
+              if (appliedN > 0)
+                this.noteThroughput(m.topic, ps.session.peerId, appliedN, appliedB, "applied");
               if (m.req !== void 0 && m.done) {
                 const want = ps.activeWants.get(m.req);
                 this.finishWant(ps, m.req);
                 if (want) {
                   const head = this.o.core.getStream(m.topic, m.writer);
                   const target = this.o.core.recoveryTarget(m.topic, m.writer);
+                  const skey = `${m.topic} ${m.writer}`;
                   if (target) {
-                    const key3 = `${m.topic} ${m.writer}`;
-                    const before = ps.recoveryProgress.get(key3);
-                    ps.recoveryProgress.set(key3, head.contigSeq);
+                    const before = ps.recoveryProgress.get(skey);
+                    ps.recoveryProgress.set(skey, head.contigSeq);
                     if (before !== void 0 && before >= head.contigSeq)
                       this.o.core.reportCanonicalUnavailable(m.topic, m.writer);
                     else
@@ -56499,8 +56719,22 @@ CREATE TABLE IF NOT EXISTS sq_archive (
                   } else if (head.sealReason === null && m.toSeq > head.contigSeq) {
                     const cert = this.o.core.getCert(m.topic);
                     const awaitingSnapshot = cert !== null && (cert.cut[m.writer]?.seq ?? 0) > head.contigSeq;
-                    if (!awaitingSnapshot)
-                      this.queueWant(ps, m.topic, m.writer);
+                    if (!awaitingSnapshot) {
+                      const before = ps.syncProgress.get(skey);
+                      ps.syncProgress.set(skey, head.contigSeq);
+                      if (before !== void 0 && before >= head.contigSeq) {
+                        if (!ps.stalled.has(skey)) {
+                          ps.stalled.add(skey);
+                          this.o.emitAnomaly({ kind: "sync_stalled" });
+                        }
+                      } else {
+                        ps.stalled.delete(skey);
+                        this.queueWant(ps, m.topic, m.writer);
+                      }
+                    }
+                  } else {
+                    ps.syncProgress.delete(skey);
+                    ps.stalled.delete(skey);
                   }
                 }
               }
@@ -57211,8 +57445,52 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           store.close();
         }
       };
+      const SCAN_DEFAULT_LIMIT = 500;
+      const SCAN_MAX_LIMIT = 1e4;
+      const scanEntries = (topic, o = {}) => {
+        if (closed)
+          throw misuse("node is closed");
+        topics.get(topic);
+        const limit = Math.min(Math.max(1, Math.floor(o.limit ?? SCAN_DEFAULT_LIMIT)), SCAN_MAX_LIMIT);
+        if (o.writer !== void 0) {
+          if (o.after !== void 0 || o.through !== void 0)
+            throw misuse("scanEntries: writer form takes fromSeq/toSeq, not after/through");
+          const head = core2.getStream(topic, o.writer);
+          const fromSeq = o.fromSeq ?? 1;
+          const toSeq = o.toSeq ?? head.contigSeq;
+          if (toSeq < fromSeq)
+            return { entries: [], complete: true, truncatedBelow: false };
+          const windowEnd = Math.min(toSeq, fromSeq + limit - 1);
+          const bySeq = /* @__PURE__ */ new Map();
+          for (const e of store.archivedEntries(topic, o.writer, fromSeq, windowEnd))
+            bySeq.set(e.seq, e);
+          for (const { entry } of store.entriesRange(topic, o.writer, fromSeq, windowEnd))
+            bySeq.set(entry.seq, entry);
+          const entries2 = [...bySeq.values()].sort((a, b) => a.seq - b.seq);
+          const complete2 = windowEnd >= toSeq;
+          const firstAvail = entries2[0]?.seq;
+          const truncatedBelow2 = firstAvail !== void 0 ? firstAvail > fromSeq : head.contigSeq >= fromSeq;
+          const r2 = { entries: entries2, complete: complete2, truncatedBelow: truncatedBelow2 };
+          if (!complete2)
+            r2.nextFromSeq = windowEnd + 1;
+          return r2;
+        }
+        if (o.fromSeq !== void 0 || o.toSeq !== void 0)
+          throw misuse("scanEntries: fromSeq/toSeq require writer");
+        const fetched = store.entriesAfterOrder(topic, o.after ?? null, limit + 1);
+        const within = o.through ? fetched.filter((e) => orderCompare(orderOf(e), o.through) <= 0) : fetched;
+        const entries = within.slice(0, limit);
+        const complete = within.length <= limit && (within.length < fetched.length || fetched.length <= limit);
+        const cert = core2.getCert(topic);
+        const truncatedBelow = store.archivedCount(topic) > 0 && (o.after === void 0 || cert !== null && orderCompare(o.after, cert.order) < 0);
+        const r = { entries, complete, truncatedBelow };
+        if (!complete && entries.length > 0)
+          r.nextAfter = orderOf(entries[entries.length - 1]);
+        return r;
+      };
       const stats = () => {
-        const out = { topics: {}, peers: sync.peerStats() };
+        const interval = sync.drainIntervalStats();
+        const out = { topics: {}, peers: sync.peerStats(), syncHotspots: interval.hotspots };
         const now = clock();
         for (const topic of topics.list()) {
           const cert = core2.getCert(topic);
@@ -57232,13 +57510,34 @@ CREATE TABLE IF NOT EXISTS sq_archive (
             archived: store.archivedCount(topic),
             finalityGeneration: cert?.generation ?? null,
             certOrderAgeMs: cert ? Math.max(0, now - cert.order.l) : null,
-            consumers: consumers2
+            consumers: consumers2,
+            applyRejects: sync.rejectStats(topic),
+            sync: interval.topics.get(topic) ?? {
+              servedEntries: 0,
+              servedBytes: 0,
+              appliedEntries: 0,
+              appliedBytes: 0,
+              wantRoundsRequested: 0,
+              wantRoundsServed: 0
+            }
           };
         }
         return out;
       };
       return Object.assign(node, {
         stats,
+        resetConsumer: (topic, consumer, o) => consumers.resetConsumer(topic, consumer, o),
+        deleteConsumer: (topic, consumer) => consumers.deleteConsumer(topic, consumer),
+        listConsumers: (topic) => consumers.listConsumers(topic),
+        pruneConsumers: (topic, o) => consumers.pruneConsumers(topic, o),
+        consumerCaughtUp: (topic, consumer) => consumers.caughtUp(topic, consumer),
+        scanEntries,
+        headOrder: (topic) => {
+          if (closed)
+            throw misuse("node is closed");
+          topics.get(topic);
+          return store.maxOrderUpTo(topic, Number.MAX_SAFE_INTEGER);
+        },
         _core: core2,
         _views: views,
         _registers: registers,
@@ -57254,6 +57553,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_beacon();
         init_codec();
         init_consume();
+        init_hlc();
         init_constants();
         init_directives();
         init_errors3();
@@ -57452,6 +57752,12 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     function meshEventsTopic(meshId) {
       return `mesh.${safeMeshId(meshId)}.events`;
     }
+    function meshIdFromEventsTopic(topic) {
+      if (!topic.startsWith("mesh.") || !topic.endsWith(".events")) return null;
+      const segment = topic.slice("mesh.".length, -".events".length);
+      if (segment.length === 0 || segment.includes(".")) return null;
+      return segment;
+    }
     function sessionTranscriptTopic(sessionId) {
       return `session.${safeSessionId(sessionId)}.transcript`;
     }
@@ -57544,6 +57850,193 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         FLEET_STATUS_RING = 50;
       }
     });
+    function diffProjected(expected, actual) {
+      const fields = [];
+      if (expected.ledgerKind !== actual.ledgerKind) fields.push("ledgerKind");
+      if (expected.timestamp !== actual.timestamp) fields.push("timestamp");
+      if (expected.nodeId !== actual.nodeId) fields.push("nodeId");
+      if (expected.sessionId !== actual.sessionId) fields.push("sessionId");
+      if (expected.providerType !== actual.providerType) fields.push("providerType");
+      if (expected.taskId !== actual.taskId) fields.push("taskId");
+      const keys = /* @__PURE__ */ new Set([
+        ...Object.keys(expected.payload ?? {}),
+        ...Object.keys(actual.payload ?? {})
+      ]);
+      for (const key2 of keys) {
+        if (expected.payload?.[key2] !== actual.payload?.[key2]) fields.push(`payload.${key2}`);
+      }
+      return fields;
+    }
+    function readProjected(payload) {
+      if (!payload || typeof payload !== "object") return null;
+      const record2 = payload;
+      if (typeof record2.id !== "string" || record2.id.length === 0) return null;
+      return {
+        id: record2.id,
+        timestamp: typeof record2.timestamp === "string" ? record2.timestamp : "",
+        ledgerKind: typeof record2.ledgerKind === "string" ? record2.ledgerKind : "",
+        nodeId: record2.nodeId ?? null,
+        sessionId: record2.sessionId ?? null,
+        providerType: record2.providerType ?? null,
+        taskId: record2.taskId ?? null,
+        payload: record2.payload ?? {}
+      };
+    }
+    function collectOwnShadowRecords(handle, topic, through) {
+      const records = /* @__PURE__ */ new Map();
+      let truncatedBelow = false;
+      let after;
+      for (let page = 0; page < SHADOW_SCAN_MAX_PAGES; page++) {
+        const result = handle.node.scanEntries(topic, {
+          ...after ? { after } : {},
+          through,
+          limit: SHADOW_SCAN_PAGE
+        });
+        if (result.truncatedBelow) truncatedBelow = true;
+        for (const entry of result.entries) {
+          if (entry.kind !== MESH_EVENT_ENTRY_KIND) continue;
+          if (entry.writer !== handle.writerId) continue;
+          const projected = readProjected(entry.payload);
+          if (projected) records.set(projected.id, projected);
+        }
+        if (result.complete || !result.nextAfter) break;
+        after = result.nextAfter;
+      }
+      return { records, through, truncatedBelow };
+    }
+    function shortId(id) {
+      return id.length <= 12 ? id : `${id.slice(0, 12)}\u2026`;
+    }
+    async function runMeshParityCheck(handle, meshId, ledgerEntries, _opts = {}) {
+      const topic = meshEventsTopic(meshId);
+      const result = { meshId, compared: 0, mismatches: [] };
+      if (!handle.topics.some((d) => d.topic === topic)) {
+        return result;
+      }
+      let window;
+      try {
+        const through = handle.node.headOrder(topic);
+        if (through === null) {
+          window = { records: /* @__PURE__ */ new Map(), through: null, truncatedBelow: false };
+        } else {
+          window = collectOwnShadowRecords(handle, topic, through);
+        }
+      } catch (error48) {
+        LOG2.warn(
+          "Seqscribe",
+          `parity read failed mesh=${meshId}: ${error48 instanceof Error ? error48.message : String(error48)}`
+        );
+        return result;
+      }
+      const shadow = window.records;
+      const seen = /* @__PURE__ */ new Set();
+      let oldestComparedMs = Infinity;
+      for (const entry of ledgerEntries) {
+        result.compared++;
+        seen.add(entry.id);
+        const entryMs = new Date(entry.timestamp).getTime();
+        if (Number.isFinite(entryMs) && entryMs < oldestComparedMs) oldestComparedMs = entryMs;
+        const actual = shadow.get(entry.id);
+        if (!actual) {
+          result.mismatches.push({
+            kind: "missing_in_shadow",
+            id: entry.id,
+            ledgerKind: entry.kind
+          });
+          continue;
+        }
+        const fields = diffProjected(projectMeshLedgerEntry(entry), actual);
+        if (fields.length > 0) {
+          result.mismatches.push({
+            kind: "field_mismatch",
+            id: entry.id,
+            ledgerKind: entry.kind,
+            fields
+          });
+        }
+      }
+      for (const [id, record2] of shadow) {
+        if (seen.has(id)) continue;
+        const recordMs = new Date(record2.timestamp).getTime();
+        if (Number.isFinite(recordMs) && recordMs < oldestComparedMs) continue;
+        result.mismatches.push({
+          kind: "extra_in_shadow",
+          id,
+          ledgerKind: record2.ledgerKind || null
+        });
+      }
+      if (window.truncatedBelow) {
+        LOG2.info(
+          "Seqscribe",
+          `parity window mesh=${meshId} reaches below the archive floor \u2014 shadow records under the cut are not visible to this sweep`
+        );
+      }
+      counters.runs++;
+      counters.compared = result.compared;
+      let missing = 0;
+      let extra = 0;
+      let field2 = 0;
+      for (const m of result.mismatches) {
+        if (m.kind === "missing_in_shadow") missing++;
+        else if (m.kind === "extra_in_shadow") extra++;
+        else field2++;
+      }
+      counters.missingInShadow += missing;
+      counters.extraInShadow += extra;
+      counters.fieldMismatch += field2;
+      counters.mismatches += result.mismatches.length;
+      if (result.mismatches.length > 0) {
+        for (const m of result.mismatches.slice(0, MISMATCH_LOG_CAP)) {
+          LOG2.info(
+            "Seqscribe",
+            `parity mismatch kind=${m.kind} mesh=${meshId} entry=${shortId(m.id)} ledgerKind=${m.ledgerKind ?? "unknown"}` + (m.fields?.length ? ` fields=${m.fields.join(",")}` : "")
+          );
+        }
+        if (result.mismatches.length > MISMATCH_LOG_CAP) {
+          LOG2.info(
+            "Seqscribe",
+            `parity mismatch mesh=${meshId} \u2014 ${result.mismatches.length - MISMATCH_LOG_CAP} further mismatches not logged this run`
+          );
+        }
+      }
+      return result;
+    }
+    function meshParityCounters() {
+      return { ...counters };
+    }
+    function __resetMeshParityForTests() {
+      counters.compared = 0;
+      counters.missingInShadow = 0;
+      counters.extraInShadow = 0;
+      counters.fieldMismatch = 0;
+      counters.mismatches = 0;
+      counters.runs = 0;
+    }
+    var PARITY_CONSUMER;
+    var counters;
+    var SHADOW_SCAN_PAGE;
+    var SHADOW_SCAN_MAX_PAGES;
+    var MISMATCH_LOG_CAP;
+    var init_mesh_parity = __esm2({
+      "src/seqscribe/mesh-parity.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_event_projection();
+        init_topics2();
+        PARITY_CONSUMER = "stage3-mesh-parity";
+        counters = {
+          compared: 0,
+          missingInShadow: 0,
+          extraInShadow: 0,
+          fieldMismatch: 0,
+          mismatches: 0,
+          runs: 0
+        };
+        SHADOW_SCAN_PAGE = 500;
+        SHADOW_SCAN_MAX_PAGES = 200;
+        MISMATCH_LOG_CAP = 20;
+      }
+    });
     function warnOnce(message) {
       if (warnedOnce.has(message)) return;
       warnedOnce.add(message);
@@ -57564,9 +58057,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         malformed: 0
       };
     }
-    function consumerNameFor(meshId) {
-      const generation = rebuildGeneration.get(meshId) ?? 0;
-      return generation === 0 ? READ_MODEL_CONSUMER : `${READ_MODEL_CONSUMER}#${generation + 1}`;
+    function meshReadModelRebuildEpoch(meshId) {
+      return rebuildEpoch.get(meshId) ?? 0;
     }
     function addToBucket(map3, key2, id) {
       if (!key2) return;
@@ -57584,7 +58076,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       bucket2.delete(id);
       if (bucket2.size === 0) map3.delete(key2);
     }
-    function readProjected(payload) {
+    function readProjected2(payload) {
       if (!payload || typeof payload !== "object") return null;
       const record2 = payload;
       if (typeof record2.id !== "string" || record2.id.length === 0) return null;
@@ -57602,7 +58094,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     }
     function ingest(index, entry) {
       if (entry.kind !== MESH_EVENT_ENTRY_KIND) return;
-      const event = readProjected(entry.payload);
+      const event = readProjected2(entry.payload);
       if (!event) {
         index.malformed++;
         return;
@@ -57641,7 +58133,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       if (existing) return existing;
       const topic = meshEventsTopic(meshId);
       if (!node.topics.some((d) => d.topic === topic)) return null;
-      const index = emptyIndex(consumerNameFor(meshId));
+      const index = emptyIndex(READ_MODEL_CONSUMER);
       try {
         index.unsub = node.node.onEntry(topic, index.consumerName, (entry) => {
           ingest(index, entry);
@@ -57735,8 +58227,70 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         }
         indexes.delete(meshId);
       }
-      rebuildGeneration.set(meshId, (rebuildGeneration.get(meshId) ?? 0) + 1);
+      const node = activeNode;
+      if (!node) return null;
+      const topic = meshEventsTopic(meshId);
+      if (!node.topics.some((d) => d.topic === topic)) return null;
+      rebuildEpoch.set(meshId, (rebuildEpoch.get(meshId) ?? 0) + 1);
+      let coverage = null;
+      try {
+        const reset = node.node.resetConsumer(topic, READ_MODEL_CONSUMER, {
+          from: "earliest-retained"
+        });
+        coverage = {
+          consumerName: READ_MODEL_CONSUMER,
+          existed: reset.existed,
+          replayFromRowid: reset.replayFromRowid,
+          archivedRows: reset.archivedRows
+        };
+        lastRebuildCoverage.set(meshId, {
+          archivedRows: reset.archivedRows,
+          replayFromRowid: reset.replayFromRowid
+        });
+        if (reset.archivedRows > 0) {
+          LOG2.info(
+            "Seqscribe",
+            `read model rebuild mesh=${meshId} replays from the archive floor (rowid=${reset.replayFromRowid}, ${reset.archivedRows} archived rows not replayed)`
+          );
+        }
+      } catch (error48) {
+        warnOnce(
+          `read model rebuild could not reset cursor topic=${topic}: ${error48 instanceof Error ? error48.message : String(error48)}`
+        );
+        return null;
+      }
       ensureIndex(meshId);
+      return coverage;
+    }
+    function pruneStaleConsumersAtBoot() {
+      const node = activeNode;
+      if (!node) return 0;
+      let total = 0;
+      for (const definition of node.topics) {
+        const meshId = meshIdFromEventsTopic(definition.topic);
+        if (meshId === null) continue;
+        total += pruneTopicConsumers(node, definition.topic, meshId).length;
+      }
+      return total;
+    }
+    function pruneTopicConsumers(node, topic, meshId) {
+      const pruned = [];
+      try {
+        pruned.push(...node.node.pruneConsumers(topic, { prefix: `${READ_MODEL_CONSUMER}#` }));
+        pruned.push(...node.node.pruneConsumers(topic, { prefix: `${PARITY_CONSUMER}:` }));
+      } catch (error48) {
+        warnOnce(
+          `consumer prune failed topic=${topic}: ${error48 instanceof Error ? error48.message : String(error48)}`
+        );
+        return pruned;
+      }
+      if (pruned.length > 0) {
+        LOG2.info(
+          "Seqscribe",
+          `pruned ${pruned.length} stale durable consumer(s) mesh=${meshId} \u2014 archive gate released`
+        );
+      }
+      return pruned;
     }
     function meshReadModelConsumerName(meshId) {
       return indexes.get(meshId)?.consumerName ?? null;
@@ -57749,7 +58303,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         }
       }
       indexes.clear();
-      rebuildGeneration.clear();
+      lastRebuildCoverage.clear();
+      rebuildEpoch.clear();
       activeNode = null;
       warnedOnce.clear();
     }
@@ -57763,7 +58318,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     var indexes;
     var activeNode;
     var warnedOnce;
-    var rebuildGeneration;
+    var lastRebuildCoverage;
+    var rebuildEpoch;
     var init_mesh_read_model = __esm2({
       "src/seqscribe/mesh-read-model.ts"() {
         "use strict";
@@ -57771,12 +58327,14 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_dist();
         init_logger();
         init_mesh_event_projection();
+        init_mesh_parity();
         init_topics2();
         READ_MODEL_CONSUMER = "stage4a-mesh-read-model";
         indexes = /* @__PURE__ */ new Map();
         activeNode = null;
         warnedOnce = /* @__PURE__ */ new Set();
-        rebuildGeneration = /* @__PURE__ */ new Map();
+        lastRebuildCoverage = /* @__PURE__ */ new Map();
+        rebuildEpoch = /* @__PURE__ */ new Map();
       }
     });
     function resolveMeshDualWriteMode(env2 = process.env) {
@@ -57861,7 +58419,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         return topic;
       } catch (error48) {
         definedTopics.set(topic, false);
-        counters.topicErrors++;
+        counters2.topicErrors++;
         LOG2.warn(
           "Seqscribe",
           `mesh dual-write disabled for this mesh \u2014 defineTopic failed topic=${topic}: ${error48 instanceof Error ? error48.message : String(error48)}`
@@ -57882,7 +58440,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         const topic = ensureTopic(node, meshId);
         if (!topic) return false;
         if (inflight >= MAX_INFLIGHT) {
-          counters.dropped++;
+          counters2.dropped++;
           warnOnce2(
             `mesh dual-write shedding load \u2014 ${MAX_INFLIGHT} appends in flight; records are being dropped from the SHADOW leg only (the ledger is unaffected)`
           );
@@ -57892,7 +58450,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         const estimated = estimateProjectedEntryBytes(topic, projected);
         const ceiling = maxEntryBytes();
         if (estimated > ceiling) {
-          counters.oversized++;
+          counters2.oversized++;
           warnOnce2(
             `mesh dual-write skipped an oversized record (further occurrences logged once): estimated=${estimated}B ceiling=${ceiling}B ledgerKind=${projected.ledgerKind}. The projection is supposed to bound every field \u2014 this is a projection bug, not a transport one.`
           );
@@ -57902,13 +58460,13 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         void node.node.log(topic).append(MESH_EVENT_ENTRY_KIND, toJsonValue(projected)).then(
           () => {
             inflight--;
-            if (origin === "backfill") counters.backfilled++;
-            else counters.written++;
+            if (origin === "backfill") counters2.backfilled++;
+            else counters2.written++;
           },
           (error48) => {
             inflight--;
-            if (origin === "backfill") counters.backfillFailed++;
-            else counters.failed++;
+            if (origin === "backfill") counters2.backfillFailed++;
+            else counters2.failed++;
             warnOnce2(
               `mesh dual-write append failed (further failures logged once): ${error48 instanceof Error ? error48.message : String(error48)}`
             );
@@ -57916,8 +58474,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         );
         return true;
       } catch (error48) {
-        if (origin === "backfill") counters.backfillFailed++;
-        else counters.failed++;
+        if (origin === "backfill") counters2.backfillFailed++;
+        else counters2.failed++;
         warnOnce2(
           `mesh dual-write threw synchronously (further throws logged once): ${error48 instanceof Error ? error48.message : String(error48)}`
         );
@@ -57925,7 +58483,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       }
     }
     function meshDualWriteCounters() {
-      return { ...counters };
+      return { ...counters2 };
     }
     function isMeshDualWriteActive() {
       return activeNode2 !== null && (activeMode === "shadow" || activeMode === "primary");
@@ -57945,17 +58503,17 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       definedTopics.clear();
       inflight = 0;
       warnedOnce2.clear();
-      counters.written = 0;
-      counters.failed = 0;
-      counters.dropped = 0;
-      counters.topicErrors = 0;
-      counters.backfilled = 0;
-      counters.backfillFailed = 0;
-      counters.oversized = 0;
+      counters2.written = 0;
+      counters2.failed = 0;
+      counters2.dropped = 0;
+      counters2.topicErrors = 0;
+      counters2.backfilled = 0;
+      counters2.backfillFailed = 0;
+      counters2.oversized = 0;
     }
     var MESH_DUAL_WRITE_ENV;
     var MAX_INFLIGHT;
-    var counters;
+    var counters2;
     var definedTopics;
     var activeNode2;
     var activeMode;
@@ -57970,7 +58528,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_topics2();
         MESH_DUAL_WRITE_ENV = "ADHDEV_SEQSCRIBE_MESH";
         MAX_INFLIGHT = 512;
-        counters = {
+        counters2 = {
           written: 0,
           failed: 0,
           dropped: 0,
@@ -57987,190 +58545,54 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         TOPIC_LISTENERS = /* @__PURE__ */ Symbol.for("adhdev.seqscribe.topicActivatedListeners");
       }
     });
-    function diffProjected(expected, actual) {
-      const fields = [];
-      if (expected.ledgerKind !== actual.ledgerKind) fields.push("ledgerKind");
-      if (expected.timestamp !== actual.timestamp) fields.push("timestamp");
-      if (expected.nodeId !== actual.nodeId) fields.push("nodeId");
-      if (expected.sessionId !== actual.sessionId) fields.push("sessionId");
-      if (expected.providerType !== actual.providerType) fields.push("providerType");
-      if (expected.taskId !== actual.taskId) fields.push("taskId");
-      const keys = /* @__PURE__ */ new Set([
-        ...Object.keys(expected.payload ?? {}),
-        ...Object.keys(actual.payload ?? {})
-      ]);
-      for (const key2 of keys) {
-        if (expected.payload?.[key2] !== actual.payload?.[key2]) fields.push(`payload.${key2}`);
-      }
-      return fields;
+    function reportMeshTopicGrants(topics) {
+      grantedTopics = topics ? new Set(topics) : null;
     }
-    function readProjected2(payload) {
-      if (!payload || typeof payload !== "object") return null;
-      const record2 = payload;
-      if (typeof record2.id !== "string" || record2.id.length === 0) return null;
-      return {
-        id: record2.id,
-        timestamp: typeof record2.timestamp === "string" ? record2.timestamp : "",
-        ledgerKind: typeof record2.ledgerKind === "string" ? record2.ledgerKind : "",
-        nodeId: record2.nodeId ?? null,
-        sessionId: record2.sessionId ?? null,
-        providerType: record2.providerType ?? null,
-        taskId: record2.taskId ?? null,
-        payload: record2.payload ?? {}
-      };
+    function isTopicGranted(topic) {
+      if (grantedTopics === null) return true;
+      return grantedTopics.has(topic);
     }
-    async function collectOwnShadowRecords(handle, topic, nonce) {
-      const found = /* @__PURE__ */ new Map();
-      let unsub = null;
-      try {
-        unsub = handle.node.onEntry(topic, `${PARITY_CONSUMER}:${nonce}`, (entry) => {
-          if (entry.kind !== MESH_EVENT_ENTRY_KIND) return;
-          if (entry.writer !== handle.writerId) return;
-          const projected = readProjected2(entry.payload);
-          if (projected) found.set(projected.id, projected);
-        });
-        await new Promise((resolve31) => setTimeout(resolve31, 0));
-        await new Promise((resolve31) => setTimeout(resolve31, 0));
-      } finally {
-        try {
-          unsub?.();
-        } catch {
-        }
+    function isConsumerCaughtUp(node, topic, meshId, consumerName) {
+      const epoch = meshReadModelRebuildEpoch(meshId);
+      const existing = caughtUpLatches.get(meshId);
+      if (existing && existing.node === node && existing.consumerName === consumerName && existing.epoch === epoch) {
+        if (existing.caughtUp || existing.pending) return existing.caughtUp;
       }
-      return found;
-    }
-    function shortId(id) {
-      return id.length <= 12 ? id : `${id.slice(0, 12)}\u2026`;
-    }
-    async function runMeshParityCheck(handle, meshId, ledgerEntries, opts = {}) {
-      const topic = meshEventsTopic(meshId);
-      const result = { meshId, compared: 0, mismatches: [] };
-      if (!handle.topics.some((d) => d.topic === topic)) {
-        return result;
-      }
-      let shadow;
+      const latch = { node, consumerName, epoch, caughtUp: false, pending: true };
+      caughtUpLatches.set(meshId, latch);
       try {
-        shadow = await collectOwnShadowRecords(
-          handle,
-          topic,
-          opts.nonce ?? `${Date.now()}-${counters2.runs}`
+        void node.node.consumerCaughtUp(topic, consumerName).then(
+          () => {
+            if (caughtUpLatches.get(meshId) !== latch) return;
+            latch.pending = false;
+            latch.caughtUp = true;
+          },
+          (error48) => {
+            if (caughtUpLatches.get(meshId) !== latch) return;
+            latch.pending = false;
+            latch.caughtUp = false;
+            LOG2.info(
+              "Seqscribe",
+              `read model catch-up watch ended mesh=${meshId}: ${error48 instanceof Error ? error48.message : String(error48)}`
+            );
+          }
         );
       } catch (error48) {
+        latch.pending = false;
         LOG2.warn(
           "Seqscribe",
-          `parity read failed mesh=${meshId}: ${error48 instanceof Error ? error48.message : String(error48)}`
+          `read model catch-up unavailable mesh=${meshId}: ${error48 instanceof Error ? error48.message : String(error48)}`
         );
-        return result;
-      }
-      const seen = /* @__PURE__ */ new Set();
-      let oldestComparedMs = Infinity;
-      for (const entry of ledgerEntries) {
-        result.compared++;
-        seen.add(entry.id);
-        const entryMs = new Date(entry.timestamp).getTime();
-        if (Number.isFinite(entryMs) && entryMs < oldestComparedMs) oldestComparedMs = entryMs;
-        const actual = shadow.get(entry.id);
-        if (!actual) {
-          result.mismatches.push({
-            kind: "missing_in_shadow",
-            id: entry.id,
-            ledgerKind: entry.kind
-          });
-          continue;
-        }
-        const fields = diffProjected(projectMeshLedgerEntry(entry), actual);
-        if (fields.length > 0) {
-          result.mismatches.push({
-            kind: "field_mismatch",
-            id: entry.id,
-            ledgerKind: entry.kind,
-            fields
-          });
-        }
-      }
-      for (const [id, record2] of shadow) {
-        if (seen.has(id)) continue;
-        const recordMs = new Date(record2.timestamp).getTime();
-        if (Number.isFinite(recordMs) && recordMs < oldestComparedMs) continue;
-        result.mismatches.push({
-          kind: "extra_in_shadow",
-          id,
-          ledgerKind: record2.ledgerKind || null
-        });
-      }
-      counters2.runs++;
-      counters2.compared = result.compared;
-      let missing = 0;
-      let extra = 0;
-      let field2 = 0;
-      for (const m of result.mismatches) {
-        if (m.kind === "missing_in_shadow") missing++;
-        else if (m.kind === "extra_in_shadow") extra++;
-        else field2++;
-      }
-      counters2.missingInShadow += missing;
-      counters2.extraInShadow += extra;
-      counters2.fieldMismatch += field2;
-      counters2.mismatches += result.mismatches.length;
-      if (result.mismatches.length > 0) {
-        for (const m of result.mismatches.slice(0, MISMATCH_LOG_CAP)) {
-          LOG2.info(
-            "Seqscribe",
-            `parity mismatch kind=${m.kind} mesh=${meshId} entry=${shortId(m.id)} ledgerKind=${m.ledgerKind ?? "unknown"}` + (m.fields?.length ? ` fields=${m.fields.join(",")}` : "")
-          );
-        }
-        if (result.mismatches.length > MISMATCH_LOG_CAP) {
-          LOG2.info(
-            "Seqscribe",
-            `parity mismatch mesh=${meshId} \u2014 ${result.mismatches.length - MISMATCH_LOG_CAP} further mismatches not logged this run`
-          );
-        }
-      }
-      return result;
-    }
-    function meshParityCounters() {
-      return { ...counters2 };
-    }
-    function __resetMeshParityForTests() {
-      counters2.compared = 0;
-      counters2.missingInShadow = 0;
-      counters2.extraInShadow = 0;
-      counters2.fieldMismatch = 0;
-      counters2.mismatches = 0;
-      counters2.runs = 0;
-    }
-    var PARITY_CONSUMER;
-    var counters2;
-    var MISMATCH_LOG_CAP;
-    var init_mesh_parity = __esm2({
-      "src/seqscribe/mesh-parity.ts"() {
-        "use strict";
-        init_logger();
-        init_mesh_event_projection();
-        init_topics2();
-        PARITY_CONSUMER = "stage3-mesh-parity";
-        counters2 = {
-          compared: 0,
-          missingInShadow: 0,
-          extraInShadow: 0,
-          fieldMismatch: 0,
-          mismatches: 0,
-          runs: 0
-        };
-        MISMATCH_LOG_CAP = 20;
       }
-    });
-    function reportMeshTopicGrants(topics) {
-      grantedTopics = topics ? new Set(topics) : null;
-    }
-    function isTopicGranted(topic) {
-      if (grantedTopics === null) return true;
-      return grantedTopics.has(topic);
+      return latch.caughtUp;
     }
     function countFallback(reason) {
       fallbackCounts.set(reason, (fallbackCounts.get(reason) ?? 0) + 1);
       readsServedFromLedger++;
     }
+    function configureMeshReadReadinessCollector(collector) {
+      seqscribeCollectorRef = collector;
+    }
     function logTransition(meshId, state) {
       if (loggedTransitions.get(meshId) === state) return;
       loggedTransitions.set(meshId, state);
@@ -58192,24 +58614,28 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         if (!hasMeshReadModelIndex(meshId)) return { ready: false, reason: "index_missing" };
       }
       let topicStats;
-      try {
-        const stats = node.node.stats();
-        const entry = stats.topics[topic];
-        if (!entry) return { ready: false, reason: "topic_undefined" };
-        topicStats = entry;
-      } catch (error48) {
-        LOG2.warn(
-          "Seqscribe",
-          `read readiness stats failed mesh=${meshId}: ${error48 instanceof Error ? error48.message : String(error48)}`
-        );
-        return { ready: false, reason: "stats_error" };
+      if (seqscribeCollectorRef) {
+        const snapshot = seqscribeCollectorRef.snapshot();
+        if (!snapshot) return { ready: false, reason: "stats_error" };
+        topicStats = snapshot.stats.topics[topic];
+      } else {
+        try {
+          topicStats = node.node.stats().topics[topic];
+        } catch (error48) {
+          LOG2.warn(
+            "Seqscribe",
+            `read readiness stats failed mesh=${meshId}: ${error48 instanceof Error ? error48.message : String(error48)}`
+          );
+          return { ready: false, reason: "stats_error" };
+        }
       }
+      if (!topicStats) return { ready: false, reason: "topic_undefined" };
       if (topicStats.quarantined > 0) return { ready: false, reason: "quarantined" };
       const consumerName = meshReadModelConsumerName(meshId);
       if (!consumerName) return { ready: false, reason: "consumer_missing" };
-      const consumer = topicStats.consumers[consumerName];
-      if (!consumer) return { ready: false, reason: "consumer_missing" };
-      if (consumer.lagRows > 0) return { ready: false, reason: "consumer_lag" };
+      if (!isConsumerCaughtUp(node, topic, meshId, consumerName)) {
+        return { ready: false, reason: "consumer_lag" };
+      }
       if (meshParityCounters().mismatches > 0) return { ready: false, reason: "parity_mismatch" };
       return { ready: true, reason: null };
     }
@@ -58237,12 +58663,15 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       readsServedFromReplica = 0;
       readsServedFromLedger = 0;
       loggedTransitions.clear();
+      caughtUpLatches.clear();
     }
     var grantedTopics;
+    var caughtUpLatches;
     var fallbackCounts;
     var readsServedFromReplica;
     var readsServedFromLedger;
     var loggedTransitions;
+    var seqscribeCollectorRef;
     var init_mesh_read_readiness = __esm2({
       "src/seqscribe/mesh-read-readiness.ts"() {
         "use strict";
@@ -58252,10 +58681,12 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_mesh_read_model();
         init_topics2();
         grantedTopics = null;
+        caughtUpLatches = /* @__PURE__ */ new Map();
         fallbackCounts = /* @__PURE__ */ new Map();
         readsServedFromReplica = 0;
         readsServedFromLedger = 0;
         loggedTransitions = /* @__PURE__ */ new Map();
+        seqscribeCollectorRef = null;
       }
     });
     function fromLedger(entry) {
@@ -62682,10 +63113,20 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         resolvedAt: r.resolved_at
       };
     }
+    function registerLedgerBulkChangeListener(fn) {
+      onLedgerBulkChange = fn;
+    }
+    function notifyLedgerBulkChange() {
+      try {
+        onLedgerBulkChange?.();
+      } catch {
+      }
+    }
     function pruneMeshRuntimeRetention() {
       try {
         const store = MeshRuntimeStore.getInstance();
         const ledger = store.pruneEventLedger(MESH_EVENT_LEDGER_RETENTION_MS);
+        if (ledger > 0) notifyLedgerBulkChange();
         const toolCalls = store.pruneToolCallLog(MESH_TOOL_CALL_LOG_RETENTION_MS);
         const terminalQueue = store.pruneTerminalQueueEntries(MESH_TERMINAL_QUEUE_RETENTION_MS);
         const sessionDelivery = store.pruneTerminalSessionDeliveries(resolveSessionDeliveryRetentionMs());
@@ -62698,6 +63139,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         return { ledger: 0, toolCalls: 0, terminalQueue: 0, sessionDelivery: 0 };
       }
     }
+    var onLedgerBulkChange;
     var MESH_EVENT_LEDGER_RETENTION_MS;
     var MESH_TOOL_CALL_LOG_RETENTION_MS;
     var MESH_TERMINAL_QUEUE_RETENTION_MS;
@@ -62848,6 +63290,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           static resetForTests() {
             this.instance?.close();
             this.instance = void 0;
+            notifyLedgerBulkChange();
           }
           /**
            * VACUUM the SQLite database to reclaim on-disk space. Retention prunes rows
@@ -65495,6 +65938,242 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         };
       }
     });
+    function safeMeshId3(meshId) {
+      return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    }
+    function getLedgerDir2() {
+      const dir = (0, import_path7.join)(getConfigDir2(), LEDGER_DIR_NAME);
+      if (!(0, import_fs7.existsSync)(dir)) {
+        (0, import_fs7.mkdirSync)(dir, { recursive: true, mode: 448 });
+      }
+      return dir;
+    }
+    function getLedgerPath(meshId) {
+      return (0, import_path7.join)(getLedgerDir2(), `${safeMeshId3(meshId)}.jsonl`);
+    }
+    function getRotatedPath(meshId, index) {
+      return (0, import_path7.join)(getLedgerDir2(), `${safeMeshId3(meshId)}.${index}.jsonl`);
+    }
+    function getArchivePath(meshId) {
+      return (0, import_path7.join)(getLedgerDir2(), `${safeMeshId3(meshId)}.archive.jsonl`);
+    }
+    function getRotatedArchivePath(meshId, index) {
+      return (0, import_path7.join)(getLedgerDir2(), `${safeMeshId3(meshId)}.archive.${index}.jsonl`);
+    }
+    function getArchivedTerminalKeysPath(meshId) {
+      return (0, import_path7.join)(getLedgerDir2(), `${safeMeshId3(meshId)}.archived-terminal-keys.json`);
+    }
+    var import_fs7;
+    var import_path7;
+    var LEDGER_DIR_NAME;
+    var init_mesh_ledger_paths = __esm2({
+      "src/mesh/mesh-ledger-paths.ts"() {
+        "use strict";
+        import_fs7 = require("fs");
+        import_path7 = require("path");
+        init_config();
+        LEDGER_DIR_NAME = "mesh-ledger";
+      }
+    });
+    function ledgerEntryTaskId(entry) {
+      if (typeof entry.taskId === "string" && entry.taskId.trim()) return entry.taskId.trim();
+      const fromPayload = entry.payload && typeof entry.payload === "object" ? entry.payload.taskId : void 0;
+      return typeof fromPayload === "string" && fromPayload.trim() ? fromPayload.trim() : void 0;
+    }
+    function readLedgerFile(meshId) {
+      const filePath = getLedgerPath(meshId);
+      if (!(0, import_fs8.existsSync)(filePath)) return [];
+      let content;
+      try {
+        content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+      } catch {
+        return [];
+      }
+      const entries = [];
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (entry.id && entry.kind) {
+            if (!entry.taskId) {
+              const derived = ledgerEntryTaskId(entry);
+              if (derived) entry.taskId = derived;
+            }
+            entries.push(entry);
+          }
+        } catch {
+        }
+      }
+      return entries;
+    }
+    function ensureLedgerImported(store, meshId) {
+      if (ledgerImportStoreRef !== store) {
+        ledgerImportDone.clear();
+        ledgerImportStoreRef = store;
+      }
+      if (ledgerImportDone.has(meshId)) return;
+      ledgerImportDone.add(meshId);
+      const fileEntries = readLedgerFile(meshId);
+      if (fileEntries.length === 0) return;
+      try {
+        store.importLedgerEntries(fileEntries.map((e) => ({
+          id: e.id,
+          meshId: e.meshId,
+          timestamp: e.timestamp,
+          kind: e.kind,
+          nodeId: e.nodeId ?? null,
+          sessionId: e.sessionId ?? null,
+          providerType: e.providerType ?? null,
+          taskId: ledgerEntryTaskId(e) ?? null,
+          payload: e.payload ?? {}
+        })));
+      } catch {
+      }
+    }
+    function readLedgerFromStore(meshId, opts) {
+      const store = MeshRuntimeStore.getInstance();
+      ensureLedgerImported(store, meshId);
+      return store.readLedgerEntriesOrdered(meshId, opts).map((r) => {
+        const payload = r.payload && typeof r.payload === "object" ? r.payload : {};
+        const taskId = ledgerEntryTaskId({ taskId: r.taskId ?? void 0, payload });
+        return {
+          id: r.id,
+          meshId: r.meshId,
+          timestamp: r.timestamp,
+          kind: r.kind,
+          ...r.nodeId ? { nodeId: r.nodeId } : {},
+          ...r.sessionId ? { sessionId: r.sessionId } : {},
+          ...r.providerType ? { providerType: r.providerType } : {},
+          ...taskId ? { taskId } : {},
+          payload
+        };
+      });
+    }
+    function getLedgerScanStats() {
+      return {
+        fullScans: ledgerScanStats.fullScans,
+        scannedRows: ledgerScanStats.scannedRows,
+        pushdownScans: ledgerScanStats.pushdownScans,
+        pushdownRows: ledgerScanStats.pushdownRows,
+        windowMs: Date.now() - ledgerScanStats.windowStartedAt
+      };
+    }
+    function __resetLedgerScanStatsForTests() {
+      ledgerScanStats.fullScans = 0;
+      ledgerScanStats.scannedRows = 0;
+      ledgerScanStats.pushdownScans = 0;
+      ledgerScanStats.pushdownRows = 0;
+      ledgerScanStats.windowStartedAt = Date.now();
+      ledgerScanStats.lastSummaryAt = Date.now();
+    }
+    function recordLedgerFullScan(rowCount) {
+      ledgerScanStats.fullScans++;
+      ledgerScanStats.scannedRows += rowCount;
+      maybeSummarizeLedgerScans();
+    }
+    function recordLedgerPushdownScan(rowCount) {
+      ledgerScanStats.pushdownScans++;
+      ledgerScanStats.pushdownRows += rowCount;
+      maybeSummarizeLedgerScans();
+    }
+    function maybeSummarizeLedgerScans() {
+      const now = Date.now();
+      if (now - ledgerScanStats.lastSummaryAt < LEDGER_SCAN_SUMMARY_INTERVAL_MS) return;
+      const windowMs = now - ledgerScanStats.windowStartedAt;
+      const { fullScans, scannedRows, pushdownScans, pushdownRows } = ledgerScanStats;
+      if (fullScans > 0 || pushdownScans > 0) {
+        LOG2.info(
+          "MeshLedger",
+          `Ledger scans in last ${Math.round(windowMs / 1e3)}s: ${fullScans} full (${scannedRows} rows parsed), ${pushdownScans} SQL-bounded (${pushdownRows} rows)`
+        );
+      }
+      ledgerScanStats.fullScans = 0;
+      ledgerScanStats.scannedRows = 0;
+      ledgerScanStats.pushdownScans = 0;
+      ledgerScanStats.pushdownRows = 0;
+      ledgerScanStats.windowStartedAt = now;
+      ledgerScanStats.lastSummaryAt = now;
+    }
+    function liveCacheEntry(meshId) {
+      const cached5 = ledgerReadCache.get(meshId);
+      if (!cached5) return void 0;
+      if (Date.now() - cached5.cachedAt >= LEDGER_CACHE_TTL_MS) return void 0;
+      return cached5;
+    }
+    function getCachedRawEntries(meshId) {
+      const cached5 = liveCacheEntry(meshId);
+      if (cached5) return cached5.entries;
+      let entries;
+      try {
+        entries = readLedgerFromStore(meshId);
+      } catch {
+        entries = readLedgerFile(meshId);
+      }
+      recordLedgerFullScan(entries.length);
+      ledgerReadCache.set(meshId, { entries, cachedAt: Date.now() });
+      return entries;
+    }
+    function entryTimeValue(entry) {
+      const t = new Date(entry.timestamp).getTime();
+      return Number.isNaN(t) ? NaN : t;
+    }
+    function appendToLedgerCache(meshId, newEntries) {
+      if (newEntries.length === 0) return true;
+      const cached5 = liveCacheEntry(meshId);
+      if (!cached5) return false;
+      let tailTime = cached5.entries.length > 0 ? entryTimeValue(cached5.entries[cached5.entries.length - 1]) : -Infinity;
+      if (Number.isNaN(tailTime)) return false;
+      for (const entry of newEntries) {
+        const t = entryTimeValue(entry);
+        if (Number.isNaN(t) || t < tailTime) return false;
+        tailTime = t;
+      }
+      cached5.entries.push(...newEntries);
+      return true;
+    }
+    function recordLedgerAppend(meshId, newEntries) {
+      if (!appendToLedgerCache(meshId, newEntries)) invalidateLedgerCache(meshId);
+    }
+    function invalidateLedgerCache(meshId) {
+      ledgerReadCache.delete(meshId);
+    }
+    function clearLedgerImportFlag(meshId) {
+      ledgerImportDone.delete(meshId);
+    }
+    function invalidateAllLedgerCaches() {
+      ledgerReadCache.clear();
+    }
+    var import_fs8;
+    var ledgerReadCache;
+    var LEDGER_CACHE_TTL_MS;
+    var ledgerImportStoreRef;
+    var ledgerImportDone;
+    var ledgerScanStats;
+    var LEDGER_SCAN_SUMMARY_INTERVAL_MS;
+    var init_mesh_ledger_read_cache = __esm2({
+      "src/mesh/mesh-ledger-read-cache.ts"() {
+        "use strict";
+        import_fs8 = require("fs");
+        init_mesh_runtime_store();
+        init_mesh_runtime_store_turn_rows();
+        init_logger();
+        init_mesh_ledger_paths();
+        ledgerReadCache = /* @__PURE__ */ new Map();
+        LEDGER_CACHE_TTL_MS = 3e4;
+        ledgerImportDone = /* @__PURE__ */ new Set();
+        ledgerScanStats = {
+          fullScans: 0,
+          scannedRows: 0,
+          /** Cold reads served by SQL pushdown (bounded) rather than a full scan. */
+          pushdownScans: 0,
+          pushdownRows: 0,
+          windowStartedAt: Date.now(),
+          lastSummaryAt: Date.now()
+        };
+        LEDGER_SCAN_SUMMARY_INTERVAL_MS = 6e4;
+        registerLedgerBulkChangeListener(invalidateAllLedgerCaches);
+      }
+    });
     var mesh_ledger_exports = {};
     __export2(mesh_ledger_exports, {
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
@@ -65504,6 +66183,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       OPERATING_NOTE_KIND: () => OPERATING_NOTE_KIND,
       OPERATING_NOTE_TOMBSTONE_KIND: () => OPERATING_NOTE_TOMBSTONE_KIND,
       __clearMeshLedgerForTests: () => __clearMeshLedgerForTests,
+      __resetLedgerScanStatsForTests: () => __resetLedgerScanStatsForTests,
       appendLedgerEntry: () => appendLedgerEntry,
       appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
       buildLedgerOriginatingCoordinatorStamp: () => buildLedgerOriginatingCoordinatorStamp,
@@ -65514,8 +66194,10 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       enforceLedgerRotationCap: () => enforceLedgerRotationCap,
       extractJsonObjectFromSummary: () => extractJsonObjectFromSummary,
       getLedgerDir: () => getLedgerDir2,
+      getLedgerScanStats: () => getLedgerScanStats,
       getLedgerSummary: () => getLedgerSummary,
       getSessionRecoveryContext: () => getSessionRecoveryContext,
+      invalidateAllLedgerCaches: () => invalidateAllLedgerCaches,
       isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
       isNoteExpired: () => isNoteExpired,
       isOperatingNoteTombstoned: () => isOperatingNoteTombstoned,
@@ -65533,11 +66215,6 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       readOperatingNotes: () => readOperatingNotes,
       tombstoneOperatingNote: () => tombstoneOperatingNote
     });
-    function ledgerEntryTaskId(entry) {
-      if (typeof entry.taskId === "string" && entry.taskId.trim()) return entry.taskId.trim();
-      const fromPayload = entry.payload && typeof entry.payload === "object" ? entry.payload.taskId : void 0;
-      return typeof fromPayload === "string" && fromPayload.trim() ? fromPayload.trim() : void 0;
-    }
     function isIntentionalCleanupStopEntry(entry) {
       if (entry.kind !== "session_stopped" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") return false;
       const payload = entry.payload && typeof entry.payload === "object" && !Array.isArray(entry.payload) ? entry.payload : {};
@@ -65565,38 +66242,11 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       if (Number.isNaN(created)) return false;
       return now - created >= ttlDays * MS_PER_DAY;
     }
-    function getLedgerDir2() {
-      const dir = (0, import_path7.join)(getConfigDir2(), LEDGER_DIR_NAME);
-      if (!(0, import_fs7.existsSync)(dir)) {
-        (0, import_fs7.mkdirSync)(dir, { recursive: true, mode: 448 });
-      }
-      return dir;
-    }
-    function getLedgerPath(meshId) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path7.join)(getLedgerDir2(), `${safe}.jsonl`);
-    }
-    function getRotatedPath(meshId, index) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path7.join)(getLedgerDir2(), `${safe}.${index}.jsonl`);
-    }
-    function getArchivePath(meshId) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path7.join)(getLedgerDir2(), `${safe}.archive.jsonl`);
-    }
-    function getRotatedArchivePath(meshId, index) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path7.join)(getLedgerDir2(), `${safe}.archive.${index}.jsonl`);
-    }
-    function getArchivedTerminalKeysPath(meshId) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path7.join)(getLedgerDir2(), `${safe}.archived-terminal-keys.json`);
-    }
     function readArchivedTerminalKeys(meshId) {
       const path63 = getArchivedTerminalKeysPath(meshId);
-      if (!(0, import_fs7.existsSync)(path63)) return /* @__PURE__ */ new Set();
+      if (!(0, import_fs9.existsSync)(path63)) return /* @__PURE__ */ new Set();
       try {
-        const parsed = JSON.parse((0, import_fs7.readFileSync)(path63, "utf-8"));
+        const parsed = JSON.parse((0, import_fs9.readFileSync)(path63, "utf-8"));
         return new Set(Array.isArray(parsed?.keys) ? parsed.keys.filter((k) => typeof k === "string") : []);
       } catch {
         return /* @__PURE__ */ new Set();
@@ -65618,23 +66268,23 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           keys = keys.slice(keys.length - ARCHIVED_TERMINAL_KEYS_MAX);
         }
         const index = { keys, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-        (0, import_fs7.writeFileSync)(getArchivedTerminalKeysPath(meshId), JSON.stringify(index), { encoding: "utf-8", mode: 384 });
+        (0, import_fs9.writeFileSync)(getArchivedTerminalKeysPath(meshId), JSON.stringify(index), { encoding: "utf-8", mode: 384 });
       } catch {
       }
     }
     function getArchivedCountsPath(meshId) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path7.join)(getLedgerDir2(), `${safe}.archived-counts.json`);
+      return (0, import_path8.join)(getLedgerDir2(), `${safe}.archived-counts.json`);
     }
     function rotateArchiveFile(meshId, archivePath) {
       let index = 1;
-      while ((0, import_fs7.existsSync)(getRotatedArchivePath(meshId, index))) {
+      while ((0, import_fs9.existsSync)(getRotatedArchivePath(meshId, index))) {
         index++;
         if (index > 5) break;
       }
       if (index > 5) index = 5;
       try {
-        (0, import_fs7.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
+        (0, import_fs9.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
       } catch (e) {
         process.stderr.write(`[adhdev-mesh] Archive rotation failed for mesh ${meshId}: ${e?.message || e}
 `);
@@ -65642,15 +66292,15 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     }
     function readArchivedCounts(meshId) {
       const path63 = getArchivedCountsPath(meshId);
-      if (!(0, import_fs7.existsSync)(path63)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+      if (!(0, import_fs9.existsSync)(path63)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
       try {
-        return JSON.parse((0, import_fs7.readFileSync)(path63, "utf-8"));
+        return JSON.parse((0, import_fs9.readFileSync)(path63, "utf-8"));
       } catch {
         return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
       }
     }
     function writeArchivedCounts(meshId, counts) {
-      (0, import_fs7.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
+      (0, import_fs9.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
     }
     function updateArchivedCounts(meshId, archived) {
       const counts = readArchivedCounts(meshId);
@@ -65686,7 +66336,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function compactLedger(meshId) {
       const filePath = getLedgerPath(meshId);
-      if (!(0, import_fs7.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
+      if (!(0, import_fs9.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
       const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
       const entries = readLedgerEntries(meshId);
       const retainedDispatchKeys = /* @__PURE__ */ new Set();
@@ -65715,11 +66365,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
       const archivePath = getArchivePath(meshId);
       try {
-        if ((0, import_fs7.existsSync)(archivePath) && (0, import_fs7.statSync)(archivePath).size > 50 * 1024 * 1024) {
+        if ((0, import_fs9.existsSync)(archivePath) && (0, import_fs9.statSync)(archivePath).size > 50 * 1024 * 1024) {
           rotateArchiveFile(meshId, archivePath);
         }
         const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        (0, import_fs7.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs9.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
         updateArchivedCounts(meshId, archive);
         recordArchivedTerminalKeys(meshId, archive);
       } catch (e) {
@@ -65729,7 +66379,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       try {
         const keepLines = keep.length ? keep.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-        (0, import_fs7.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs9.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
         invalidateLedgerCache(meshId);
       } catch (e) {
         process.stderr.write(`[adhdev-mesh] Ledger compaction rewrite failed for mesh ${meshId}: ${e?.message || e}
@@ -65911,9 +66561,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         if (derived) entry.taskId = derived;
       }
       const filePath = getLedgerPath(meshId);
-      if ((0, import_fs7.existsSync)(filePath)) {
+      if ((0, import_fs9.existsSync)(filePath)) {
         try {
-          const stat2 = (0, import_fs7.statSync)(filePath);
+          const stat2 = (0, import_fs9.statSync)(filePath);
           if (stat2.size >= MAX_FILE_SIZE_BYTES) {
             rotateLedgerFile(meshId, filePath);
           } else if (stat2.size >= COMPACT_THRESHOLD_BYTES) {
@@ -65935,12 +66585,12 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           payload: entry.payload
         });
       } catch {
-        ledgerImportDone.delete(meshId);
+        clearLedgerImportFlag(meshId);
       }
       try {
         const line = JSON.stringify(entry) + "\n";
-        (0, import_fs7.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
-        invalidateLedgerCache(meshId);
+        (0, import_fs9.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+        recordLedgerAppend(meshId, [entry]);
         meshLedgerEvents.emit("append", meshId, entry);
         try {
           recordMeshEventShadow(meshId, entry);
@@ -66035,7 +66685,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         const remaining = readLedgerFile(meshId).filter((e) => !removeIds.includes(e.id));
         const filePath = getLedgerPath(meshId);
         const lines = remaining.length ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-        (0, import_fs7.writeFileSync)(filePath, lines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs9.writeFileSync)(filePath, lines, { encoding: "utf-8", mode: 384 });
       } catch {
       }
       invalidateLedgerCache(meshId);
@@ -66092,8 +66742,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       try {
         const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        (0, import_fs7.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
-        invalidateLedgerCache(meshId);
+        (0, import_fs9.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+        recordLedgerAppend(meshId, validEntries);
         for (const entry of validEntries) {
           meshLedgerEvents.emit("append", meshId, entry);
         }
@@ -66102,101 +66752,33 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         throw new Error(`Failed to append remote ledger entries for mesh ${meshId}: ${e.message}`);
       }
     }
-    function readLedgerFile(meshId) {
-      const filePath = getLedgerPath(meshId);
-      if (!(0, import_fs7.existsSync)(filePath)) return [];
-      let content;
-      try {
-        content = (0, import_fs7.readFileSync)(filePath, "utf-8");
-      } catch {
-        return [];
-      }
-      const entries = [];
-      for (const line of content.split("\n")) {
-        if (!line.trim()) continue;
-        try {
-          const entry = JSON.parse(line);
-          if (entry.id && entry.kind) {
-            if (!entry.taskId) {
-              const derived = ledgerEntryTaskId(entry);
-              if (derived) entry.taskId = derived;
-            }
-            entries.push(entry);
-          }
-        } catch {
-        }
-      }
-      return entries;
-    }
-    function ensureLedgerImported(store, meshId) {
-      if (ledgerImportStoreRef !== store) {
-        ledgerImportDone.clear();
-        ledgerImportStoreRef = store;
-      }
-      if (ledgerImportDone.has(meshId)) return;
-      ledgerImportDone.add(meshId);
-      const fileEntries = readLedgerFile(meshId);
-      if (fileEntries.length === 0) return;
-      try {
-        store.importLedgerEntries(fileEntries.map((e) => ({
-          id: e.id,
-          meshId: e.meshId,
-          timestamp: e.timestamp,
-          kind: e.kind,
-          nodeId: e.nodeId ?? null,
-          sessionId: e.sessionId ?? null,
-          providerType: e.providerType ?? null,
-          taskId: ledgerEntryTaskId(e) ?? null,
-          payload: e.payload ?? {}
-        })));
-      } catch {
-      }
-    }
-    function readLedgerFromStore(meshId) {
-      const store = MeshRuntimeStore.getInstance();
-      ensureLedgerImported(store, meshId);
-      return store.readLedgerEntriesOrdered(meshId).map((r) => {
-        const payload = r.payload && typeof r.payload === "object" ? r.payload : {};
-        const taskId = ledgerEntryTaskId({ taskId: r.taskId ?? void 0, payload });
-        return {
-          id: r.id,
-          meshId: r.meshId,
-          timestamp: r.timestamp,
-          kind: r.kind,
-          ...r.nodeId ? { nodeId: r.nodeId } : {},
-          ...r.sessionId ? { sessionId: r.sessionId } : {},
-          ...r.providerType ? { providerType: r.providerType } : {},
-          ...taskId ? { taskId } : {},
-          payload
-        };
-      });
-    }
-    function getCachedRawEntries(meshId) {
-      const now = Date.now();
-      const cached5 = ledgerReadCache.get(meshId);
-      if (cached5 && now - cached5.cachedAt < LEDGER_CACHE_TTL_MS) return cached5.entries;
-      let entries;
+    function __clearMeshLedgerForTests(meshId) {
       try {
-        entries = readLedgerFromStore(meshId);
+        MeshRuntimeStore.getInstance().clearLedgerForMesh(meshId);
       } catch {
-        entries = readLedgerFile(meshId);
       }
-      ledgerReadCache.set(meshId, { entries, cachedAt: now });
-      return entries;
-    }
-    function invalidateLedgerCache(meshId) {
-      ledgerReadCache.delete(meshId);
+      invalidateLedgerCache(meshId);
+      clearLedgerImportFlag(meshId);
     }
-    function __clearMeshLedgerForTests(meshId) {
+    function readRawEntriesForOpts(meshId, opts) {
+      const cached5 = liveCacheEntry(meshId);
+      if (cached5) return cached5.entries;
+      const hasSince = typeof opts?.since === "string" && !Number.isNaN(new Date(opts.since).getTime());
+      const kinds = opts?.kind?.length ? opts.kind : void 0;
+      if (!hasSince && !kinds) return getCachedRawEntries(meshId);
       try {
-        MeshRuntimeStore.getInstance().clearLedgerForMesh(meshId);
+        const entries = readLedgerFromStore(meshId, {
+          ...hasSince ? { since: opts.since } : {},
+          ...kinds ? { kinds } : {}
+        });
+        recordLedgerPushdownScan(entries.length);
+        return entries;
       } catch {
+        return getCachedRawEntries(meshId);
       }
-      ledgerReadCache.delete(meshId);
-      ledgerImportDone.delete(meshId);
     }
     function readLedgerEntries(meshId, opts) {
-      let entries = getCachedRawEntries(meshId);
+      let entries = readRawEntriesForOpts(meshId, opts);
       if (opts?.since) {
         const sinceDate = new Date(opts.since).getTime();
         if (!isNaN(sinceDate)) entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceDate);
@@ -66398,13 +66980,13 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function rotateLedgerFile(meshId, currentPath) {
       let index = 1;
-      while ((0, import_fs7.existsSync)(getRotatedPath(meshId, index))) {
+      while ((0, import_fs9.existsSync)(getRotatedPath(meshId, index))) {
         index++;
         if (index > 10) break;
       }
       if (index > 10) index = 10;
       try {
-        (0, import_fs7.renameSync)(currentPath, getRotatedPath(meshId, index));
+        (0, import_fs9.renameSync)(currentPath, getRotatedPath(meshId, index));
       } catch (e) {
         process.stderr.write(`[adhdev-mesh] Ledger rotation failed for mesh ${meshId}: ${e?.message || e}. File will continue to grow.
 `);
@@ -66440,7 +67022,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function readRotationEntriesTolerant(filePath) {
       let text;
       try {
-        text = (0, import_fs7.readFileSync)(filePath, "utf-8");
+        text = (0, import_fs9.readFileSync)(filePath, "utf-8");
       } catch {
         return [];
       }
@@ -66459,14 +67041,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return out;
     }
     function evictClosedRotationFile(safe, dir, entry) {
-      const filePath = (0, import_path7.join)(dir, entry.name);
+      const filePath = (0, import_path8.join)(dir, entry.name);
       const counts = readArchivedCounts(safe);
       const alreadyFolded = new Set(counts.evictedRotations ?? []);
       if (alreadyFolded.has(entry.name)) {
-        if ((0, import_fs7.existsSync)(filePath)) (0, import_fs7.unlinkSync)(filePath);
+        if ((0, import_fs9.existsSync)(filePath)) (0, import_fs9.unlinkSync)(filePath);
         return;
       }
-      if (closedRotationKind(safe, entry.name) === "active" && (0, import_fs7.existsSync)(filePath)) {
+      if (closedRotationKind(safe, entry.name) === "active" && (0, import_fs9.existsSync)(filePath)) {
         const entries = readRotationEntriesTolerant(filePath);
         for (const e of entries) {
           if (e.kind === "task_completed") counts.taskCompleted++;
@@ -66479,7 +67061,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       counts.evictedRotations = [...alreadyFolded, entry.name];
       counts.lastArchivedAt = (/* @__PURE__ */ new Date()).toISOString();
       writeArchivedCounts(safe, counts);
-      if ((0, import_fs7.existsSync)(filePath)) (0, import_fs7.unlinkSync)(filePath);
+      if ((0, import_fs9.existsSync)(filePath)) (0, import_fs9.unlinkSync)(filePath);
     }
     function enforceLedgerRotationCap(meshId, opts) {
       const maxFiles = opts?.maxFiles ?? resolveLedgerRotationMaxFiles();
@@ -66490,14 +67072,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const stats = [];
       let names = [];
       try {
-        names = (0, import_fs7.readdirSync)(dir);
+        names = (0, import_fs9.readdirSync)(dir);
       } catch {
         names = [];
       }
       for (const name of names) {
         if (!closedRotationKind(safe, name)) continue;
         try {
-          const st = (0, import_fs7.statSync)((0, import_path7.join)(dir, name));
+          const st = (0, import_fs9.statSync)((0, import_path8.join)(dir, name));
           if (st.isFile()) stats.push({ name, sizeBytes: st.size, mtimeMs: st.mtimeMs });
         } catch {
         }
@@ -66530,7 +67112,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const dir = getLedgerDir2();
       let names = [];
       try {
-        names = (0, import_fs7.readdirSync)(dir);
+        names = (0, import_fs9.readdirSync)(dir);
       } catch {
         return result;
       }
@@ -66556,12 +67138,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       return result;
     }
-    var import_fs7;
-    var import_path7;
+    var import_fs9;
+    var import_path8;
     var import_crypto11;
     var import_events;
     var TASK_LIFECYCLE_LEDGER_KINDS;
-    var LEDGER_DIR_NAME;
     var MAX_FILE_SIZE_BYTES;
     var COMPACT_THRESHOLD_BYTES;
     var ARCHIVE_TERMINAL_OLDER_THAN_MS;
@@ -66578,23 +67159,22 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     var MS_PER_DAY;
     var ARCHIVED_TERMINAL_KEYS_MAX;
     var meshLedgerEvents;
-    var ledgerReadCache;
-    var LEDGER_CACHE_TTL_MS;
-    var ledgerImportStoreRef;
-    var ledgerImportDone;
     var init_mesh_ledger = __esm2({
       "src/mesh/mesh-ledger.ts"() {
         "use strict";
-        import_fs7 = require("fs");
-        import_path7 = require("path");
+        import_fs9 = require("fs");
+        import_path8 = require("path");
         import_crypto11 = require("crypto");
-        init_config();
         init_mesh_retention_config();
         init_dist();
         import_events = require("events");
         init_mesh_runtime_store();
+        init_mesh_ledger_paths();
+        init_mesh_ledger_read_cache();
         init_mesh_dual_write();
         init_contracts();
+        init_mesh_ledger_paths();
+        init_mesh_ledger_read_cache();
         TASK_LIFECYCLE_LEDGER_KINDS = /* @__PURE__ */ new Set([
           "task_dispatched",
           "task_claimed",
@@ -66613,7 +67193,6 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           // redrive history without an O(n) payload scan.
           "redrive_provider_changed"
         ]);
-        LEDGER_DIR_NAME = "mesh-ledger";
         MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
         COMPACT_THRESHOLD_BYTES = 2 * 1024 * 1024;
         ARCHIVE_TERMINAL_OLDER_THAN_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -66643,9 +67222,6 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         MS_PER_DAY = 24 * 60 * 60 * 1e3;
         ARCHIVED_TERMINAL_KEYS_MAX = 5e3;
         meshLedgerEvents = new import_events.EventEmitter();
-        ledgerReadCache = /* @__PURE__ */ new Map();
-        LEDGER_CACHE_TTL_MS = 100;
-        ledgerImportDone = /* @__PURE__ */ new Set();
       }
     });
     var coordinator_prompt_exports = {};
@@ -67726,10 +68302,10 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         return { config: inline, source: "mesh.policy.refineConfig", sourceType: "mesh_policy" };
       }
       for (const relative8 of MESH_REFINE_CONFIG_LOCATIONS) {
-        const configPath = (0, import_path8.join)(workspace, relative8);
-        if (!(0, import_fs8.existsSync)(configPath)) continue;
+        const configPath = (0, import_path9.join)(workspace, relative8);
+        if (!(0, import_fs10.existsSync)(configPath)) continue;
         try {
-          const parsed = parseConfigText3(configPath, (0, import_fs8.readFileSync)(configPath, "utf-8"));
+          const parsed = parseConfigText3(configPath, (0, import_fs10.readFileSync)(configPath, "utf-8"));
           const validation = validateMeshRefineConfig(parsed, relative8);
           if (!validation.valid) return { source: relative8, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
           return { config: parsed, source: relative8, sourceType: "repo_file", path: configPath };
@@ -67745,7 +68321,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
     }
     function readPackageScripts(workspace) {
       try {
-        const parsed = JSON.parse((0, import_fs8.readFileSync)((0, import_path8.join)(workspace, "package.json"), "utf-8"));
+        const parsed = JSON.parse((0, import_fs10.readFileSync)((0, import_path9.join)(workspace, "package.json"), "utf-8"));
         return isRecord3(parsed?.scripts) ? parsed.scripts : {};
       } catch {
         return {};
@@ -67820,8 +68396,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         unavailableReason: validation.commands.length ? void 0 : "validation_unavailable: repo mesh/refine config has no validation.commands"
       };
     }
-    var import_fs8;
-    var import_path8;
+    var import_fs10;
+    var import_path9;
     var yaml3;
     var MESH_REFINE_VALIDATION_CATEGORIES;
     var MESH_REFINE_VALIDATION_SCOPES;
@@ -67834,8 +68410,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
     var init_refine_config = __esm2({
       "src/mesh/refine-config.ts"() {
         "use strict";
-        import_fs8 = require("fs");
-        import_path8 = require("path");
+        import_fs10 = require("fs");
+        import_path9 = require("path");
         yaml3 = __toESM2(require_js_yaml());
         MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
         MESH_REFINE_VALIDATION_SCOPES = ["none", "web", "daemon"];
@@ -67942,7 +68518,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         if (!dir) continue;
         for (const ext of WIN_EXEC_EXT) {
           const full = path232.join(dir, trimmed + ext);
-          if ((0, import_fs9.existsSync)(full)) return full;
+          if ((0, import_fs11.existsSync)(full)) return full;
         }
       }
       return null;
@@ -67959,7 +68535,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       if (process.platform !== "win32") return command;
       const trimmed = (command || "").trim();
       if (!trimmed) return command;
-      if (path232.isAbsolute(trimmed) && (0, import_fs9.existsSync)(trimmed)) return trimmed;
+      if (path232.isAbsolute(trimmed) && (0, import_fs11.existsSync)(trimmed)) return trimmed;
       try {
         const out = (0, import_child_process3.execFileSync)("where", [trimmed], {
           encoding: "utf8",
@@ -68008,7 +68584,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       };
     }
     var import_child_process3;
-    var import_fs9;
+    var import_fs11;
     var path232;
     var DIRECT_EXEC_EXT;
     var SHIM_EXEC_EXT;
@@ -68017,7 +68593,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       "src/cli-adapters/resolve-executable.ts"() {
         "use strict";
         import_child_process3 = require("child_process");
-        import_fs9 = require("fs");
+        import_fs11 = require("fs");
         path232 = __toESM2(require("path"));
         DIRECT_EXEC_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
         SHIM_EXEC_EXT = /* @__PURE__ */ new Set([".cmd", ".bat"]);
@@ -68155,7 +68731,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       if (!Number.isFinite(startedMs)) return false;
       if (nowMs - startedMs <= WORKTREE_BOOTSTRAP_STALE_RUNNING_MS) return false;
       const workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
-      if (!workspace || !(0, import_fs10.existsSync)(workspace)) return false;
+      if (!workspace || !(0, import_fs12.existsSync)(workspace)) return false;
       try {
         const out = (0, import_node_child_process4.execFileSync)(resolveWin32Executable("git"), ["status", "--porcelain"], {
           cwd: workspace,
@@ -68218,10 +68794,10 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         return { config: inline, source: "mesh.policy.worktreeBootstrapConfig", sourceType: "mesh_policy" };
       }
       for (const relative8 of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
-        const configPath = (0, import_path9.join)(workspace, relative8);
-        if (!(0, import_fs10.existsSync)(configPath)) continue;
+        const configPath = (0, import_path10.join)(workspace, relative8);
+        if (!(0, import_fs12.existsSync)(configPath)) continue;
         try {
-          const parsed = parseConfigText4(configPath, (0, import_fs10.readFileSync)(configPath, "utf-8"));
+          const parsed = parseConfigText4(configPath, (0, import_fs12.readFileSync)(configPath, "utf-8"));
           const validation = validateMeshWorktreeBootstrapConfig(parsed, relative8);
           if (!validation.valid) return { source: relative8, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
           return { config: parsed, source: relative8, sourceType: "repo_file", path: configPath };
@@ -68234,9 +68810,9 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
     function computeStaleInputsDigest(workspace, staleInputs) {
       const digest = {};
       for (const relative8 of staleInputs ?? []) {
-        const filePath = (0, import_path9.join)(workspace, relative8);
+        const filePath = (0, import_path10.join)(workspace, relative8);
         try {
-          digest[relative8] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs10.readFileSync)(filePath)).digest("hex");
+          digest[relative8] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs12.readFileSync)(filePath)).digest("hex");
         } catch {
           digest[relative8] = "absent";
         }
@@ -68307,10 +68883,10 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         staleInputs: loaded.config.staleInputs
       };
       const staleInputPaths = loaded.config.staleInputs ?? [];
-      const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs10.existsSync)((0, import_path9.join)(workspace, p)));
+      const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs12.existsSync)((0, import_path10.join)(workspace, p)));
       for (const command of validation.commands) {
         if (initiallyAbsent.length > 0) {
-          const appearedNow = initiallyAbsent.filter((p) => (0, import_fs10.existsSync)((0, import_path9.join)(workspace, p)));
+          const appearedNow = initiallyAbsent.filter((p) => (0, import_fs12.existsSync)((0, import_path10.join)(workspace, p)));
           if (appearedNow.length > 0) {
             state.status = "stale";
             state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -68318,7 +68894,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
             return state;
           }
         }
-        const cwd = command.cwd ? (0, import_path9.resolve)(workspace, command.cwd) : workspace;
+        const cwd = command.cwd ? (0, import_path10.resolve)(workspace, command.cwd) : workspace;
         const startedAt = Date.now();
         state.lastCommand = command.displayCommand;
         const resolvedCommand = resolveWin32Executable(command.command);
@@ -68378,8 +68954,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       }
       return state;
     }
-    var import_fs10;
-    var import_path9;
+    var import_fs12;
+    var import_path10;
     var import_node_child_process4;
     var import_node_crypto2;
     var import_node_util3;
@@ -68394,8 +68970,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
     var init_worktree_bootstrap_config = __esm2({
       "src/mesh/worktree-bootstrap-config.ts"() {
         "use strict";
-        import_fs10 = require("fs");
-        import_path9 = require("path");
+        import_fs12 = require("fs");
+        import_path10 = require("path");
         import_node_child_process4 = require("child_process");
         import_node_crypto2 = require("crypto");
         import_node_util3 = require("util");
@@ -68930,13 +69506,13 @@ ${rendered}`, "utf-8");
       }
     });
     function getRegistryPath() {
-      return (0, import_path11.join)(getDaemonDataDir(), "mesh-coordinators.json");
+      return (0, import_path12.join)(getDaemonDataDir(), "mesh-coordinators.json");
     }
     function loadMeshCoordinatorRegistry() {
       const path63 = getRegistryPath();
-      if (!(0, import_fs12.existsSync)(path63)) return;
+      if (!(0, import_fs14.existsSync)(path63)) return;
       try {
-        const raw = JSON.parse((0, import_fs12.readFileSync)(path63, "utf-8"));
+        const raw = JSON.parse((0, import_fs14.readFileSync)(path63, "utf-8"));
         if (!Array.isArray(raw)) return;
         _registry.clear();
         for (const entry of raw) {
@@ -68949,7 +69525,7 @@ ${rendered}`, "utf-8");
     }
     function saveRegistry() {
       try {
-        (0, import_fs12.writeFileSync)(
+        (0, import_fs14.writeFileSync)(
           getRegistryPath(),
           JSON.stringify([..._registry.values()], null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -68986,14 +69562,14 @@ ${rendered}`, "utf-8");
     function listCoordinatorsForMesh(meshId) {
       return [..._registry.values()].filter((e) => e.meshId === meshId).sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
     }
-    var import_path11;
-    var import_fs12;
+    var import_path12;
+    var import_fs14;
     var _registry;
     var init_coordinator_registry = __esm2({
       "src/mesh/coordinator-registry.ts"() {
         "use strict";
-        import_path11 = require("path");
-        import_fs12 = require("fs");
+        import_path12 = require("path");
+        import_fs14 = require("fs");
         init_config();
         _registry = /* @__PURE__ */ new Map();
       }
@@ -76656,7 +77232,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (now - lastAttempt < IDLE_AUTO_FAST_FORWARD_THROTTLE_MS) return;
       idleAutoFastForwardLastAttempt.set(throttleKey, now);
       if (isLocalAutoLaunchNode(node)) {
-        if (!(0, import_fs14.existsSync)(workspace)) return;
+        if (!(0, import_fs16.existsSync)(workspace)) return;
         await executeLocalAutoFastForward({ meshId: args.meshId, nodeId: args.nodeId, node, workspace, policy, trigger: "idle_auto" });
         return;
       }
@@ -76746,7 +77322,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       }
     }
-    var import_fs14;
+    var import_fs16;
     var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS;
     var idleAutoFastForwardLastAttempt;
     var CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS;
@@ -76755,7 +77331,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var init_mesh_auto_fast_forward = __esm2({
       "src/mesh/mesh-auto-fast-forward.ts"() {
         "use strict";
-        import_fs14 = require("fs");
+        import_fs16 = require("fs");
         init_logger();
         init_config();
         init_mesh_fast_forward();
@@ -79607,7 +80183,7 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
     function getStatePath() {
-      return (0, import_path13.join)(getConfigDir2(), "state.json");
+      return (0, import_path14.join)(getConfigDir2(), "state.json");
     }
     function normalizeState(raw) {
       const parsed = isPlainObject22(raw) ? raw : {};
@@ -79658,11 +80234,11 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
     }
     function loadState() {
       const statePath = getStatePath();
-      if (!(0, import_fs15.existsSync)(statePath)) {
+      if (!(0, import_fs17.existsSync)(statePath)) {
         return { ...DEFAULT_STATE };
       }
       try {
-        const raw = (0, import_fs15.readFileSync)(statePath, "utf-8");
+        const raw = (0, import_fs17.readFileSync)(statePath, "utf-8");
         return normalizeState(JSON.parse(raw));
       } catch {
         return { ...DEFAULT_STATE };
@@ -79671,7 +80247,7 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
     function saveState(state) {
       const statePath = getStatePath();
       const normalized = normalizeState(state);
-      (0, import_fs15.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs17.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function resetState() {
       saveState({ ...DEFAULT_STATE });
@@ -79711,14 +80287,14 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
       delete next[key2];
       saveState({ ...state, deferredRestartSchedules: next });
     }
-    var import_fs15;
-    var import_path13;
+    var import_fs17;
+    var import_path14;
     var DEFAULT_STATE;
     var init_state_store = __esm2({
       "src/config/state-store.ts"() {
         "use strict";
-        import_fs15 = require("fs");
-        import_path13 = require("path");
+        import_fs17 = require("fs");
+        import_path14 = require("path");
         init_config();
         DEFAULT_STATE = {
           recentActivity: [],
@@ -84014,7 +84590,7 @@ ${cleanBody}`;
     }
     function readDiskSpace(path63) {
       try {
-        const stats = (0, import_fs16.statfsSync)(path63);
+        const stats = (0, import_fs18.statfsSync)(path63);
         const blockSize = Number(stats.bsize);
         const freeBytes = Number(stats.bavail) * blockSize;
         const totalBytes = Number(stats.blocks) * blockSize;
@@ -84061,7 +84637,7 @@ ${cleanBody}`;
       }
       return status;
     }
-    var import_fs16;
+    var import_fs18;
     var DISK_CRITICAL_PERCENT_FREE;
     var DISK_CRITICAL_FREE_BYTES;
     var DISK_WARNING_PERCENT_FREE;
@@ -84070,7 +84646,7 @@ ${cleanBody}`;
     var init_disk_space_preflight = __esm2({
       "src/diagnostics/disk-space-preflight.ts"() {
         "use strict";
-        import_fs16 = require("fs");
+        import_fs18 = require("fs");
         init_logger();
         DISK_CRITICAL_PERCENT_FREE = 2;
         DISK_CRITICAL_FREE_BYTES = 1 * 1024 * 1024 * 1024;
@@ -84122,7 +84698,7 @@ ${cleanBody}`;
     }
     function safeUnlink(path63) {
       try {
-        (0, import_fs17.unlinkSync)(path63);
+        (0, import_fs19.unlinkSync)(path63);
         return true;
       } catch (e) {
         LOG2.warn("DiskRetention", `Failed to delete ${path63}: ${e?.message || e}`);
@@ -84130,18 +84706,18 @@ ${cleanBody}`;
       }
     }
     function listDirFiles(dir) {
-      if (!(0, import_fs17.existsSync)(dir)) return [];
+      if (!(0, import_fs19.existsSync)(dir)) return [];
       const out = [];
       let names;
       try {
-        names = (0, import_fs17.readdirSync)(dir);
+        names = (0, import_fs19.readdirSync)(dir);
       } catch {
         return [];
       }
       for (const name of names) {
-        const path63 = (0, import_path14.join)(dir, name);
+        const path63 = (0, import_path15.join)(dir, name);
         try {
-          const st = (0, import_fs17.statSync)(path63);
+          const st = (0, import_fs19.statSync)(path63);
           if (st.isFile()) out.push({ path: path63, mtimeMs: st.mtimeMs });
         } catch {
         }
@@ -84167,23 +84743,23 @@ ${cleanBody}`;
       return deleted;
     }
     function pruneExpiredSessionHostRuntimes(now = Date.now()) {
-      const root = (0, import_path14.join)(getConfigDir2(), "session-host");
-      if (!(0, import_fs17.existsSync)(root)) return 0;
+      const root = (0, import_path15.join)(getConfigDir2(), "session-host");
+      if (!(0, import_fs19.existsSync)(root)) return 0;
       let apps;
       try {
-        apps = (0, import_fs17.readdirSync)(root);
+        apps = (0, import_fs19.readdirSync)(root);
       } catch {
         return 0;
       }
       const candidates = [];
       for (const app of apps) {
-        const runtimesDir = (0, import_path14.join)(root, app, "runtimes");
-        if (!(0, import_fs17.existsSync)(runtimesDir)) continue;
+        const runtimesDir = (0, import_path15.join)(root, app, "runtimes");
+        if (!(0, import_fs19.existsSync)(runtimesDir)) continue;
         for (const f of listDirFiles(runtimesDir)) {
           if (!f.path.endsWith(".json")) continue;
           let record2 = null;
           try {
-            const parsed = JSON.parse((0, import_fs17.readFileSync)(f.path, "utf-8"));
+            const parsed = JSON.parse((0, import_fs19.readFileSync)(f.path, "utf-8"));
             const rec = parsed && typeof parsed === "object" ? parsed.record : null;
             record2 = rec && typeof rec === "object" ? rec : null;
           } catch {
@@ -84288,8 +84864,8 @@ ${cleanBody}`;
       }
       return signalled;
     }
-    var import_fs17;
-    var import_path14;
+    var import_fs19;
+    var import_path15;
     var DAY_MS2;
     var LEDGER_JSONL_MAX_AGE_MS;
     var SESSION_HOST_RUNTIME_MAX_AGE_MS;
@@ -84298,8 +84874,8 @@ ${cleanBody}`;
     var init_mesh_disk_retention = __esm2({
       "src/mesh/mesh-disk-retention.ts"() {
         "use strict";
-        import_fs17 = require("fs");
-        import_path14 = require("path");
+        import_fs19 = require("fs");
+        import_path15 = require("path");
         init_config();
         init_mesh_ledger();
         init_runtime_surface();
@@ -84314,7 +84890,7 @@ ${cleanBody}`;
       }
     });
     function retentionStatePath() {
-      return (0, import_path15.join)(getLedgerDir2(), "worktree-node-retention-state.json");
+      return (0, import_path16.join)(getLedgerDir2(), "worktree-node-retention-state.json");
     }
     function stateKey(meshId, nodeId) {
       return `${meshId}::${nodeId}`;
@@ -84379,7 +84955,7 @@ ${cleanBody}`;
       return String(stdout || "");
     }
     function normalizePathForCompare(value) {
-      const resolved = (0, import_path15.resolve)(value);
+      const resolved = (0, import_path16.resolve)(value);
       try {
         return fs17.realpathSync(resolved);
       } catch {
@@ -84432,7 +85008,7 @@ ${cleanBody}`;
       if (workspace && ctx.processCwd) {
         const normalizedWorkspace = normalizePathForCompare(workspace);
         const normalizedCwd = normalizePathForCompare(ctx.processCwd);
-        if (normalizedCwd === normalizedWorkspace || normalizedCwd.startsWith(normalizedWorkspace + import_path15.sep)) {
+        if (normalizedCwd === normalizedWorkspace || normalizedCwd.startsWith(normalizedWorkspace + import_path16.sep)) {
           return skip("process_cwd_reference", "Worktree path is (or contains) the current process working directory; an open-runtime/cwd reference blocks removal.");
         }
       }
@@ -84813,7 +85389,7 @@ ${cleanBody}`;
     }
     var fs17;
     var import_os22;
-    var import_path15;
+    var import_path16;
     var LOG_CATEGORY;
     var metrics2;
     var init_mesh_worktree_retention = __esm2({
@@ -84821,7 +85397,7 @@ ${cleanBody}`;
         "use strict";
         fs17 = __toESM2(require("fs"));
         import_os22 = require("os");
-        import_path15 = require("path");
+        import_path16 = require("path");
         init_dist();
         init_logger();
         init_config();
@@ -91201,8 +91777,8 @@ ${cleanBody}`;
     }
     function probeSubmoduleGitlinkReachability(input) {
       const { path: path63, baseCommit, branchCommit, probeRoot, baseRepoRoot } = input;
-      const submoduleRepo = (0, import_path16.resolve)(probeRoot, path63);
-      const baseSubmoduleRepo = (0, import_path16.resolve)(baseRepoRoot, path63);
+      const submoduleRepo = (0, import_path17.resolve)(probeRoot, path63);
+      const baseSubmoduleRepo = (0, import_path17.resolve)(baseRepoRoot, path63);
       if (baseCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, baseCommit);
       if (branchCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, branchCommit);
       let fastForward;
@@ -91372,7 +91948,7 @@ ${cleanBody}`;
     }
     var fs50;
     var import_node_child_process9;
-    var import_path16;
+    var import_path17;
     var GIT2;
     var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
     var init_mesh_refine_gitlink_utils = __esm2({
@@ -91380,7 +91956,7 @@ ${cleanBody}`;
         "use strict";
         fs50 = __toESM2(require("fs"));
         import_node_child_process9 = require("child_process");
-        import_path16 = require("path");
+        import_path17 = require("path");
         init_logger();
         init_resolve_executable();
         GIT2 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
@@ -91506,9 +92082,9 @@ ${cleanBody}`;
       for (const path63 of changed) {
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path63);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path63);
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path63);
+        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path63);
         if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path63), baseCommit);
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path63), baseCommit);
         }
         const markUndeterminable = () => {
           const unavailable = [];
@@ -91731,7 +92307,7 @@ ${cleanBody}`;
         for (const p of conflicts) {
           const commit = resolveByPath.get(p);
           try {
-            (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path18.resolve)(worktreeRoot, p), stdio: "ignore" });
           } catch {
           }
           try {
@@ -91750,7 +92326,7 @@ ${cleanBody}`;
       return { ok: true, branchHead };
     }
     var fs51;
-    var import_path17;
+    var import_path18;
     var import_node_child_process10;
     var SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION;
     var SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION;
@@ -91758,7 +92334,7 @@ ${cleanBody}`;
       "src/mesh/mesh-refine-submodule-converge.ts"() {
         "use strict";
         fs51 = __toESM2(require("fs"));
-        import_path17 = require("path");
+        import_path18 = require("path");
         import_node_child_process10 = require("child_process");
         init_mesh_refine_gitlink_utils();
         SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION = "Publish the branch-side submodule commit(s) to submodule origin main, then rerun mesh_refine_node. Do NOT retry the rebase: the branch was intentionally left unrewritten because a rebase here would mint a submodule commit the reachability gate must reject.";
@@ -91782,10 +92358,10 @@ ${tail}`;
     }
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
-        const dir = (0, import_path18.join)(workspace, REFINE_VALIDATION_LOG_DIR);
+        const dir = (0, import_path19.join)(workspace, REFINE_VALIDATION_LOG_DIR);
         fs52.mkdirSync(dir, { recursive: true });
         const stamp2 = now().toISOString().replace(/[:.]/g, "-");
-        const file2 = (0, import_path18.join)(dir, `refine-${stamp2}-${index}.log`);
+        const file2 = (0, import_path19.join)(dir, `refine-${stamp2}-${index}.log`);
         const asText = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
         const shown = candidate.displayCommand || [candidate.command, ...candidate.args || []].join(" ");
         fs52.writeFileSync(
@@ -92270,7 +92846,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path63);
         const branchCommit = readTreeObject(repoRoot, branchHead, path63);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path63), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path19.resolve)(repoRoot, path63), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -92279,8 +92855,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path63);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path63);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path63);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path63), baseCommit);
+        const submoduleRepoPath = (0, import_path19.resolve)(worktreeRoot, path63);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path19.resolve)(baseRepoRoot, path63), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -92296,7 +92872,7 @@ ${mergeTreeErr?.stderr || ""}`;
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path63) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path63);
         const branchCommit = readTreeObject(repoRoot, branchHead, path63);
-        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path63);
+        const submoduleRepoPath = (0, import_path19.resolve)(repoRoot, path63);
         const probe = !!baseCommit && !!branchCommit ? probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) : "undeterminable";
         return {
           path: path63,
@@ -92359,7 +92935,7 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path63) => `160000 commit ${placeholderCommit}	${path63}`).join("\n");
         if (!updates) return tree;
-        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path19.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process11.execFileSync)(GIT2, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -92434,7 +93010,7 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!contentTree) return void 0;
         const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
         if (!updates) return contentTree;
-        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path19.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process11.execFileSync)(GIT2, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -92593,7 +93169,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return match ? { commit: match[1], path: match[2] } : null;
         }).filter((entry) => !!entry);
         for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path18.resolve)(repoRoot, gitlink.path);
+          const submodulePath = (0, import_path19.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -92620,7 +93196,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path18.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path19.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
                   if (imported) {
                     entry.localReachable = true;
                     entry.importedFromWorktree = true;
@@ -92872,13 +93448,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path18.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+        const command = (0, import_path19.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs52.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
-        if (fs52.existsSync((0, import_path18.join)(cwd, "node_modules"))) return false;
-        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs52.existsSync((0, import_path18.join)(cwd, lock)));
+        if (!fs52.existsSync((0, import_path19.join)(cwd, "package.json"))) return false;
+        if (fs52.existsSync((0, import_path19.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs52.existsSync((0, import_path19.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -92945,7 +93521,7 @@ ${mergeTreeErr?.stderr || ""}`;
         summary.bootstrap = { stage: "legacy" };
         for (const candidate of selection.bootstrapCommands) {
           const startedAt = Date.now();
-          const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
+          const cwd = candidate.cwd ? (0, import_path19.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           const resolvedCommand = resolveWin32Executable(candidate.command);
           const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -92978,7 +93554,7 @@ ${mergeTreeErr?.stderr || ""}`;
       let missingDepsBlocked = false;
       for (const candidate of commandsToRun) {
         const startedAt = Date.now();
-        const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
+        const cwd = candidate.cwd ? (0, import_path19.resolve)(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
         if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
@@ -93045,7 +93621,7 @@ ${mergeTreeErr?.stderr || ""}`;
       summary.status = "passed";
       return summary;
     }
-    var import_path18;
+    var import_path19;
     var fs52;
     var import_node_child_process11;
     var REFINE_VALIDATION_TIMEOUT_MS;
@@ -93060,7 +93636,7 @@ ${mergeTreeErr?.stderr || ""}`;
         init_git_status();
         init_refine_config();
         init_worktree_bootstrap_config();
-        import_path18 = require("path");
+        import_path19 = require("path");
         fs52 = __toESM2(require("fs"));
         import_node_child_process11 = require("child_process");
         init_resolve_executable();
@@ -93073,7 +93649,7 @@ ${mergeTreeErr?.stderr || ""}`;
         REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
         REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
         REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-        REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
+        REFINE_VALIDATION_LOG_DIR = (0, import_path19.join)(".adhdev", "logs");
       }
     });
     async function runMeshRefineSubmoduleReachabilityPreflight(args) {
@@ -93082,7 +93658,7 @@ ${mergeTreeErr?.stderr || ""}`;
       if (touched.length === 0) return void 0;
       const entries = [];
       for (const path63 of touched) {
-        const probedRepo = (0, import_path19.resolve)(args.worktreeRoot, path63);
+        const probedRepo = (0, import_path20.resolve)(args.worktreeRoot, path63);
         const commit = readTreeObject(args.worktreeRoot, args.branchRef, path63);
         if (!commit) {
           entries.push({
@@ -93237,7 +93813,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     var import_node_child_process12;
     var import_node_util6;
-    var import_path19;
+    var import_path20;
     var execFileAsync5;
     var runGit2;
     var init_mesh_refine_submodule_preflight = __esm2({
@@ -93245,7 +93821,7 @@ ${mergeTreeErr?.stderr || ""}`;
         "use strict";
         import_node_child_process12 = require("child_process");
         import_node_util6 = require("util");
-        import_path19 = require("path");
+        import_path20 = require("path");
         init_dist();
         init_mesh_refine_gitlink_utils();
         init_mesh_refine_gates();
@@ -98533,8 +99109,8 @@ ${e?.stderr || ""}`;
     init_git_locale();
     init_repo_mesh_types();
     init_mesh_config();
-    var import_fs11 = require("fs");
-    var import_path10 = require("path");
+    var import_fs13 = require("fs");
+    var import_path11 = require("path");
     init_refine_config();
     init_worktree_bootstrap_config();
     init_change_impact_config();
@@ -98553,22 +99129,22 @@ ${e?.stderr || ""}`;
       "requirements.txt"
     ];
     function writeConfigFile(workspace, relativePath, config2) {
-      const target = (0, import_path10.join)(workspace, relativePath);
-      (0, import_fs11.mkdirSync)((0, import_path10.dirname)(target), { recursive: true });
-      (0, import_fs11.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
+      const target = (0, import_path11.join)(workspace, relativePath);
+      (0, import_fs13.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
+      (0, import_fs13.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
       return target;
     }
     function suggestMeshWorktreeBootstrapConfig(workspace) {
       const commands = [];
-      const hasPackageJson = (0, import_fs11.existsSync)((0, import_path10.join)(workspace, "package.json"));
-      const hasNpmLock = (0, import_fs11.existsSync)((0, import_path10.join)(workspace, "package-lock.json"));
+      const hasPackageJson = (0, import_fs13.existsSync)((0, import_path11.join)(workspace, "package.json"));
+      const hasNpmLock = (0, import_fs13.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
       if (hasPackageJson) {
         commands.push(
           hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
         );
       }
-      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative8) => (0, import_fs11.existsSync)((0, import_path10.join)(workspace, relative8)));
+      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative8) => (0, import_fs13.existsSync)((0, import_path11.join)(workspace, relative8)));
       if (!commands.length) {
         return { commands, staleInputs };
       }
@@ -98667,7 +99243,7 @@ ${e?.stderr || ""}`;
     }
     function applyConfigSuggestion(input) {
       const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-      const absolute = (0, import_path10.join)(workspace, relativePath);
+      const absolute = (0, import_path11.join)(workspace, relativePath);
       if (existing !== void 0 && !overwrite) {
         return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
       }
@@ -99208,8 +99784,8 @@ ${e?.stderr || ""}`;
     function isMeshTestPollution(args) {
       return isSyntheticTestMeshId(args.meshId) || isSyntheticTestCoordinatorSession(args.coordinatorSessionId);
     }
-    var import_fs13 = require("fs");
-    var import_path12 = require("path");
+    var import_fs15 = require("fs");
+    var import_path13 = require("path");
     init_config();
     var ZERO = {
       inputTokens: 0,
@@ -99326,13 +99902,13 @@ ${e?.stderr || ""}`;
       lastEvictedAt: 0
     };
     function getUsageDir() {
-      const dir = (0, import_path12.join)(getConfigDir2(), USAGE_DIR_NAME);
-      if (!(0, import_fs13.existsSync)(dir)) (0, import_fs13.mkdirSync)(dir, { recursive: true, mode: 448 });
+      const dir = (0, import_path13.join)(getConfigDir2(), USAGE_DIR_NAME);
+      if (!(0, import_fs15.existsSync)(dir)) (0, import_fs15.mkdirSync)(dir, { recursive: true, mode: 448 });
       return dir;
     }
     function getUsagePath(meshId) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path12.join)(getUsageDir(), `${safe}.json`);
+      return (0, import_path13.join)(getUsageDir(), `${safe}.json`);
     }
     function emptyFile(meshId) {
       return { version: 1, meshId, sessions: {} };
@@ -99342,7 +99918,7 @@ ${e?.stderr || ""}`;
       const path63 = getUsagePath(meshId);
       let stat2;
       try {
-        const s2 = (0, import_fs13.statSync)(path63);
+        const s2 = (0, import_fs15.statSync)(path63);
         stat2 = { mtimeMs: s2.mtimeMs, size: s2.size };
       } catch {
         usageFileCache.delete(path63);
@@ -99353,7 +99929,7 @@ ${e?.stderr || ""}`;
         return cached5.file;
       }
       try {
-        const parsed = JSON.parse((0, import_fs13.readFileSync)(path63, "utf-8"));
+        const parsed = JSON.parse((0, import_fs15.readFileSync)(path63, "utf-8"));
         if (!parsed || typeof parsed !== "object" || !parsed.sessions) {
           usageFileCache.delete(path63);
           return emptyFile(meshId);
@@ -99368,19 +99944,19 @@ ${e?.stderr || ""}`;
     function writeUsageFile(meshId, file2) {
       const path63 = getUsagePath(meshId);
       const tmp = `${path63}.tmp`;
-      (0, import_fs13.writeFileSync)(tmp, JSON.stringify(file2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs15.writeFileSync)(tmp, JSON.stringify(file2), { encoding: "utf-8", mode: 384 });
       try {
-        (0, import_fs13.renameSync)(tmp, path63);
+        (0, import_fs15.renameSync)(tmp, path63);
       } catch (e) {
         try {
-          (0, import_fs13.unlinkSync)(tmp);
+          (0, import_fs15.unlinkSync)(tmp);
         } catch {
         }
         usageFileCache.delete(path63);
         throw e;
       }
       try {
-        const s2 = (0, import_fs13.statSync)(path63);
+        const s2 = (0, import_fs15.statSync)(path63);
         usageFileCache.set(path63, { file: file2, mtimeMs: s2.mtimeMs, size: s2.size });
       } catch {
         usageFileCache.delete(path63);
@@ -100896,7 +101472,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
     init_state_store();
     var import_child_process5 = require("child_process");
     var import_util22 = require("util");
-    var import_fs18 = require("fs");
+    var import_fs20 = require("fs");
     var import_os3 = require("os");
     var path27 = __toESM2(require("path"));
     var fs18 = __toESM2(require("fs"));
@@ -100973,7 +101549,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
       if (path27.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
         const candidate = trimmed.startsWith("~") ? path27.join((0, import_os3.homedir)(), trimmed.slice(1)) : trimmed;
         const resolved = path27.isAbsolute(candidate) ? candidate : path27.resolve(candidate);
-        return (0, import_fs18.existsSync)(resolved) ? resolved : null;
+        return (0, import_fs20.existsSync)(resolved) ? resolved : null;
       }
       const isWin = (0, import_os3.platform)() === "win32";
       const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -100983,8 +101559,8 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
         for (const ext of exes) {
           const fullPath = path27.join(p, trimmed + ext);
           try {
-            if ((0, import_fs18.existsSync)(fullPath)) {
-              const stat2 = (0, import_fs18.statSync)(fullPath);
+            if ((0, import_fs20.existsSync)(fullPath)) {
+              const stat2 = (0, import_fs20.statSync)(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -101002,9 +101578,9 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs18.existsSync)(resolved)) return resolved;
+          if ((0, import_fs20.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs18.existsSync)(normalized)) return normalized;
+          if ((0, import_fs20.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -101018,7 +101594,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os35 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs18.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs20.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os35 === "win32") {
           const { dirname: dirname25 } = await import("path");
@@ -101031,7 +101607,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs18.existsSync)(c)) {
+            if ((0, import_fs20.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -112960,7 +113536,7 @@ ${marker}`,
     var os26 = __toESM2(require("os"));
     var path43 = __toESM2(require("path"));
     var crypto6 = __toESM2(require("crypto"));
-    var import_fs19 = require("fs");
+    var import_fs21 = require("fs");
     var import_child_process11 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     var fs34 = __toESM2(require("fs"));
@@ -115605,7 +116181,7 @@ ${marker}`,
         return v;
       });
       if (missing) return null;
-      return out;
+      return out.includes("*") ? out : path38.normalize(out);
     }
     function claudeProjectDirName(workspace) {
       return workspace.replace(/[^A-Za-z0-9_-]/g, "-");
@@ -117919,8 +118495,8 @@ ${marker}`,
         const landedQuestion = readFocusedClaudeTuiQuestion(landed.screenText);
         const rereadQuestion = readFocusedClaudeTuiQuestion(reread);
         if (!landedQuestion || !rereadQuestion) return true;
-        const normalize6 = (text) => text.replace(/\s+/g, " ").trim();
-        return normalize6(landedQuestion.question) === normalize6(rereadQuestion.question);
+        const normalize7 = (text) => text.replace(/\s+/g, " ").trim();
+        return normalize7(landedQuestion.question) === normalize7(rereadQuestion.question);
       }
       async captureClaudeTuiPrompt(firstScreen, headers) {
         if (this.claudeTuiCaptureSuppressed) return;
@@ -118137,8 +118713,8 @@ ${marker}`,
       };
     }
     function isPathInsideWorkspace(configPath, workspace) {
-      const normalize6 = (value) => value.replace(/[\\/]+$/, "");
-      const ws = normalize6(workspace);
+      const normalize7 = (value) => value.replace(/[\\/]+$/, "");
+      const ws = normalize7(workspace);
       if (!ws) return false;
       const separatorAgnostic = (value) => value.replace(/\\/g, "/");
       const normalizedPath = separatorAgnostic(configPath);
@@ -124518,7 +125094,7 @@ ${rawInput}` : rawInput;
       const trimmed = command.trim();
       if (!trimmed) return false;
       if (isExplicitCommand(trimmed)) {
-        return (0, import_fs19.existsSync)(expandExecutable(trimmed));
+        return (0, import_fs21.existsSync)(expandExecutable(trimmed));
       }
       try {
         (0, import_child_process11.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -124664,10 +125240,10 @@ ${rawInput}` : rawInput;
     }
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path43.join(os26.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-      (0, import_fs19.mkdirSync)(baseDir, { recursive: true });
+      (0, import_fs21.mkdirSync)(baseDir, { recursive: true });
       const workspaceHash = shortHash(path43.resolve(workspace || os26.tmpdir()));
       const filePath = path43.join(baseDir, `${workspaceHash}.json`);
-      (0, import_fs19.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+      (0, import_fs21.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
     }
     function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -131505,9 +132081,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
       compareVersions(a, b) {
-        const normalize6 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
-        const pa = normalize6(a);
-        const pb = normalize6(b);
+        const normalize7 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
+        const pa = normalize7(a);
+        const pb = normalize7(b);
         for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
           const va = pa[i] || 0;
           const vb = pb[i] || 0;
@@ -132391,11 +132967,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
           const { mkdirSync: mkdirSync34, writeFileSync: writeFileSync32 } = await import("fs");
-          const { dirname: dirname25, join: join73 } = await import("path");
+          const { dirname: dirname25, join: join74 } = await import("path");
           const scaffold = buildMeshJsonConfigScaffold2(mesh);
           const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
-          const absolutePath = join73(workspace, relativePath);
+          const absolutePath = join74(workspace, relativePath);
           const validation = normalizeRepoMeshDeclarativeConfig2(scaffold);
           if (!validation.valid) {
             return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join("; ")}` };
@@ -132501,18 +133077,18 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
-          const { existsSync: existsSync72, readFileSync: readFileSync58, mkdirSync: mkdirSync34, writeFileSync: writeFileSync32 } = await import("fs");
-          const { dirname: dirname25, join: join73 } = await import("path");
+          const { existsSync: existsSync74, readFileSync: readFileSync59, mkdirSync: mkdirSync34, writeFileSync: writeFileSync32 } = await import("fs");
+          const { dirname: dirname25, join: join74 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
           let baseDoc = { version: 1 };
-          let existingPath = join73(workspace, relativePath);
+          let existingPath = join74(workspace, relativePath);
           let existedAsYaml = false;
           for (const relative8 of MESH_JSON_CONFIG_LOCATIONS2) {
-            const candidate = join73(workspace, relative8);
-            if (!existsSync72(candidate)) continue;
+            const candidate = join74(workspace, relative8);
+            if (!existsSync74(candidate)) continue;
             try {
-              const text = readFileSync58(candidate, "utf-8");
+              const text = readFileSync59(candidate, "utf-8");
               const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
               if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
                 baseDoc = parsed;
@@ -134559,7 +135135,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
     };
-    var import_path20 = require("path");
+    var import_path21 = require("path");
     var fs53 = __toESM2(require("fs"));
     init_logger();
     init_mesh_host_ownership();
@@ -134600,9 +135176,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     }
     function isWorkspaceLocalPath(configPath, workspace) {
-      const resolvedConfig = (0, import_path20.resolve)(configPath);
-      const resolvedWorkspace = (0, import_path20.resolve)(workspace);
-      return resolvedConfig === resolvedWorkspace || resolvedConfig.startsWith(resolvedWorkspace + import_path20.sep);
+      const resolvedConfig = (0, import_path21.resolve)(configPath);
+      const resolvedWorkspace = (0, import_path21.resolve)(workspace);
+      return resolvedConfig === resolvedWorkspace || resolvedConfig.startsWith(resolvedWorkspace + import_path21.sep);
     }
     var meshCoordinatorLaunchHandlers = {
       launch_mesh_coordinator: async (ctx, args) => {
@@ -134864,7 +135440,7 @@ ${ptyResult.output.slice(-2e3)}`);
               };
             }
             if (cliType === "codex-cli") {
-              const repoMcpConfigPath = (0, import_path20.join)(workspace, ".mcp.json");
+              const repoMcpConfigPath = (0, import_path21.join)(workspace, ".mcp.json");
               if (fs53.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
@@ -135037,7 +135613,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync72, readFileSync: readFileSync58, writeFileSync: writeFileSync32, copyFileSync: copyFileSync3, mkdirSync: mkdirSync34 } = await import("fs");
+          const { existsSync: existsSync74, readFileSync: readFileSync59, writeFileSync: writeFileSync32, copyFileSync: copyFileSync3, mkdirSync: mkdirSync34 } = await import("fs");
           const { dirname: dirname25 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -135082,14 +135658,14 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync72(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync74(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname25(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync58(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync59(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync3(mcpConfigPath, mcpConfigPath + ".backup");
@@ -135900,7 +136476,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync72 } = await import("fs");
+          const { existsSync: existsSync74 } = await import("fs");
           const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -135919,7 +136495,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync72(workspace)) continue;
+            if (!workspace || !existsSync74(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -136121,7 +136697,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_router_refine();
     var fs56 = __toESM2(require("fs"));
     var import_node_os22 = require("os");
-    var import_path21 = require("path");
+    var import_path222 = require("path");
     init_logger();
     init_git_locale();
     init_dist();
@@ -136133,7 +136709,7 @@ ${ptyResult.output.slice(-2e3)}`);
     function acceptableManagedWorktreePaths(resolveWorktreePath2, normalizePath2, repoRoot, meshName, branch, worktreeBaseDir) {
       const safeBranch = branch.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
       const safeMeshName = meshName.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
-      const legacyPath = (0, import_path21.join)((0, import_path21.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path222.join)((0, import_path222.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -136160,8 +136736,8 @@ ${ptyResult.output.slice(-2e3)}`);
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os22.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path21.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path21.sep);
+        const trackWorktreesDir = (0, import_path222.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path222.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -136271,7 +136847,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path21.resolve)(value);
+        const resolved = (0, import_path222.resolve)(value);
         try {
           return fs56.realpathSync(resolved);
         } catch {
@@ -136398,7 +136974,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path21.resolve)(value);
+        const resolved = (0, import_path222.resolve)(value);
         try {
           return fs56.realpathSync(resolved);
         } catch {
@@ -137066,7 +137642,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path222 = require("path");
+    var import_path23 = require("path");
     var fs57 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
@@ -137107,13 +137683,13 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path222.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path23.join)((0, import_os5.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path222.join)(sourceHome, "config.yaml");
+      const sourceConfigPath = (0, import_path23.join)(sourceHome, "config.yaml");
       if (!fs57.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path222.resolve)(sourceConfigPath) === (0, import_path222.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path23.resolve)(sourceConfigPath) === (0, import_path23.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs57.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -137147,10 +137723,10 @@ ${ptyResult.output.slice(-2e3)}`);
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path222.resolve)(sourceHome) === (0, import_path222.resolve)(targetHome)) return;
+      if ((0, import_path23.resolve)(sourceHome) === (0, import_path23.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path222.join)(sourceHome, fileName);
-        const targetPath = (0, import_path222.join)(targetHome, fileName);
+        const sourcePath = (0, import_path23.join)(sourceHome, fileName);
+        const targetPath = (0, import_path23.join)(targetHome, fileName);
         if (!fs57.existsSync(sourcePath)) continue;
         try {
           fs57.copyFileSync(sourcePath, targetPath);
@@ -138678,6 +139254,108 @@ ${ptyResult.output.slice(-2e3)}`);
     init_runtime_defaults();
     init_snapshot3();
     init_builders();
+    init_dist2();
+    init_logger();
+    init_topics2();
+    var FLEET_STATUS_ENV = "ADHDEV_SEQSCRIBE_FLEET_STATUS";
+    var FLEET_STATUS_ENTRY_KIND = "adhdev.fleet.status";
+    var MAX_INFLIGHT2 = 32;
+    function resolveFleetStatusMode(env2 = process.env) {
+      const raw = env2[FLEET_STATUS_ENV]?.trim().toLowerCase();
+      if (!raw) return "off";
+      if (raw === "off") return "off";
+      if (raw === "shadow") return "shadow";
+      warnOnce3(
+        `unrecognized ${FLEET_STATUS_ENV}=${raw}; treating as 'off'. Valid values are 'shadow' and 'off' (default).`
+      );
+      return "off";
+    }
+    var counters3 = {
+      written: 0,
+      failed: 0,
+      dropped: 0,
+      oversized: 0
+    };
+    var activeNode3 = null;
+    var activeMode2 = "off";
+    var inflight2 = 0;
+    var topicUsable = null;
+    var warnedOnce3 = /* @__PURE__ */ new Set();
+    function warnOnce3(message) {
+      if (warnedOnce3.has(message)) return;
+      warnedOnce3.add(message);
+      LOG2.warn("Seqscribe", message);
+    }
+    function configureFleetStatusShadow(node, env2 = process.env) {
+      activeNode3 = node;
+      activeMode2 = resolveFleetStatusMode(env2);
+      topicUsable = null;
+      inflight2 = 0;
+      if (node && activeMode2 === "shadow") {
+        LOG2.info("Seqscribe", `fleet.status shadow armed writer=${node.writerId}`);
+      }
+    }
+    function ensureTopic2(node) {
+      if (topicUsable !== null) return topicUsable;
+      const present = node.topics.some((d) => d.topic === FLEET_STATUS_TOPIC);
+      topicUsable = present;
+      if (!present) {
+        LOG2.warn(
+          "Seqscribe",
+          `fleet.status shadow disabled \u2014 topic ${FLEET_STATUS_TOPIC} is not defined on this node`
+        );
+      }
+      return present;
+    }
+    function recordFleetStatusShadow(entry) {
+      try {
+        const node = activeNode3;
+        if (!node || activeMode2 === "off") return false;
+        if (!ensureTopic2(node)) return false;
+        if (inflight2 >= MAX_INFLIGHT2) {
+          counters3.dropped++;
+          warnOnce3(
+            `fleet.status shadow shedding load \u2014 ${MAX_INFLIGHT2} appends in flight; status records are being dropped from the RING only (the WS status_report is unaffected)`
+          );
+          return false;
+        }
+        const payload = sanitizeJson(entry);
+        const estimated = estimateEntryBytes({
+          topic: FLEET_STATUS_TOPIC,
+          kind: FLEET_STATUS_ENTRY_KIND,
+          payload
+        });
+        const ceiling = resolveConstants().MAX_ENTRY_BYTES;
+        if (estimated > ceiling) {
+          counters3.oversized++;
+          warnOnce3(
+            `fleet.status shadow skipped an oversized record (further occurrences logged once): estimated=${estimated}B ceiling=${ceiling}B. The entry is a fixed set of scalars \u2014 this is a producer-shape bug, not a transport one.`
+          );
+          return false;
+        }
+        inflight2++;
+        void node.node.log(FLEET_STATUS_TOPIC).append(FLEET_STATUS_ENTRY_KIND, payload).then(
+          () => {
+            inflight2--;
+            counters3.written++;
+          },
+          (error48) => {
+            inflight2--;
+            counters3.failed++;
+            warnOnce3(
+              `fleet.status shadow append failed (further failures logged once): ${error48 instanceof Error ? error48.message : String(error48)}`
+            );
+          }
+        );
+        return true;
+      } catch (error48) {
+        counters3.failed++;
+        warnOnce3(
+          `fleet.status shadow threw synchronously (further throws logged once): ${error48 instanceof Error ? error48.message : String(error48)}`
+        );
+        return false;
+      }
+    }
     function buildCloudP2PSummary(p2p) {
       if (!p2p) return void 0;
       const counter = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
@@ -138751,6 +139429,59 @@ ${ptyResult.output.slice(-2e3)}`);
         timestamp: timestamp2
       };
     }
+    function countFleetSessions(sessions) {
+      const list = Array.isArray(sessions) ? sessions : [];
+      const counts = {
+        ideCount: 0,
+        cliCount: 0,
+        acpCount: 0,
+        idleCount: 0,
+        generatingCount: 0,
+        waitingApprovalCount: 0,
+        erroredCount: 0
+      };
+      for (const raw of list) {
+        const session = raw || {};
+        if (!session.parentId) {
+          if (session.kind === "workspace" && session.transport === "cdp-page") counts.ideCount++;
+          else if (session.kind === "agent" && session.transport === "pty") counts.cliCount++;
+          else if (session.kind === "agent" && session.transport === "acp") counts.acpCount++;
+        }
+        switch (session.status) {
+          case "idle":
+            counts.idleCount++;
+            break;
+          case "generating":
+            counts.generatingCount++;
+            break;
+          // Both approval-shaped states land in one bucket: from a fleet tail's
+          // point of view "a human must answer something" is the signal, and
+          // splitting it would invite a consumer to watch only one of the two.
+          case "waiting_approval":
+          case "waiting_choice":
+            counts.waitingApprovalCount++;
+            break;
+          case "error":
+            counts.erroredCount++;
+            break;
+          default:
+            break;
+        }
+      }
+      return counts;
+    }
+    function fleetStatusEntry(input) {
+      const seqscribeSummary = buildCloudSeqscribeSummary(input.seqscribe);
+      const at = Number.isFinite(input.timestamp) ? new Date(input.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        daemonId: input.daemonId,
+        at,
+        onlineState: input.onlineState,
+        p2pActive: input.p2pActive === true,
+        sessionCounts: countFleetSessions(input.sessions),
+        ...seqscribeSummary ? { seqscribe: seqscribeSummary } : {}
+      };
+    }
     var SERVER_DEDUP_KEEPALIVE_REPORTS = 10;
     var DaemonStatusReporter = class {
       deps;
@@ -139014,6 +139745,20 @@ ${ptyResult.output.slice(-2e3)}`);
             );
           }
         }
+        recordFleetStatusShadow(fleetStatusEntry({
+          daemonId: this.deps.instanceId,
+          sessions: payload.sessions,
+          // Derived from what this process can actually observe: a live server
+          // socket is `online`; no socket while P2P still carries traffic is a
+          // daemon mid-reconnect rather than a dead one. `offline` is
+          // effectively unreachable from here — `sendUnifiedStatusReport`
+          // returns early when neither transport is up — and is kept in the
+          // enum for a consumer that infers it from a stale `at`.
+          onlineState: serverConnected ? "online" : p2pConnected ? "reconnecting" : "offline",
+          p2pActive: p2pConnected,
+          timestamp: now,
+          seqscribe: this.deps.getSeqscribeStats?.() || void 0
+        }));
         if (opts?.p2pOnly) return;
         if (!serverConnected || !serverConn) return;
         const wsPayload = buildCloudStatusReportPayload(
@@ -146561,8 +147306,8 @@ data: ${JSON.stringify(msg.data)}
     init_contract();
     init_mesh_events();
     init_mesh_reconcile_loop();
-    var import_fs20 = require("fs");
-    var import_path23 = require("path");
+    var import_fs22 = require("fs");
+    var import_path24 = require("path");
     var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -146630,31 +147375,31 @@ data: ${JSON.stringify(msg.data)}
       } catch {
         return result;
       }
-      if (!(0, import_fs20.existsSync)(dir)) return result;
+      if (!(0, import_fs22.existsSync)(dir)) return result;
       let names;
       try {
-        names = (0, import_fs20.readdirSync)(dir);
+        names = (0, import_fs22.readdirSync)(dir);
       } catch (e) {
         LOG2.warn("MeshEvents", `Pending-events migration: cannot read ledger dir: ${e?.message || e}`);
         return result;
       }
       for (const name of names) {
         if (!isPendingEventsFile(name)) continue;
-        const path63 = (0, import_path23.join)(dir, name);
+        const path63 = (0, import_path24.join)(dir, name);
         result.filesScanned++;
         const claimed = `${path63}.migrating`;
         try {
-          (0, import_fs20.renameSync)(path63, claimed);
+          (0, import_fs22.renameSync)(path63, claimed);
         } catch {
           continue;
         }
         let content;
         try {
-          content = (0, import_fs20.readFileSync)(claimed, "utf-8");
+          content = (0, import_fs22.readFileSync)(claimed, "utf-8");
         } catch (e) {
           LOG2.warn("MeshEvents", `Pending-events migration: cannot read ${name}; leaving it for the next boot: ${e?.message || e}`);
           try {
-            (0, import_fs20.renameSync)(claimed, path63);
+            (0, import_fs22.renameSync)(claimed, path63);
           } catch {
           }
           result.filesRetained++;
@@ -146669,14 +147414,14 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!allImported) {
           try {
-            (0, import_fs20.renameSync)(claimed, path63);
+            (0, import_fs22.renameSync)(claimed, path63);
           } catch {
           }
           result.filesRetained++;
           continue;
         }
         try {
-          (0, import_fs20.unlinkSync)(claimed);
+          (0, import_fs22.unlinkSync)(claimed);
           result.filesRemoved++;
         } catch (e) {
           LOG2.warn("MeshEvents", `Pending-events migration: imported ${name} but could not unlink it: ${e?.message || e}`);
@@ -146834,20 +147579,20 @@ data: ${JSON.stringify(msg.data)}
       };
     }
     init_require_whitelist();
-    var import_fs21 = require("fs");
-    var import_path24 = require("path");
+    var import_fs23 = require("fs");
+    var import_path25 = require("path");
     init_config();
     init_logger();
     var FLEET_SECRET_FILE = "seqscribe-fleet-secret.json";
     function fleetSecretPath(env2) {
-      return (0, import_path24.join)(getConfigDir2(env2), FLEET_SECRET_FILE);
+      return (0, import_path25.join)(getConfigDir2(env2), FLEET_SECRET_FILE);
     }
     function loadStoredFleetSecret(env2) {
       const path63 = fleetSecretPath(env2);
-      if (!(0, import_fs21.existsSync)(path63)) return null;
+      if (!(0, import_fs23.existsSync)(path63)) return null;
       let raw;
       try {
-        raw = (0, import_fs21.readFileSync)(path63, "utf-8");
+        raw = (0, import_fs23.readFileSync)(path63, "utf-8");
       } catch (err) {
         LOG2.warn(
           "Seqscribe",
@@ -146874,32 +147619,32 @@ data: ${JSON.stringify(msg.data)}
         throw new Error("storeFleetSecret requires an integer version >= 1");
       }
       const dir = getConfigDir2(env2);
-      if (!(0, import_fs21.existsSync)(dir)) {
-        (0, import_fs21.mkdirSync)(dir, { recursive: true, mode: 448 });
+      if (!(0, import_fs23.existsSync)(dir)) {
+        (0, import_fs23.mkdirSync)(dir, { recursive: true, mode: 448 });
       }
-      const path63 = (0, import_path24.join)(dir, FLEET_SECRET_FILE);
+      const path63 = (0, import_path25.join)(dir, FLEET_SECRET_FILE);
       const tmp = `${path63}.tmp-${process.pid}`;
-      (0, import_fs21.writeFileSync)(tmp, JSON.stringify({ secret, version: version2 }, null, 2), {
+      (0, import_fs23.writeFileSync)(tmp, JSON.stringify({ secret, version: version2 }, null, 2), {
         encoding: "utf-8",
         mode: 384
       });
       try {
-        (0, import_fs21.renameSync)(tmp, path63);
+        (0, import_fs23.renameSync)(tmp, path63);
       } catch (err) {
         try {
-          (0, import_fs21.unlinkSync)(tmp);
+          (0, import_fs23.unlinkSync)(tmp);
         } catch {
         }
         throw err;
       }
       try {
-        (0, import_fs21.chmodSync)(path63, 384);
+        (0, import_fs23.chmodSync)(path63, 384);
       } catch {
       }
       LOG2.info("Seqscribe", `fleet secret stored (v${version2})`);
     }
-    var import_fs22 = require("fs");
-    var import_path25 = require("path");
+    var import_fs24 = require("fs");
+    var import_path26 = require("path");
     init_dist2();
     init_config();
     init_logger();
@@ -146909,12 +147654,12 @@ data: ${JSON.stringify(msg.data)}
     var SEQSCRIBE_DB_NAME = "seqscribe.db";
     var WRITER_ID_PREFIX = "adhdev";
     function getSeqscribeDbPath() {
-      return (0, import_path25.join)(getConfigDir2(), SEQSCRIBE_DB_NAME);
+      return (0, import_path26.join)(getConfigDir2(), SEQSCRIBE_DB_NAME);
     }
     function openSeqscribeNode(opts = {}) {
       const dbPath = opts.dbPath ?? getSeqscribeDbPath();
-      const dir = (0, import_path25.dirname)(dbPath);
-      if (!(0, import_fs22.existsSync)(dir)) (0, import_fs22.mkdirSync)(dir, { recursive: true, mode: 448 });
+      const dir = (0, import_path26.dirname)(dbPath);
+      if (!(0, import_fs24.existsSync)(dir)) (0, import_fs24.mkdirSync)(dir, { recursive: true, mode: 448 });
       const Database = loadBetterSqlite3();
       const db = new Database(dbPath);
       db.pragma("journal_mode = WAL");
@@ -146976,6 +147721,32 @@ data: ${JSON.stringify(msg.data)}
         authority: authority.authority,
         intervalMs: opts.finalityIntervalMs
       }) : null;
+      let unsubAnomaly = null;
+      try {
+        unsubAnomaly = node.onAnomaly((anomaly) => {
+          try {
+            if (anomaly.kind === "sync_stalled") {
+              LOG2.warn(
+                "Seqscribe",
+                `sync stalled writer=${writerId} \u2014 WANT rounds toward a peer stopped progressing; check get_status_metadata seqscribe.stalledStreams / applyRejects`
+              );
+            } else if (anomaly.kind === "sync_hot") {
+              LOG2.warn(
+                "Seqscribe",
+                `sync hot writer=${writerId} \u2014 bulk sync traffic crossed the rate window (informational, not throttled); see seqscribe.syncHotspots in get_status_metadata`
+              );
+            } else {
+              LOG2.warn("Seqscribe", `anomaly kind=${anomaly.kind} writer=${writerId}`);
+            }
+          } catch {
+          }
+        });
+      } catch (err) {
+        LOG2.warn(
+          "Seqscribe",
+          `anomaly subscription failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
       LOG2.info(
         "Seqscribe",
         `node open writer=${writerId} topics=${defs.length} authority=${authority ? "on" : "off"}${opts.isCoordinator ? " role=coordinator" : ""}`
@@ -146988,6 +147759,10 @@ data: ${JSON.stringify(msg.data)}
           finalityLoop?.stop();
         } catch {
         }
+        try {
+          unsubAnomaly?.();
+        } catch {
+        }
         try {
           await node.close();
         } catch (err) {
@@ -147145,6 +147920,41 @@ data: ${JSON.stringify(msg.data)}
         if (peer.queuedData > maxQueued) maxQueued = peer.queuedData;
         if (peer.state === "ready") peersReady++;
       }
+      let localDiagnostics = {};
+      if (opts.includeLocalDiagnostics) {
+        let applyRejects = 0;
+        for (const topic of Object.values(stats.topics)) {
+          for (const count of Object.values(topic.applyRejects ?? {})) {
+            if (typeof count === "number" && Number.isFinite(count) && count > 0) {
+              applyRejects += count;
+            }
+          }
+        }
+        let stalledStreams = 0;
+        for (const peer of stats.peers) {
+          const stalled = peer.stalledStreams;
+          if (typeof stalled === "number" && Number.isFinite(stalled) && stalled > 0) {
+            stalledStreams += stalled;
+          }
+        }
+        const snap = opts.throughput;
+        localDiagnostics = {
+          applyRejects,
+          stalledStreams,
+          ...snap ? {
+            throughput: {
+              intervalMs: snap.intervalMs,
+              servedEntries: snap.totals.servedEntries,
+              servedBytes: snap.totals.servedBytes,
+              appliedEntries: snap.totals.appliedEntries,
+              appliedBytes: snap.totals.appliedBytes,
+              wantRoundsRequested: snap.totals.wantRoundsRequested,
+              wantRoundsServed: snap.totals.wantRoundsServed
+            },
+            syncHotspots: snap.hotspots.map((h) => ({ ...h }))
+          } : {}
+        };
+      }
       return {
         topics,
         peers: stats.peers.length,
@@ -147163,9 +147973,119 @@ data: ${JSON.stringify(msg.data)}
         parityRan: (opts.parity?.runs ?? 0) > 0,
         parityMissingInShadowBucket: bucket(opts.parity?.missingInShadow ?? 0, BACKLOG_BUCKETS),
         parityExtraInShadowBucket: bucket(opts.parity?.extraInShadow ?? 0, BACKLOG_BUCKETS),
-        parityFieldMismatchBucket: bucket(opts.parity?.fieldMismatch ?? 0, BACKLOG_BUCKETS)
+        parityFieldMismatchBucket: bucket(opts.parity?.fieldMismatch ?? 0, BACKLOG_BUCKETS),
+        ...localDiagnostics
       };
     }
+    init_logger();
+    var DEFAULT_COLLECT_INTERVAL_MS = 6e4;
+    var SNAPSHOT_HOTSPOT_LIMIT = 5;
+    var ZERO_TOTALS = {
+      servedEntries: 0,
+      servedBytes: 0,
+      appliedEntries: 0,
+      appliedBytes: 0,
+      wantRoundsRequested: 0,
+      wantRoundsServed: 0
+    };
+    function sumTotals(stats) {
+      const totals = { ...ZERO_TOTALS };
+      for (const topic of Object.values(stats.topics ?? {})) {
+        const sync = topic?.sync;
+        if (!sync) continue;
+        totals.servedEntries += num(sync.servedEntries);
+        totals.servedBytes += num(sync.servedBytes);
+        totals.appliedEntries += num(sync.appliedEntries);
+        totals.appliedBytes += num(sync.appliedBytes);
+        totals.wantRoundsRequested += num(sync.wantRoundsRequested);
+        totals.wantRoundsServed += num(sync.wantRoundsServed);
+      }
+      return totals;
+    }
+    function num(value) {
+      return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+    }
+    function sumApplyRejects(stats) {
+      let total = 0;
+      for (const topic of Object.values(stats.topics ?? {})) {
+        for (const count of Object.values(topic?.applyRejects ?? {})) {
+          total += num(count);
+        }
+      }
+      return total;
+    }
+    function sumStalledStreams(stats) {
+      let total = 0;
+      for (const peer of stats.peers ?? []) {
+        total += num(peer?.stalledStreams);
+      }
+      return total;
+    }
+    function hasActivity(totals) {
+      return totals.servedEntries > 0 || totals.appliedEntries > 0 || totals.servedBytes > 0 || totals.appliedBytes > 0 || totals.wantRoundsRequested > 0 || totals.wantRoundsServed > 0;
+    }
+    function fmtBytes(bytes) {
+      if (bytes < 1024) return `${bytes}B`;
+      if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KiB`;
+      return `${(bytes / (1024 * 1024)).toFixed(1)}MiB`;
+    }
+    function startSeqscribeThroughputCollector(opts) {
+      const intervalMs = opts.intervalMs ?? DEFAULT_COLLECT_INTERVAL_MS;
+      const clock = opts.clock ?? (() => Date.now());
+      const log = opts.log ?? ((level, message) => {
+        if (level === "warn") LOG2.warn("Seqscribe", message);
+        else LOG2.info("Seqscribe", message);
+      });
+      let current = null;
+      let lastAt = null;
+      let stopped = false;
+      const collect = () => {
+        if (stopped) return current;
+        let stats;
+        try {
+          stats = opts.readStats();
+        } catch (error48) {
+          log(
+            "warn",
+            `throughput collect failed: ${error48 instanceof Error ? error48.message : String(error48)}`
+          );
+          return current;
+        }
+        const at = clock();
+        const totals = sumTotals(stats);
+        const snapshot = {
+          at,
+          intervalMs: lastAt === null ? intervalMs : Math.max(0, at - lastAt),
+          totals,
+          hotspots: (stats.syncHotspots ?? []).slice(0, SNAPSHOT_HOTSPOT_LIMIT).map((h) => ({ topic: h.topic, peerId: h.peerId, bytes: num(h.bytes) })),
+          applyRejects: sumApplyRejects(stats),
+          stalledStreams: sumStalledStreams(stats),
+          stats
+        };
+        lastAt = at;
+        current = snapshot;
+        if (hasActivity(totals)) {
+          const top = snapshot.hotspots[0];
+          log(
+            "info",
+            `sync ${intervalMs / 1e3}s: served=${totals.servedEntries}e/${fmtBytes(totals.servedBytes)} applied=${totals.appliedEntries}e/${fmtBytes(totals.appliedBytes)} want=${totals.wantRoundsRequested}req/${totals.wantRoundsServed}served` + (top ? ` hot=${top.topic}@${top.peerId}/${fmtBytes(top.bytes)}` : "")
+          );
+        }
+        return snapshot;
+      };
+      const timer = setInterval(collect, intervalMs);
+      timer.unref?.();
+      return {
+        snapshot: () => current,
+        collect,
+        stop: () => {
+          if (stopped) return;
+          stopped = true;
+          clearInterval(timer);
+        }
+      };
+    }
+    init_mesh_read_readiness();
     init_mesh_dual_write();
     init_mesh_parity();
     init_mesh_config();
@@ -147536,6 +148456,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       );
       commandHandler.setAgentStreamManager(agentStreamManager);
       let seqscribeNodeRef;
+      let seqscribeCollector;
       const router = new DaemonCommandRouter({
         commandHandler,
         cliManager,
@@ -147568,8 +148489,18 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
           try {
             const dual = meshDualWriteCounters();
             const parity = meshParityCounters();
-            return summarizeSeqscribeStats(seqscribeNodeRef.node.stats(), {
+            const snapshot = seqscribeCollector?.snapshot() ?? null;
+            if (!snapshot) return null;
+            return summarizeSeqscribeStats(snapshot.stats, {
               authorityEnabled: seqscribeNodeRef.authorityEnabled,
+              // Local surface: `get_status_metadata` and the status
+              // reporter share this closure, but the cloud projection
+              // (buildCloudSeqscribeSummary) is a fixed-key allow-list
+              // that drops every field below, so these never reach the
+              // server. syncHotspots in particular carries topic names
+              // and peer ids and is local-only by contract.
+              includeLocalDiagnostics: true,
+              throughput: snapshot,
               dualWrite: {
                 active: isMeshDualWriteActive(),
                 failed: dual.failed,
@@ -147623,6 +148554,22 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       };
       components.seqscribeNode = tryOpenDaemonSeqscribeNode({ daemonId: config2.statusInstanceId });
       seqscribeNodeRef = components.seqscribeNode;
+      if (components.seqscribeNode) {
+        try {
+          const node = components.seqscribeNode;
+          seqscribeCollector = startSeqscribeThroughputCollector({
+            readStats: () => node.node.stats()
+          });
+          seqscribeCollector.collect();
+          components.seqscribeCollector = seqscribeCollector;
+          configureMeshReadReadinessCollector(seqscribeCollector);
+        } catch (error48) {
+          LOG2.warn(
+            "Seqscribe",
+            `throughput collector unavailable: ${error48 instanceof Error ? error48.message : String(error48)}`
+          );
+        }
+      }
       if (components.seqscribeNode) {
         try {
           components.seqscribeProbe = startConvergenceProbe(components.seqscribeNode, {
@@ -147639,7 +148586,9 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       try {
         configureMeshDualWrite(components.seqscribeNode ?? null);
         configureMeshReadModel(components.seqscribeNode ?? null);
+        configureFleetStatusShadow(components.seqscribeNode ?? null);
         if (components.seqscribeNode) {
+          pruneStaleConsumersAtBoot();
           components.seqscribeParityLoop = startMeshParityLoop(components.seqscribeNode);
         }
       } catch (error48) {
@@ -147700,7 +148649,8 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         eventLoopMonitor,
         seqscribeNode,
         seqscribeProbe,
-        seqscribeParityLoop
+        seqscribeParityLoop,
+        seqscribeCollector
       } = components;
       poller.stop();
       cdpInitializer.stop();
@@ -147728,6 +148678,14 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         seqscribeProbe?.stop();
       } catch {
       }
+      try {
+        seqscribeCollector?.stop();
+      } catch {
+      }
+      try {
+        configureMeshReadReadinessCollector(null);
+      } catch {
+      }
       try {
         seqscribeParityLoop?.stop();
       } catch {
@@ -147736,6 +148694,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         configureMeshDualWrite(null);
       } catch {
       }
+      try {
+        configureFleetStatusShadow(null);
+      } catch {
+      }
       try {
         configureMeshReadModel(null);
       } catch {