@adhdev/daemon-standalone 1.0.58-rc.28 → 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 ? "8b689b3eaa810e0c92ffdf0f7317278e496ae782" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "8b689b3e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.28" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-27T11:26:23.456Z" : 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,6 +51012,14 @@ 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"
         };
       }
@@ -56007,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"() {
@@ -56017,6 +56026,7 @@ 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();
@@ -56024,6 +56034,16 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           // (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;
@@ -56162,6 +56182,56 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           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);
@@ -56342,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);
@@ -56386,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,
@@ -56508,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) => ({
@@ -56572,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;
             }
           }
@@ -56597,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 {
@@ -56608,16 +56683,25 @@ CREATE TABLE IF NOT EXISTS sq_archive (
               }
               if (entry.topic !== m.topic || entry.writer !== m.writer)
                 continue;
+              costs.push(utf8ByteLength(JSON.stringify(entry)));
               applies.push(this.o.core.applyExternal(entry, ps.session.peerId).catch(() => "error"));
             }
             void Promise.all(applies).then((results) => {
-              for (const r of results) {
-                if (r === "applied" || r === "duplicate" || r === "pending")
+              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);
@@ -57405,7 +57489,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         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);
@@ -57426,7 +57511,15 @@ CREATE TABLE IF NOT EXISTS sq_archive (
             finalityGeneration: cert?.generation ?? null,
             certOrderAgeMs: cert ? Math.max(0, now - cert.order.l) : null,
             consumers: consumers2,
-            applyRejects: sync.rejectStats(topic)
+            applyRejects: sync.rejectStats(topic),
+            sync: interval.topics.get(topic) ?? {
+              servedEntries: 0,
+              servedBytes: 0,
+              appliedEntries: 0,
+              appliedBytes: 0,
+              wantRoundsRequested: 0,
+              wantRoundsServed: 0
+            }
           };
         }
         return out;
@@ -58497,6 +58590,9 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       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);
@@ -58518,18 +58614,22 @@ 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" };
@@ -58571,6 +58671,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     var readsServedFromReplica;
     var readsServedFromLedger;
     var loggedTransitions;
+    var seqscribeCollectorRef;
     var init_mesh_read_readiness = __esm2({
       "src/seqscribe/mesh-read-readiness.ts"() {
         "use strict";
@@ -58585,6 +58686,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         readsServedFromReplica = 0;
         readsServedFromLedger = 0;
         loggedTransitions = /* @__PURE__ */ new Map();
+        seqscribeCollectorRef = null;
       }
     });
     function fromLedger(entry) {
@@ -63011,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());
@@ -63027,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;
@@ -63177,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
@@ -65824,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,
@@ -65833,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,
@@ -65843,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,
@@ -65862,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 : {};
@@ -65894,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();
@@ -65947,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}
 `);
@@ -65971,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);
@@ -66015,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();
@@ -66044,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) {
@@ -66058,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}
@@ -66240,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) {
@@ -66264,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);
@@ -66364,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);
@@ -66421,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);
         }
@@ -66431,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);
@@ -66727,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.
 `);
@@ -66769,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 [];
       }
@@ -66788,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++;
@@ -66808,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();
@@ -66819,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 {
         }
@@ -66859,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;
       }
@@ -66885,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;
@@ -66907,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",
@@ -66942,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;
@@ -66972,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 = {};
@@ -68055,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 };
@@ -68074,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 {};
@@ -68149,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;
@@ -68163,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"];
@@ -68271,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;
@@ -68288,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",
@@ -68337,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;
@@ -68346,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"]);
@@ -68484,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,
@@ -68547,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 };
@@ -68563,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";
         }
@@ -68636,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();
@@ -68647,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);
@@ -68707,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;
@@ -68723,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");
@@ -69259,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) {
@@ -69278,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 }
@@ -69315,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();
       }
@@ -76985,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;
       }
@@ -77075,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;
@@ -77084,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();
@@ -79936,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 : {};
@@ -79987,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 };
@@ -80000,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 });
@@ -80040,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: [],
@@ -84343,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;
@@ -84390,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;
@@ -84399,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;
@@ -84451,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}`);
@@ -84459,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 {
         }
@@ -84496,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 {
@@ -84617,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;
@@ -84627,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();
@@ -84643,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}`;
@@ -84708,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 {
@@ -84761,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.");
         }
       }
@@ -85142,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({
@@ -85150,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();
@@ -91530,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;
@@ -91701,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({
@@ -91709,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";
@@ -91835,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 = [];
@@ -92060,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 {
@@ -92079,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;
@@ -92087,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.";
@@ -92111,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(
@@ -92599,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) {
@@ -92608,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;
         }
@@ -92625,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,
@@ -92688,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" });
@@ -92763,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" });
@@ -92922,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,
@@ -92949,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;
@@ -93201,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) => {
@@ -93274,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);
@@ -93307,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)) {
@@ -93374,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;
@@ -93389,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();
@@ -93402,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) {
@@ -93411,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({
@@ -93566,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({
@@ -93574,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();
@@ -98862,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();
@@ -98882,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 };
       }
@@ -98996,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 };
       }
@@ -99537,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,
@@ -99655,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: {} };
@@ -99671,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);
@@ -99682,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);
@@ -99697,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);
@@ -101225,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"));
@@ -101302,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 ? ";" : ":");
@@ -101312,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;
               }
@@ -101331,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;
@@ -101347,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");
@@ -101360,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;
             }
@@ -113289,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"));
@@ -115934,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, "-");
@@ -118248,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;
@@ -118466,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);
@@ -124847,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], {
@@ -124993,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) {
@@ -131834,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;
@@ -132720,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("; ")}` };
@@ -132830,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;
@@ -134888,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();
@@ -134929,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) => {
@@ -135193,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(
@@ -135366,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;
@@ -135411,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");
@@ -136229,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" };
@@ -136248,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 });
@@ -136450,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();
@@ -136462,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
@@ -136489,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) {
@@ -136600,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 {
@@ -136727,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 {
@@ -137395,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) {
@@ -137436,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 };
@@ -137476,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);
@@ -139007,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;
@@ -139080,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;
@@ -139343,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(
@@ -146890,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();
@@ -146959,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++;
@@ -146998,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}`);
@@ -147163,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",
@@ -147203,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();
@@ -147238,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");
@@ -147305,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" : ""}`
@@ -147317,6 +147759,10 @@ data: ${JSON.stringify(msg.data)}
           finalityLoop?.stop();
         } catch {
         }
+        try {
+          unsubAnomaly?.();
+        } catch {
+        }
         try {
           await node.close();
         } catch (err) {
@@ -147474,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,
@@ -147492,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();
@@ -147865,6 +148456,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       );
       commandHandler.setAgentStreamManager(agentStreamManager);
       let seqscribeNodeRef;
+      let seqscribeCollector;
       const router = new DaemonCommandRouter({
         commandHandler,
         cliManager,
@@ -147897,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,
@@ -147952,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, {
@@ -147968,6 +148586,7 @@ ${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);
@@ -148030,7 +148649,8 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         eventLoopMonitor,
         seqscribeNode,
         seqscribeProbe,
-        seqscribeParityLoop
+        seqscribeParityLoop,
+        seqscribeCollector
       } = components;
       poller.stop();
       cdpInitializer.stop();
@@ -148058,6 +148678,14 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         seqscribeProbe?.stop();
       } catch {
       }
+      try {
+        seqscribeCollector?.stop();
+      } catch {
+      }
+      try {
+        configureMeshReadReadinessCollector(null);
+      } catch {
+      }
       try {
         seqscribeParityLoop?.stop();
       } catch {
@@ -148066,6 +148694,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         configureMeshDualWrite(null);
       } catch {
       }
+      try {
+        configureFleetStatusShadow(null);
+      } catch {
+      }
       try {
         configureMeshReadModel(null);
       } catch {