@adhdev/daemon-standalone 1.0.42 → 1.0.43-rc.1

package/dist/index.js

@@ -31423,9 +31423,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/b4a/index.js
+// ../../node_modules/tar-stream/node_modules/b4a/index.js
 var require_b4a2 = __commonJS({
-  "../daemon-core/node_modules/b4a/index.js"(exports2, module2) {
+  "../../node_modules/tar-stream/node_modules/b4a/index.js"(exports2, module2) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -31581,9 +31581,9 @@ var require_b4a2 = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/headers.js
+// ../../node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../daemon-core/node_modules/tar-stream/headers.js"(exports2) {
+  "../../node_modules/tar-stream/headers.js"(exports2) {
     "use strict";
     var b4a = require_b4a2();
     var ZEROS = "0000000000000000000";
@@ -31844,9 +31844,9 @@ var require_headers = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/extract.js
+// ../../node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../daemon-core/node_modules/tar-stream/extract.js"(exports2, module2) {
+  "../../node_modules/tar-stream/extract.js"(exports2, module2) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
@@ -32189,9 +32189,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/constants.js
+// ../../node_modules/tar-stream/constants.js
 var require_constants = __commonJS({
-  "../daemon-core/node_modules/tar-stream/constants.js"(exports2, module2) {
+  "../../node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -32210,9 +32210,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/pack.js
+// ../../node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../daemon-core/node_modules/tar-stream/pack.js"(exports2, module2) {
+  "../../node_modules/tar-stream/pack.js"(exports2, module2) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a2();
@@ -32445,9 +32445,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/index.js
+// ../../node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../daemon-core/node_modules/tar-stream/index.js"(exports2) {
+  "../../node_modules/tar-stream/index.js"(exports2) {
     "use strict";
     exports2.extract = require_extract();
     exports2.pack = require_pack();
@@ -32690,9 +32690,9 @@ var require_pump = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-fs/index.js
+// ../../node_modules/tar-fs/index.js
 var require_tar_fs = __commonJS({
-  "../daemon-core/node_modules/tar-fs/index.js"(exports2) {
+  "../../node_modules/tar-fs/index.js"(exports2) {
     "use strict";
     var tar = require_tar_stream();
     var pump = require_pump();
@@ -36556,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "9d57fb32f38be14867c8897aac6af379a1027624" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "9d57fb3" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.42" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-10T23:11:18.240Z" : void 0);
+      const commit = readInjected(true ? "4c0b4f5134ad0c5994f030f228fa8d270fd75b6e" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "4c0b4f51" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.43-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-11T02:05:06.448Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -37817,7 +37817,7 @@ var require_dist3 = __commonJS({
       }
     });
     function resolveBuildTrack(env2 = process.env) {
-      const injected = true ? "" : void 0;
+      const injected = true ? "preview" : void 0;
       const stamped = typeof injected === "string" ? injected.trim() : "";
       const raw = (stamped || (env2[BUILD_CHANNEL_ENV_VAR] ?? "").trim()).toLowerCase();
       return raw === "preview" || raw === "next" ? "preview" : "stable";
@@ -45595,9 +45595,13 @@ Next step: ${nextStep}`;
       if (!REFINE_TERMINAL_EVENTS.has(event.event)) return false;
       const jobId = readRefineJobId2(event);
       if (!jobId) return false;
-      return readPendingMeshCoordinatorEventsFromDisk(event.meshId).some(
-        (pending) => pending.event === event.event && readRefineJobId2(pending) === jobId
-      );
+      try {
+        return MeshRuntimeStore.getInstance().peekPendingEvents(event.meshId).some(
+          (row) => row.event === event.event && readRefineJobId2(row.payload) === jobId
+        );
+      } catch {
+        return false;
+      }
     }
     function buildPendingEventFingerprint(event) {
       const metadata = readRecord2(event.metadataEvent) || {};
@@ -45640,42 +45644,10 @@ Next step: ${nextStep}`;
       const fingerprint = buildPendingEventFingerprint(event);
       if (!fingerprint.trim()) return false;
       try {
-        if (MeshRuntimeStore.getInstance().hasPendingEventFingerprint(event.meshId, fingerprint)) return true;
+        return MeshRuntimeStore.getInstance().hasPendingEventFingerprint(event.meshId, fingerprint);
       } catch {
+        return false;
       }
-      return readPendingMeshCoordinatorEventsFromDisk(event.meshId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
-    }
-    function getPendingEventsPath(meshId, coordinatorDaemonId) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      if (coordinatorDaemonId) {
-        const safeDaemon = coordinatorDaemonId.replace(/[^a-zA-Z0-9_-]/g, "_");
-        return (0, import_path6.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
-      }
-      return (0, import_path6.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
-    }
-    function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
-      if (!meshId) return [];
-      const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
-      const primaryDaemonId = daemonIds[0];
-      const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-      const events = [];
-      for (const path54 of paths) {
-        if (!(0, import_fs6.existsSync)(path54)) continue;
-        try {
-          const raw = (0, import_fs6.readFileSync)(path54, "utf-8");
-          const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
-            try {
-              return [JSON.parse(line)];
-            } catch {
-              return [];
-            }
-          });
-          const filtered = primaryDaemonId && path54 === getPendingEventsPath(meshId) ? parsed.filter((e) => !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId)) : parsed;
-          events.push(...filtered);
-        } catch {
-        }
-      }
-      return events;
     }
     function refineTerminalEventFromLedger(meshId, pending) {
       const acceptedJobIds = new Set(
@@ -45750,50 +45722,6 @@ Next step: ${nextStep}`;
         return 0;
       }
     }
-    function trimPendingEventsIfNeeded(path54) {
-      try {
-        if (!(0, import_fs6.existsSync)(path54)) return;
-        if ((0, import_fs6.statSync)(path54).size <= MAX_PENDING_EVENTS_BYTES) return;
-        const lines = (0, import_fs6.readFileSync)(path54, "utf-8").split("\n").filter(Boolean);
-        if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
-        const dropped = lines.slice(0, lines.length - MAX_PENDING_EVENTS_KEEP);
-        for (const line of dropped) {
-          let event;
-          try {
-            event = JSON.parse(line);
-          } catch {
-            continue;
-          }
-          if (!event || !event.meshId) continue;
-          const finalSummary = readMeshCompletionSummary(event.metadataEvent || {});
-          if (!readNonEmptyString(event.coordinatorMessage) && !finalSummary) continue;
-          try {
-            appendLedgerEntry(event.meshId, {
-              kind: "event_held",
-              ...event.nodeId ? { nodeId: event.nodeId } : {},
-              payload: {
-                event: event.event,
-                reason: "pending_trim_dropped",
-                recoverable: true,
-                nodeLabel: event.nodeLabel,
-                ...event.workspace ? { workspace: event.workspace } : {},
-                targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
-                ...readNonEmptyString(event.eventId) ? { eventId: event.eventId } : {},
-                queuedAt: event.queuedAt,
-                ...finalSummary ? { finalSummary } : {},
-                // Full original event for lossless mesh_requeue_held_events restore.
-                heldEvent: event
-              }
-            });
-            LOG2.warn("MeshEvents", `Pending-events trim dropping undelivered ${event.event} for mesh ${event.meshId} \u2014 recorded to ledger (recoverable)`);
-          } catch (e) {
-            LOG2.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
-          }
-        }
-        (0, import_fs6.writeFileSync)(path54, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
-      } catch {
-      }
-    }
     function stampPendingEventV2(event, hint) {
       if (event.protocolVersion === MESH_PROTOCOL_VERSION_V2 && readNonEmptyString(event.eventId)) {
         return event;
@@ -45876,40 +45804,30 @@ Next step: ${nextStep}`;
           return true;
         }
         const fingerprint = buildPendingEventFingerprint(event);
-        let sqliteOk = false;
-        try {
-          MeshRuntimeStore.getInstance().insertPendingEvent({
-            id: (0, import_crypto6.randomUUID)(),
-            meshId: event.meshId,
-            coordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
-            event: event.event,
-            payload: event,
-            fingerprint: fingerprint || null,
-            queuedAt: event.queuedAt,
-            // v2 envelope columns (B2a) — all nullable so v1 rows coexist. The
-            // authoritative copy still rides inside `payload`; these columns exist
-            // for queryable idempotency (event_id) and scope-based drain filtering
-            // (scope / intended_for) without JSON-parsing every row.
-            protocolVersion: event.protocolVersion ?? null,
-            eventId: event.eventId ?? null,
-            scope: event.scope ?? null,
-            dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
-            intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
-          });
-          sqliteOk = true;
-        } catch {
-        }
-        try {
-          const path54 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-          trimPendingEventsIfNeeded(path54);
-          (0, import_fs6.appendFileSync)(path54, JSON.stringify(event) + "\n", "utf-8");
-        } catch (e) {
-          if (!sqliteOk) throw e;
-          LOG2.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
-        }
+        MeshRuntimeStore.getInstance().insertPendingEvent({
+          id: (0, import_crypto6.randomUUID)(),
+          meshId: event.meshId,
+          coordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+          event: event.event,
+          payload: event,
+          fingerprint: fingerprint || null,
+          queuedAt: event.queuedAt,
+          // v2 envelope columns (B2a) — all nullable so v1 rows coexist. The
+          // authoritative copy still rides inside `payload`; these columns exist
+          // for queryable idempotency (event_id) and scope-based drain filtering
+          // (scope / intended_for) without JSON-parsing every row.
+          protocolVersion: event.protocolVersion ?? null,
+          eventId: event.eventId ?? null,
+          scope: event.scope ?? null,
+          dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
+          intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
+        });
         return true;
       } catch (e) {
-        LOG2.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
+        LOG2.error(
+          "MeshEvents",
+          `PENDING-EVENT PERSIST FAILED \u2014 ${event.event} for mesh ${event.meshId} is NOT queued and will NOT be delivered (SQLite is the only store; there is no fallback): ${e?.message || e}`
+        );
         return false;
       }
     }
@@ -45920,98 +45838,17 @@ Next step: ${nextStep}`;
       try {
         requeued = MeshRuntimeStore.getInstance().requeueDrainedPendingEventByFingerprint(event.meshId, fingerprint);
       } catch (e) {
-        LOG2.warn("MeshEvents", `SQLite re-queue of held ${event.event} failed for mesh ${event.meshId}: ${e?.message || e}`);
-      }
-      try {
-        const path54 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-        const alreadyOnDisk = readPendingMeshCoordinatorEventsFromDisk(event.meshId, event.targetCoordinatorDaemonId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
-        if (!alreadyOnDisk) {
-          trimPendingEventsIfNeeded(path54);
-          (0, import_fs6.appendFileSync)(path54, JSON.stringify(event) + "\n", "utf-8");
-          requeued = true;
-        }
-      } catch (e) {
-        if (!requeued) {
-          LOG2.warn("MeshEvents", `Failed to durably re-queue held ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
-          return false;
-        }
-        LOG2.warn("MeshEvents", `JSONL re-queue append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
+        LOG2.error(
+          "MeshEvents",
+          `HELD-EVENT RE-QUEUE FAILED \u2014 ${event.event} for mesh ${event.meshId} was NOT durably returned to the queue (SQLite is the only store): ${e?.message || e}`
+        );
+        return false;
       }
       return requeued;
     }
-    function atomicDrainFile(path54) {
-      const tmpPath = `${path54}.draining`;
-      try {
-        (0, import_fs6.renameSync)(path54, tmpPath);
-      } catch {
-        return null;
-      }
-      try {
-        const content = (0, import_fs6.readFileSync)(tmpPath, "utf-8");
-        try {
-          (0, import_fs6.unlinkSync)(tmpPath);
-        } catch {
-        }
-        return content;
-      } catch {
-        try {
-          (0, import_fs6.unlinkSync)(tmpPath);
-        } catch {
-        }
-        return null;
-      }
-    }
-    function selectiveDrainFile(path54, predicate) {
-      const tmpPath = `${path54}.draining`;
-      try {
-        (0, import_fs6.renameSync)(path54, tmpPath);
-      } catch {
-        return [];
-      }
-      let content;
-      try {
-        content = (0, import_fs6.readFileSync)(tmpPath, "utf-8");
-      } catch {
-        try {
-          (0, import_fs6.unlinkSync)(tmpPath);
-        } catch {
-        }
-        return [];
-      }
-      const consumed = [];
-      const keptLines = [];
-      for (const line of content.split("\n")) {
-        if (!line) continue;
-        let parsed;
-        try {
-          parsed = JSON.parse(line);
-        } catch {
-          parsed = void 0;
-        }
-        if (parsed && predicate(parsed)) {
-          consumed.push(parsed);
-        } else {
-          keptLines.push(line);
-        }
-      }
-      try {
-        if (keptLines.length > 0) {
-          (0, import_fs6.writeFileSync)(path54, keptLines.join("\n") + "\n", "utf-8");
-        }
-        (0, import_fs6.unlinkSync)(tmpPath);
-      } catch {
-        try {
-          if ((0, import_fs6.existsSync)(tmpPath) && !(0, import_fs6.existsSync)(path54)) (0, import_fs6.renameSync)(tmpPath, path54);
-        } catch {
-        }
-        return [];
-      }
-      return consumed;
-    }
     function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
       if (!meshId) return [];
       const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
-      const primaryDaemonId = daemonIds[0];
       const drainer = resolveDrainerIdentity(daemonIds, opts?.drainerIdentity);
       let priorDrainedEventIds = /* @__PURE__ */ new Set();
       try {
@@ -46019,17 +45856,7 @@ Next step: ${nextStep}`;
       } catch {
       }
       const onlyEvents = opts?.onlyEvents;
-      const matchesFilter = (eventName) => !onlyEvents || onlyEvents.has(eventName);
       const merged = [];
-      const seenFingerprints = /* @__PURE__ */ new Set();
-      const pushUnique = (event) => {
-        const fingerprint = buildPendingEventFingerprint(event);
-        if (fingerprint.trim()) {
-          if (seenFingerprints.has(fingerprint)) return;
-          seenFingerprints.add(fingerprint);
-        }
-        merged.push(event);
-      };
       try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
@@ -46040,39 +45867,17 @@ Next step: ${nextStep}`;
             { ...onlyEvents ? { onlyEvents } : {}, drainedBy }
           )) {
             const event = row.payload;
-            if (event) pushUnique(event);
+            if (event) merged.push(event);
           }
         }
       } catch (e) {
         if (!loggedSqlitePendingDrainFailure) {
           loggedSqlitePendingDrainFailure = true;
-          LOG2.warn("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only (further occurrences at debug): ${e?.message || e}`);
+          LOG2.warn("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId} \u2014 NO events can be delivered while the store is unavailable (there is no fallback store; further occurrences at debug): ${e?.message || e}`);
         } else {
-          LOG2.debug("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only: ${e?.message || e}`);
+          LOG2.debug("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId}; no events delivered this cycle: ${e?.message || e}`);
         }
       }
-      const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-      for (const path54 of paths) {
-        const isSharedFile = !!primaryDaemonId && path54 === getPendingEventsPath(meshId);
-        const targets = (e) => !isSharedFile || !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId);
-        if (onlyEvents) {
-          for (const event of selectiveDrainFile(path54, (e) => targets(e) && matchesFilter(e.event))) {
-            pushUnique(event);
-          }
-          continue;
-        }
-        const content = atomicDrainFile(path54);
-        if (!content) continue;
-        const parsed = content.split("\n").filter(Boolean).flatMap((line) => {
-          try {
-            return [JSON.parse(line)];
-          } catch {
-            return [];
-          }
-        });
-        const filtered = isSharedFile ? parsed.filter(targets) : parsed;
-        for (const event of filtered) pushUnique(event);
-      }
       if (merged.length === 0) return [];
       const routed = routeV2EventsForDrainer(merged, drainer, {
         alreadyDrained: (eventId) => priorDrainedEventIds.has(eventId),
@@ -46098,16 +45903,8 @@ Next step: ${nextStep}`;
           if (matchesTask(row.payload)) ids.push(row.id);
         }
         if (ids.length) removed += store.deletePendingEventsById(ids);
-      } catch {
-      }
-      const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
-      const primaryDaemonId = daemonIds[0];
-      const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-      for (const path54 of paths) {
-        try {
-          removed += selectiveDrainFile(path54, matchesTask).length;
-        } catch {
-        }
+      } catch (e) {
+        LOG2.warn("MeshEvents", `Failed to retract dispatch_blocked for task ${taskId} on mesh ${meshId}: ${e?.message || e}`);
       }
       return removed;
     }
@@ -46121,28 +45918,16 @@ Next step: ${nextStep}`;
       } catch {
       }
       const merged = [];
-      const seenFingerprints = /* @__PURE__ */ new Set();
-      const pushUnique = (event) => {
-        const fingerprint = buildPendingEventFingerprint(event);
-        if (fingerprint.trim()) {
-          if (seenFingerprints.has(fingerprint)) return;
-          seenFingerprints.add(fingerprint);
-        }
-        merged.push(event);
-      };
       try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
           for (const row of store.peekPendingEvents(meshId, daemonIds.length > 0 ? daemonIds : void 0)) {
             const event = row.payload;
-            if (event) pushUnique(event);
+            if (event) merged.push(event);
           }
         }
       } catch {
       }
-      for (const event of readPendingMeshCoordinatorEventsFromDisk(meshId, daemonIds)) {
-        pushUnique(event);
-      }
       const routed = routeV2EventsForDrainer(merged, drainer, {
         alreadyDrained: (eventId) => priorDrainedEventIds.has(eventId),
         batchSeen: /* @__PURE__ */ new Set(),
@@ -46243,37 +46028,24 @@ Next step: ${nextStep}`;
       }
       return result;
     }
-    function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
+    function clearPendingMeshCoordinatorEvents(meshId, _coordinatorDaemonId) {
       if (!meshId) return;
       try {
         MeshRuntimeStore.getInstance().clearPendingEventsForMesh(meshId);
       } catch {
       }
-      const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-      for (const path54 of paths) {
-        if ((0, import_fs6.existsSync)(path54)) try {
-          (0, import_fs6.unlinkSync)(path54);
-        } catch {
-        }
-      }
     }
-    var import_fs6;
-    var import_path6;
     var import_crypto6;
     var REFINE_TERMINAL_EVENTS;
     var meshV2DrainCounters;
     var warnedV2Violations;
     var loggedSqlitePendingDrainFailure;
     var TERMINAL_COMPLETION_EVENTS;
-    var MAX_PENDING_EVENTS_BYTES;
-    var MAX_PENDING_EVENTS_KEEP;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
     var init_mesh_events_pending = __esm2({
       "src/mesh/mesh-events-pending.ts"() {
         "use strict";
-        import_fs6 = require("fs");
-        import_path6 = require("path");
         import_crypto6 = require("crypto");
         init_logger();
         init_config();
@@ -46317,8 +46089,6 @@ Next step: ${nextStep}`;
         warnedV2Violations = /* @__PURE__ */ new Set();
         loggedSqlitePendingDrainFailure = false;
         TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
-        MAX_PENDING_EVENTS_BYTES = 100 * 1024;
-        MAX_PENDING_EVENTS_KEEP = 50;
         PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
         PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
       }
@@ -47855,15 +47625,15 @@ Next step: ${nextStep}`;
       return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
     }
     function legacyQueuePath(meshId) {
-      return (0, import_path7.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+      return (0, import_path6.join)(getLedgerDir2(), `${safeMeshId(meshId)}.queue.json`);
     }
     function cleanupStrayRootRuntimeDb(canonicalPath2) {
       try {
-        const strayPath = (0, import_path7.join)(getConfigDir2(), "mesh-runtime.db");
+        const strayPath = (0, import_path6.join)(getConfigDir2(), "mesh-runtime.db");
         if (strayPath === canonicalPath2) return;
-        if (!(0, import_fs7.existsSync)(strayPath)) return;
-        if ((0, import_fs7.statSync)(strayPath).size !== 0) return;
-        (0, import_fs7.unlinkSync)(strayPath);
+        if (!(0, import_fs6.existsSync)(strayPath)) return;
+        if ((0, import_fs6.statSync)(strayPath).size !== 0) return;
+        (0, import_fs6.unlinkSync)(strayPath);
         if (!loggedStrayCleanup) {
           loggedStrayCleanup = true;
           LOG2.info("MeshRuntimeStore", `Removed stray 0-byte root mesh-runtime.db at ${strayPath}`);
@@ -47876,18 +47646,18 @@ Next step: ${nextStep}`;
       }
     }
     function meshRuntimeStorePath() {
-      const dir = getLedgerDir();
-      const nextPath = (0, import_path7.join)(dir, "mesh-runtime.db");
+      const dir = getLedgerDir2();
+      const nextPath = (0, import_path6.join)(dir, "mesh-runtime.db");
       cleanupStrayRootRuntimeDb(nextPath);
-      if ((0, import_fs7.existsSync)(nextPath)) return nextPath;
-      const legacyPath = (0, import_path7.join)(dir, "beads.db");
-      if (!(0, import_fs7.existsSync)(legacyPath)) return nextPath;
+      if ((0, import_fs6.existsSync)(nextPath)) return nextPath;
+      const legacyPath = (0, import_path6.join)(dir, "beads.db");
+      if (!(0, import_fs6.existsSync)(legacyPath)) return nextPath;
       try {
-        (0, import_fs7.renameSync)(legacyPath, nextPath);
+        (0, import_fs6.renameSync)(legacyPath, nextPath);
         for (const suffix of ["-wal", "-shm"]) {
           const legacyCompanion = `${legacyPath}${suffix}`;
-          if ((0, import_fs7.existsSync)(legacyCompanion)) {
-            (0, import_fs7.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
+          if ((0, import_fs6.existsSync)(legacyCompanion)) {
+            (0, import_fs6.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
           }
         }
       } catch (err) {
@@ -47898,7 +47668,7 @@ Next step: ${nextStep}`;
             `Legacy beads.db\u2192mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`
           );
         }
-        return (0, import_fs7.existsSync)(nextPath) ? nextPath : legacyPath;
+        return (0, import_fs6.existsSync)(nextPath) ? nextPath : legacyPath;
       }
       return nextPath;
     }
@@ -47959,8 +47729,8 @@ Next step: ${nextStep}`;
         return { ledger: 0, toolCalls: 0, terminalQueue: 0, sessionDelivery: 0 };
       }
     }
-    var import_fs7;
-    var import_path7;
+    var import_fs6;
+    var import_path6;
     var DatabaseCtor;
     var loggedMigrationFailure;
     var loggedStrayCleanup;
@@ -47971,8 +47741,8 @@ Next step: ${nextStep}`;
     var init_mesh_runtime_store = __esm2({
       "src/mesh/mesh-runtime-store.ts"() {
         "use strict";
-        import_fs7 = require("fs");
-        import_path7 = require("path");
+        import_fs6 = require("fs");
+        import_path6 = require("path");
         init_logger();
         init_load_better_sqlite3();
         init_config();
@@ -48005,8 +47775,8 @@ Next step: ${nextStep}`;
           static WAL_MAX_BYTES = 50 * 1024 * 1024;
           // 50 MB
           constructor(dbPath) {
-            const dir = (0, import_path7.dirname)(dbPath);
-            if (!(0, import_fs7.existsSync)(dir)) (0, import_fs7.mkdirSync)(dir, { recursive: true });
+            const dir = (0, import_path6.dirname)(dbPath);
+            if (!(0, import_fs6.existsSync)(dir)) (0, import_fs6.mkdirSync)(dir, { recursive: true });
             this.dbPath = dbPath;
             this.db = new (loadDatabaseCtor())(dbPath);
             this.db.pragma("journal_mode = WAL");
@@ -48525,8 +48295,8 @@ Next step: ${nextStep}`;
             this.walWriteCounter = 0;
             try {
               const walPath = `${this.dbPath}-wal`;
-              if (!(0, import_fs7.existsSync)(walPath)) return;
-              const size = (0, import_fs7.statSync)(walPath).size;
+              if (!(0, import_fs6.existsSync)(walPath)) return;
+              const size = (0, import_fs6.statSync)(walPath).size;
               if (size < _MeshRuntimeStore.WAL_MAX_BYTES) return;
               process.stderr.write(
                 `[adhdev-mesh] WAL file ${Math.round(size / 1024 / 1024)}MB exceeds threshold; forcing checkpoint
@@ -48542,9 +48312,9 @@ Next step: ${nextStep}`;
             const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
             if (count.count > 0) return;
             const path54 = legacyQueuePath(meshId);
-            if (!(0, import_fs7.existsSync)(path54)) return;
+            if (!(0, import_fs6.existsSync)(path54)) return;
             try {
-              const entries = JSON.parse((0, import_fs7.readFileSync)(path54, "utf-8"));
+              const entries = JSON.parse((0, import_fs6.readFileSync)(path54, "utf-8"));
               if (!Array.isArray(entries)) return;
               const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -50558,7 +50328,7 @@ Next step: ${nextStep}`;
       compactLedger: () => compactLedger,
       enforceAllLedgerRotationCaps: () => enforceAllLedgerRotationCaps,
       enforceLedgerRotationCap: () => enforceLedgerRotationCap,
-      getLedgerDir: () => getLedgerDir,
+      getLedgerDir: () => getLedgerDir2,
       getLedgerSummary: () => getLedgerSummary,
       getSessionRecoveryContext: () => getSessionRecoveryContext,
       isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
@@ -50599,42 +50369,42 @@ Next step: ${nextStep}`;
       if (Number.isNaN(created)) return false;
       return now - created >= ttlDays * MS_PER_DAY;
     }
-    function getLedgerDir() {
-      const dir = (0, import_path8.join)(getConfigDir2(), LEDGER_DIR_NAME);
-      if (!(0, import_fs8.existsSync)(dir)) {
-        (0, import_fs8.mkdirSync)(dir, { recursive: true, mode: 448 });
+    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_path8.join)(getLedgerDir(), `${safe}.jsonl`);
+      return (0, import_path7.join)(getLedgerDir2(), `${safe}.jsonl`);
     }
     function getRotatedPath(meshId, index) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path8.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
+      return (0, import_path7.join)(getLedgerDir2(), `${safe}.${index}.jsonl`);
     }
     function getArchivePath(meshId) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path8.join)(getLedgerDir(), `${safe}.archive.jsonl`);
+      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_path8.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+      return (0, import_path7.join)(getLedgerDir2(), `${safe}.archive.${index}.jsonl`);
     }
     function getArchivedCountsPath(meshId) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path8.join)(getLedgerDir(), `${safe}.archived-counts.json`);
+      return (0, import_path7.join)(getLedgerDir2(), `${safe}.archived-counts.json`);
     }
     function rotateArchiveFile(meshId, archivePath) {
       let index = 1;
-      while ((0, import_fs8.existsSync)(getRotatedArchivePath(meshId, index))) {
+      while ((0, import_fs7.existsSync)(getRotatedArchivePath(meshId, index))) {
         index++;
         if (index > 5) break;
       }
       if (index > 5) index = 5;
       try {
-        (0, import_fs8.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
+        (0, import_fs7.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
       } catch (e) {
         process.stderr.write(`[adhdev-mesh] Archive rotation failed for mesh ${meshId}: ${e?.message || e}
 `);
@@ -50642,15 +50412,15 @@ Next step: ${nextStep}`;
     }
     function readArchivedCounts(meshId) {
       const path54 = getArchivedCountsPath(meshId);
-      if (!(0, import_fs8.existsSync)(path54)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+      if (!(0, import_fs7.existsSync)(path54)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
       try {
-        return JSON.parse((0, import_fs8.readFileSync)(path54, "utf-8"));
+        return JSON.parse((0, import_fs7.readFileSync)(path54, "utf-8"));
       } catch {
         return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
       }
     }
     function writeArchivedCounts(meshId, counts) {
-      (0, import_fs8.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
+      (0, import_fs7.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
     }
     function updateArchivedCounts(meshId, archived) {
       const counts = readArchivedCounts(meshId);
@@ -50686,7 +50456,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function compactLedger(meshId) {
       const filePath = getLedgerPath(meshId);
-      if (!(0, import_fs8.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
+      if (!(0, import_fs7.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
       const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
       const entries = readLedgerEntries(meshId);
       const keep = [];
@@ -50701,11 +50471,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_fs8.existsSync)(archivePath) && (0, import_fs8.statSync)(archivePath).size > 50 * 1024 * 1024) {
+        if ((0, import_fs7.existsSync)(archivePath) && (0, import_fs7.statSync)(archivePath).size > 50 * 1024 * 1024) {
           rotateArchiveFile(meshId, archivePath);
         }
         const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        (0, import_fs8.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs7.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
         updateArchivedCounts(meshId, archive);
       } catch (e) {
         process.stderr.write(`[adhdev-mesh] Ledger archive write failed for mesh ${meshId}: ${e?.message || e}
@@ -50714,7 +50484,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       try {
         const keepLines = keep.length ? keep.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-        (0, import_fs8.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs7.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}
@@ -50896,9 +50666,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         if (derived) entry.taskId = derived;
       }
       const filePath = getLedgerPath(meshId);
-      if ((0, import_fs8.existsSync)(filePath)) {
+      if ((0, import_fs7.existsSync)(filePath)) {
         try {
-          const stat2 = (0, import_fs8.statSync)(filePath);
+          const stat2 = (0, import_fs7.statSync)(filePath);
           if (stat2.size >= MAX_FILE_SIZE_BYTES) {
             rotateLedgerFile(meshId, filePath);
           } else if (stat2.size >= COMPACT_THRESHOLD_BYTES) {
@@ -50924,7 +50694,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       try {
         const line = JSON.stringify(entry) + "\n";
-        (0, import_fs8.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+        (0, import_fs7.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
         invalidateLedgerCache(meshId);
         meshLedgerEvents.emit("append", meshId, entry);
         if (entry.kind === OPERATING_NOTE_KIND || entry.kind === OPERATING_NOTE_TOMBSTONE_KIND) {
@@ -51016,7 +50786,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_fs8.writeFileSync)(filePath, lines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs7.writeFileSync)(filePath, lines, { encoding: "utf-8", mode: 384 });
       } catch {
       }
       invalidateLedgerCache(meshId);
@@ -51073,7 +50843,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       try {
         const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        (0, import_fs8.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+        (0, import_fs7.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
         invalidateLedgerCache(meshId);
         for (const entry of validEntries) {
           meshLedgerEvents.emit("append", meshId, entry);
@@ -51085,10 +50855,10 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function readLedgerFile(meshId) {
       const filePath = getLedgerPath(meshId);
-      if (!(0, import_fs8.existsSync)(filePath)) return [];
+      if (!(0, import_fs7.existsSync)(filePath)) return [];
       let content;
       try {
-        content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+        content = (0, import_fs7.readFileSync)(filePath, "utf-8");
       } catch {
         return [];
       }
@@ -51365,13 +51135,13 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function rotateLedgerFile(meshId, currentPath) {
       let index = 1;
-      while ((0, import_fs8.existsSync)(getRotatedPath(meshId, index))) {
+      while ((0, import_fs7.existsSync)(getRotatedPath(meshId, index))) {
         index++;
         if (index > 10) break;
       }
       if (index > 10) index = 10;
       try {
-        (0, import_fs8.renameSync)(currentPath, getRotatedPath(meshId, index));
+        (0, import_fs7.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.
 `);
@@ -51407,7 +51177,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function readRotationEntriesTolerant(filePath) {
       let text;
       try {
-        text = (0, import_fs8.readFileSync)(filePath, "utf-8");
+        text = (0, import_fs7.readFileSync)(filePath, "utf-8");
       } catch {
         return [];
       }
@@ -51426,14 +51196,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return out;
     }
     function evictClosedRotationFile(safe, dir, entry) {
-      const filePath = (0, import_path8.join)(dir, entry.name);
+      const filePath = (0, import_path7.join)(dir, entry.name);
       const counts = readArchivedCounts(safe);
       const alreadyFolded = new Set(counts.evictedRotations ?? []);
       if (alreadyFolded.has(entry.name)) {
-        if ((0, import_fs8.existsSync)(filePath)) (0, import_fs8.unlinkSync)(filePath);
+        if ((0, import_fs7.existsSync)(filePath)) (0, import_fs7.unlinkSync)(filePath);
         return;
       }
-      if (closedRotationKind(safe, entry.name) === "active" && (0, import_fs8.existsSync)(filePath)) {
+      if (closedRotationKind(safe, entry.name) === "active" && (0, import_fs7.existsSync)(filePath)) {
         const entries = readRotationEntriesTolerant(filePath);
         for (const e of entries) {
           if (e.kind === "task_completed") counts.taskCompleted++;
@@ -51446,25 +51216,25 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       counts.evictedRotations = [...alreadyFolded, entry.name];
       counts.lastArchivedAt = (/* @__PURE__ */ new Date()).toISOString();
       writeArchivedCounts(safe, counts);
-      if ((0, import_fs8.existsSync)(filePath)) (0, import_fs8.unlinkSync)(filePath);
+      if ((0, import_fs7.existsSync)(filePath)) (0, import_fs7.unlinkSync)(filePath);
     }
     function enforceLedgerRotationCap(meshId, opts) {
       const maxFiles = opts?.maxFiles ?? resolveLedgerRotationMaxFiles();
       const maxBytes = opts?.maxBytes ?? resolveLedgerRotationMaxBytes();
       const dryRun = opts?.dryRun === true;
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      const dir = getLedgerDir();
+      const dir = getLedgerDir2();
       const stats = [];
       let names = [];
       try {
-        names = (0, import_fs8.readdirSync)(dir);
+        names = (0, import_fs7.readdirSync)(dir);
       } catch {
         names = [];
       }
       for (const name of names) {
         if (!closedRotationKind(safe, name)) continue;
         try {
-          const st = (0, import_fs8.statSync)((0, import_path8.join)(dir, name));
+          const st = (0, import_fs7.statSync)((0, import_path7.join)(dir, name));
           if (st.isFile()) stats.push({ name, sizeBytes: st.size, mtimeMs: st.mtimeMs });
         } catch {
         }
@@ -51494,10 +51264,10 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         evictedBytes: 0,
         byReason: { rotation_cap_count: 0, rotation_cap_bytes: 0 }
       };
-      const dir = getLedgerDir();
+      const dir = getLedgerDir2();
       let names = [];
       try {
-        names = (0, import_fs8.readdirSync)(dir);
+        names = (0, import_fs7.readdirSync)(dir);
       } catch {
         return result;
       }
@@ -51523,8 +51293,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       return result;
     }
-    var import_fs8;
-    var import_path8;
+    var import_fs7;
+    var import_path7;
     var import_crypto9;
     var import_events;
     var TASK_LIFECYCLE_LEDGER_KINDS;
@@ -51550,8 +51320,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     var init_mesh_ledger = __esm2({
       "src/mesh/mesh-ledger.ts"() {
         "use strict";
-        import_fs8 = require("fs");
-        import_path8 = require("path");
+        import_fs7 = require("fs");
+        import_path7 = require("path");
         import_crypto9 = require("crypto");
         init_config();
         init_mesh_retention_config();
@@ -52705,10 +52475,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_path9.join)(workspace, relative8);
-        if (!(0, import_fs9.existsSync)(configPath)) continue;
+        const configPath = (0, import_path8.join)(workspace, relative8);
+        if (!(0, import_fs8.existsSync)(configPath)) continue;
         try {
-          const parsed = parseConfigText3(configPath, (0, import_fs9.readFileSync)(configPath, "utf-8"));
+          const parsed = parseConfigText3(configPath, (0, import_fs8.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 };
@@ -52724,7 +52494,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_fs9.readFileSync)((0, import_path9.join)(workspace, "package.json"), "utf-8"));
+        const parsed = JSON.parse((0, import_fs8.readFileSync)((0, import_path8.join)(workspace, "package.json"), "utf-8"));
         return isRecord3(parsed?.scripts) ? parsed.scripts : {};
       } catch {
         return {};
@@ -52799,8 +52569,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_fs9;
-    var import_path9;
+    var import_fs8;
+    var import_path8;
     var yaml3;
     var MESH_REFINE_VALIDATION_CATEGORIES;
     var MESH_REFINE_VALIDATION_SCOPES;
@@ -52813,8 +52583,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_fs9 = require("fs");
-        import_path9 = require("path");
+        import_fs8 = require("fs");
+        import_path8 = require("path");
         yaml3 = __toESM2(require_js_yaml());
         MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
         MESH_REFINE_VALIDATION_SCOPES = ["none", "web", "daemon"];
@@ -52921,7 +52691,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 = path17.join(dir, trimmed + ext);
-          if ((0, import_fs10.existsSync)(full)) return full;
+          if ((0, import_fs9.existsSync)(full)) return full;
         }
       }
       return null;
@@ -52938,7 +52708,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 (path17.isAbsolute(trimmed) && (0, import_fs10.existsSync)(trimmed)) return trimmed;
+      if (path17.isAbsolute(trimmed) && (0, import_fs9.existsSync)(trimmed)) return trimmed;
       try {
         const out = (0, import_child_process3.execFileSync)("where", [trimmed], {
           encoding: "utf8",
@@ -52987,7 +52757,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       };
     }
     var import_child_process3;
-    var import_fs10;
+    var import_fs9;
     var path17;
     var DIRECT_EXEC_EXT;
     var SHIM_EXEC_EXT;
@@ -52996,7 +52766,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_fs10 = require("fs");
+        import_fs9 = require("fs");
         path17 = __toESM2(require("path"));
         DIRECT_EXEC_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
         SHIM_EXEC_EXT = /* @__PURE__ */ new Set([".cmd", ".bat"]);
@@ -53134,7 +52904,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_fs11.existsSync)(workspace)) return false;
+      if (!workspace || !(0, import_fs10.existsSync)(workspace)) return false;
       try {
         const out = (0, import_node_child_process4.execFileSync)(resolveWin32Executable("git"), ["status", "--porcelain"], {
           cwd: workspace,
@@ -53197,10 +52967,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_path10.join)(workspace, relative8);
-        if (!(0, import_fs11.existsSync)(configPath)) continue;
+        const configPath = (0, import_path9.join)(workspace, relative8);
+        if (!(0, import_fs10.existsSync)(configPath)) continue;
         try {
-          const parsed = parseConfigText4(configPath, (0, import_fs11.readFileSync)(configPath, "utf-8"));
+          const parsed = parseConfigText4(configPath, (0, import_fs10.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 };
@@ -53213,9 +52983,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_path10.join)(workspace, relative8);
+        const filePath = (0, import_path9.join)(workspace, relative8);
         try {
-          digest[relative8] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs11.readFileSync)(filePath)).digest("hex");
+          digest[relative8] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs10.readFileSync)(filePath)).digest("hex");
         } catch {
           digest[relative8] = "absent";
         }
@@ -53286,10 +53056,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_fs11.existsSync)((0, import_path10.join)(workspace, p)));
+      const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs10.existsSync)((0, import_path9.join)(workspace, p)));
       for (const command of validation.commands) {
         if (initiallyAbsent.length > 0) {
-          const appearedNow = initiallyAbsent.filter((p) => (0, import_fs11.existsSync)((0, import_path10.join)(workspace, p)));
+          const appearedNow = initiallyAbsent.filter((p) => (0, import_fs10.existsSync)((0, import_path9.join)(workspace, p)));
           if (appearedNow.length > 0) {
             state.status = "stale";
             state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -53297,7 +53067,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
             return state;
           }
         }
-        const cwd = command.cwd ? (0, import_path10.resolve)(workspace, command.cwd) : workspace;
+        const cwd = command.cwd ? (0, import_path9.resolve)(workspace, command.cwd) : workspace;
         const startedAt = Date.now();
         state.lastCommand = command.displayCommand;
         const resolvedCommand = resolveWin32Executable(command.command);
@@ -53357,8 +53127,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       }
       return state;
     }
-    var import_fs11;
-    var import_path10;
+    var import_fs10;
+    var import_path9;
     var import_node_child_process4;
     var import_node_crypto2;
     var import_node_util3;
@@ -53373,8 +53143,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_fs11 = require("fs");
-        import_path10 = require("path");
+        import_fs10 = require("fs");
+        import_path9 = require("path");
         import_node_child_process4 = require("child_process");
         import_node_crypto2 = require("crypto");
         import_node_util3 = require("util");
@@ -53839,13 +53609,13 @@ ${rendered}`, "utf-8");
       }
     });
     function getRegistryPath() {
-      return (0, import_path12.join)(getDaemonDataDir(), "mesh-coordinators.json");
+      return (0, import_path11.join)(getDaemonDataDir(), "mesh-coordinators.json");
     }
     function loadMeshCoordinatorRegistry() {
       const path54 = getRegistryPath();
-      if (!(0, import_fs13.existsSync)(path54)) return;
+      if (!(0, import_fs12.existsSync)(path54)) return;
       try {
-        const raw = JSON.parse((0, import_fs13.readFileSync)(path54, "utf-8"));
+        const raw = JSON.parse((0, import_fs12.readFileSync)(path54, "utf-8"));
         if (!Array.isArray(raw)) return;
         _registry.clear();
         for (const entry of raw) {
@@ -53858,7 +53628,7 @@ ${rendered}`, "utf-8");
     }
     function saveRegistry() {
       try {
-        (0, import_fs13.writeFileSync)(
+        (0, import_fs12.writeFileSync)(
           getRegistryPath(),
           JSON.stringify([..._registry.values()], null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -53891,14 +53661,14 @@ ${rendered}`, "utf-8");
     function listCoordinatorsForWorkspace(workspace) {
       return [..._registry.values()].filter((e) => e.workspace === workspace);
     }
-    var import_path12;
-    var import_fs13;
+    var import_path11;
+    var import_fs12;
     var _registry;
     var init_coordinator_registry = __esm2({
       "src/mesh/coordinator-registry.ts"() {
         "use strict";
-        import_path12 = require("path");
-        import_fs13 = require("fs");
+        import_path11 = require("path");
+        import_fs12 = require("fs");
         init_config();
         _registry = /* @__PURE__ */ new Map();
       }
@@ -62048,7 +61818,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_fs15.existsSync)(workspace)) return;
+        if (!(0, import_fs14.existsSync)(workspace)) return;
         await executeLocalAutoFastForward({ meshId: args.meshId, nodeId: args.nodeId, node, workspace, policy, trigger: "idle_auto" });
         return;
       }
@@ -62145,7 +61915,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         });
       });
     }
-    var import_fs15;
+    var import_fs14;
     var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS;
     var idleAutoFastForwardLastAttempt;
     var CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS;
@@ -62174,7 +61944,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var init_mesh_queue_assignment = __esm2({
       "src/mesh/mesh-queue-assignment.ts"() {
         "use strict";
-        import_fs15 = require("fs");
+        import_fs14 = require("fs");
         init_runtime_defaults();
         init_config();
         init_mesh_config();
@@ -62522,7 +62292,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
     function getStatePath() {
-      return (0, import_path14.join)(getConfigDir2(), "state.json");
+      return (0, import_path13.join)(getConfigDir2(), "state.json");
     }
     function normalizeState(raw) {
       const parsed = isPlainObject22(raw) ? raw : {};
@@ -62573,11 +62343,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     }
     function loadState() {
       const statePath = getStatePath();
-      if (!(0, import_fs16.existsSync)(statePath)) {
+      if (!(0, import_fs15.existsSync)(statePath)) {
         return { ...DEFAULT_STATE };
       }
       try {
-        const raw = (0, import_fs16.readFileSync)(statePath, "utf-8");
+        const raw = (0, import_fs15.readFileSync)(statePath, "utf-8");
         return normalizeState(JSON.parse(raw));
       } catch {
         return { ...DEFAULT_STATE };
@@ -62586,7 +62356,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function saveState(state) {
       const statePath = getStatePath();
       const normalized = normalizeState(state);
-      (0, import_fs16.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs15.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function resetState() {
       saveState({ ...DEFAULT_STATE });
@@ -62626,14 +62396,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       delete next[key2];
       saveState({ ...state, deferredRestartSchedules: next });
     }
-    var import_fs16;
-    var import_path14;
+    var import_fs15;
+    var import_path13;
     var DEFAULT_STATE;
     var init_state_store = __esm2({
       "src/config/state-store.ts"() {
         "use strict";
-        import_fs16 = require("fs");
-        import_path14 = require("path");
+        import_fs15 = require("fs");
+        import_path13 = require("path");
         init_config();
         DEFAULT_STATE = {
           recentActivity: [],
@@ -65787,7 +65557,7 @@ ${cleanBody}`;
         const targets = wantSession ? idleCoordinators.filter((c) => sessionIdsEquivalent(c.sessionId, wantSession)) : idleCoordinators;
         if (targets.length === 0 || !pending.coordinatorMessage) {
           try {
-            queuePendingMeshCoordinatorEvent(pending);
+            requeueDrainedPendingMeshCoordinatorEvent(pending);
           } catch {
           }
           continue;
@@ -66384,7 +66154,7 @@ ${cleanBody}`;
     }
     function safeUnlink(path54) {
       try {
-        (0, import_fs17.unlinkSync)(path54);
+        (0, import_fs16.unlinkSync)(path54);
         return true;
       } catch (e) {
         LOG2.warn("DiskRetention", `Failed to delete ${path54}: ${e?.message || e}`);
@@ -66392,18 +66162,18 @@ ${cleanBody}`;
       }
     }
     function listDirFiles(dir) {
-      if (!(0, import_fs17.existsSync)(dir)) return [];
+      if (!(0, import_fs16.existsSync)(dir)) return [];
       const out = [];
       let names;
       try {
-        names = (0, import_fs17.readdirSync)(dir);
+        names = (0, import_fs16.readdirSync)(dir);
       } catch {
         return [];
       }
       for (const name of names) {
-        const path54 = (0, import_path15.join)(dir, name);
+        const path54 = (0, import_path14.join)(dir, name);
         try {
-          const st = (0, import_fs17.statSync)(path54);
+          const st = (0, import_fs16.statSync)(path54);
           if (st.isFile()) out.push({ path: path54, mtimeMs: st.mtimeMs });
         } catch {
         }
@@ -66411,7 +66181,7 @@ ${cleanBody}`;
       return out;
     }
     function pruneExpiredLedgerJsonl(now = Date.now()) {
-      const dir = getLedgerDir();
+      const dir = getLedgerDir2();
       const jsonl = listDirFiles(dir).filter((f) => f.path.endsWith(".jsonl"));
       const expired = selectExpiredLedgerJsonl(jsonl, now);
       let deleted = 0;
@@ -66420,7 +66190,7 @@ ${cleanBody}`;
       return deleted;
     }
     function pruneExpiredDbBackups(now = Date.now()) {
-      const dir = getLedgerDir();
+      const dir = getLedgerDir2();
       const baks = listDirFiles(dir).filter((f) => isDbBackupFileName(f.path.split(/[/\\]/).pop() || ""));
       const expired = selectExpiredDbBackups(baks, now);
       let deleted = 0;
@@ -66429,23 +66199,23 @@ ${cleanBody}`;
       return deleted;
     }
     function pruneExpiredSessionHostRuntimes(now = Date.now()) {
-      const root = (0, import_path15.join)(getConfigDir2(), "session-host");
-      if (!(0, import_fs17.existsSync)(root)) return 0;
+      const root = (0, import_path14.join)(getConfigDir2(), "session-host");
+      if (!(0, import_fs16.existsSync)(root)) return 0;
       let apps;
       try {
-        apps = (0, import_fs17.readdirSync)(root);
+        apps = (0, import_fs16.readdirSync)(root);
       } catch {
         return 0;
       }
       const candidates = [];
       for (const app of apps) {
-        const runtimesDir = (0, import_path15.join)(root, app, "runtimes");
-        if (!(0, import_fs17.existsSync)(runtimesDir)) continue;
+        const runtimesDir = (0, import_path14.join)(root, app, "runtimes");
+        if (!(0, import_fs16.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_fs16.readFileSync)(f.path, "utf-8"));
             const rec = parsed && typeof parsed === "object" ? parsed.record : null;
             record2 = rec && typeof rec === "object" ? rec : null;
           } catch {
@@ -66542,8 +66312,8 @@ ${cleanBody}`;
       }
       return signalled;
     }
-    var import_fs17;
-    var import_path15;
+    var import_fs16;
+    var import_path14;
     var DAY_MS2;
     var LEDGER_JSONL_MAX_AGE_MS;
     var SESSION_HOST_RUNTIME_MAX_AGE_MS;
@@ -66552,8 +66322,8 @@ ${cleanBody}`;
     var init_mesh_disk_retention = __esm2({
       "src/mesh/mesh-disk-retention.ts"() {
         "use strict";
-        import_fs17 = require("fs");
-        import_path15 = require("path");
+        import_fs16 = require("fs");
+        import_path14 = require("path");
         init_config();
         init_mesh_ledger();
         init_runtime_surface();
@@ -66567,7 +66337,7 @@ ${cleanBody}`;
       }
     });
     function retentionStatePath() {
-      return (0, import_path16.join)(getLedgerDir(), "worktree-node-retention-state.json");
+      return (0, import_path15.join)(getLedgerDir2(), "worktree-node-retention-state.json");
     }
     function stateKey(meshId, nodeId) {
       return `${meshId}::${nodeId}`;
@@ -66632,7 +66402,7 @@ ${cleanBody}`;
       return String(stdout || "");
     }
     function normalizePathForCompare(value) {
-      const resolved = (0, import_path16.resolve)(value);
+      const resolved = (0, import_path15.resolve)(value);
       try {
         return fs11.realpathSync(resolved);
       } catch {
@@ -66685,7 +66455,7 @@ ${cleanBody}`;
       if (workspace && ctx.processCwd) {
         const normalizedWorkspace = normalizePathForCompare(workspace);
         const normalizedCwd = normalizePathForCompare(ctx.processCwd);
-        if (normalizedCwd === normalizedWorkspace || normalizedCwd.startsWith(normalizedWorkspace + import_path16.sep)) {
+        if (normalizedCwd === normalizedWorkspace || normalizedCwd.startsWith(normalizedWorkspace + import_path15.sep)) {
           return skip("process_cwd_reference", "Worktree path is (or contains) the current process working directory; an open-runtime/cwd reference blocks removal.");
         }
       }
@@ -67049,7 +66819,7 @@ ${cleanBody}`;
     }
     var fs11;
     var import_os22;
-    var import_path16;
+    var import_path15;
     var LOG_CATEGORY;
     var metrics2;
     var init_mesh_worktree_retention = __esm2({
@@ -67057,7 +66827,7 @@ ${cleanBody}`;
         "use strict";
         fs11 = __toESM2(require("fs"));
         import_os22 = require("os");
-        import_path16 = require("path");
+        import_path15 = require("path");
         init_dist();
         init_logger();
         init_config();
@@ -67746,6 +67516,75 @@ ${cleanBody}`;
       }
       return delivered;
     }
+    function holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId) {
+      const queuedAt = typeof pending.queuedAt === "number" ? pending.queuedAt : Date.now();
+      if (Date.now() - queuedAt <= STRICT_SESSION_MATCH_TTL_MS) {
+        try {
+          const requeued = requeueDrainedPendingMeshCoordinatorEvent(pending);
+          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})${requeued ? "" : " [WARN: not durably re-queued]"}`);
+          traceMeshEventDrop("strict_route_hold", {
+            taskId: pending.metadataEvent?.taskId,
+            sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
+            nodeId: pending.nodeId,
+            meshId,
+            event: pending.event
+          }, `coordinatorSession=${wantSession} not live durable=${requeued}`);
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
+        }
+        return;
+      }
+      const finalSummary = readMeshCompletionSummary(pending.metadataEvent || {});
+      try {
+        appendLedgerEntry(meshId, {
+          kind: "event_held",
+          ...pending.nodeId ? { nodeId: pending.nodeId } : {},
+          payload: {
+            event: pending.event,
+            reason: "strict_route_expired",
+            recoverable: true,
+            targetCoordinatorSessionId: wantSession,
+            targetCoordinatorDaemonId: pending.targetCoordinatorDaemonId ?? null,
+            nodeLabel: pending.nodeLabel,
+            ...pending.workspace ? { workspace: pending.workspace } : {},
+            queuedAt,
+            ...finalSummary ? { finalSummary } : {}
+          }
+        });
+        LOG2.warn("MeshReconcile", `Strict route expire: coordinator session ${wantSession} never returned for mesh ${meshId} \u2014 recorded to ledger (recoverable), dropped (${pending.event})`);
+        traceMeshEventDrop("strict_route_expired", {
+          taskId: pending.metadataEvent?.taskId,
+          sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
+          nodeId: pending.nodeId,
+          meshId,
+          event: pending.event
+        }, `coordinatorSession=${wantSession} never returned`);
+      } catch (e) {
+        LOG2.warn("MeshReconcile", `Failed to ledger-expire strict-unmatched ${pending.event} for mesh ${meshId}: ${e?.message || e}`);
+      }
+    }
+    var coordinatorModalParkState;
+    var DISK_RETENTION_INTERVAL_MS;
+    var heldEventLedgerRecorded;
+    var STRICT_SESSION_MATCH_TTL_MS;
+    var init_mesh_reconcile_coordinator_drain = __esm2({
+      "src/mesh/mesh-reconcile-coordinator-drain.ts"() {
+        "use strict";
+        init_config();
+        init_logger();
+        init_mesh_events_pending();
+        init_mesh_ledger();
+        init_mesh_events_coordinator();
+        init_mesh_event_classify();
+        init_mesh_events_utils();
+        init_mesh_event_trace();
+        init_dist();
+        coordinatorModalParkState = /* @__PURE__ */ new Map();
+        DISK_RETENTION_INTERVAL_MS = 60 * 60 * 1e3;
+        heldEventLedgerRecorded = /* @__PURE__ */ new Set();
+        STRICT_SESSION_MATCH_TTL_MS = 6e4;
+      }
+    });
     function assignedRowLiveStatusIsAwaitingApproval(mesh, nodeId, sessionId) {
       if (!nodeId || !sessionId) return false;
       try {
@@ -68548,6 +68387,165 @@ ${cleanBody}`;
         }, `${reason} stale=${Math.round((nowMs - anchorMs) / 6e4)}m`);
       }
     }
+    var ASSIGNED_STRANDED_DEADLINE_MS;
+    var DELIVERED_NO_TURN_DEADLINE_MS;
+    var NATIVE_SOURCE_ACTIVITY_STALE_MS;
+    var ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS;
+    var RECLAIM_UNKNOWN_GRACE_TICKS;
+    var QUEUE_HOLD_HARD_DEADLINE_MS;
+    var queueHoldHardDeadlineAudited;
+    var deliveredNoTurnUnknownStreak;
+    var deliveredUnconsumedUnknownStreak;
+    var ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS;
+    var assignedIdleFinalAssistantSince;
+    var ZOMBIE_ASSIGNED_MIN_AGE_MS;
+    var init_mesh_reconcile_stranded_dispatch = __esm2({
+      "src/mesh/mesh-reconcile-stranded-dispatch.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_ledger();
+        init_mesh_runtime_store();
+        init_mesh_events_utils();
+        init_mesh_event_trace();
+        init_dist();
+        init_mesh_work_queue();
+        init_mesh_queue_assignment();
+        init_mesh_events_stale();
+        init_mesh_reconcile_identity();
+        init_mesh_remote_event_pull();
+        init_transcript_evidence();
+        init_mesh_completion_synthesis();
+        init_mesh_active_work();
+        init_mesh_event_forwarding();
+        init_mesh_turn_ledger();
+        init_mesh_turn_presentation();
+        ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
+        DELIVERED_NO_TURN_DEADLINE_MS = 15 * 6e4;
+        NATIVE_SOURCE_ACTIVITY_STALE_MS = 10 * 6e4;
+        ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS = 25e3;
+        RECLAIM_UNKNOWN_GRACE_TICKS = 3;
+        QUEUE_HOLD_HARD_DEADLINE_MS = 90 * 6e4;
+        queueHoldHardDeadlineAudited = /* @__PURE__ */ new Set();
+        deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
+        deliveredUnconsumedUnknownStreak = /* @__PURE__ */ new Map();
+        ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS = 8e3;
+        assignedIdleFinalAssistantSince = /* @__PURE__ */ new Map();
+        ZOMBIE_ASSIGNED_MIN_AGE_MS = 30 * 60 * 1e3;
+      }
+    });
+    function scheduleUnresolvedForwardNudge(components) {
+      if (!components.dispatchMeshCommand) return;
+      if (unresolvedForwardNudgeTimer) return;
+      unresolvedForwardNudgeTimer = setTimeout(() => {
+        unresolvedForwardNudgeTimer = void 0;
+        if (unresolvedForwardNudgeRunning) return;
+        unresolvedForwardNudgeRunning = true;
+        void retryUnresolvedDelegateForwards(components).catch((e) => LOG2.warn("MeshReconcile", `Nudged unresolved-forward retry failed: ${e?.message || e}`)).finally(() => {
+          unresolvedForwardNudgeRunning = false;
+        });
+      }, UNRESOLVED_FORWARD_NUDGE_DELAY_MS);
+      if (typeof unresolvedForwardNudgeTimer.unref === "function") unresolvedForwardNudgeTimer.unref();
+    }
+    function clearUnresolvedForwardNudge() {
+      if (unresolvedForwardNudgeTimer) {
+        clearTimeout(unresolvedForwardNudgeTimer);
+        unresolvedForwardNudgeTimer = void 0;
+      }
+    }
+    async function retryUnresolvedDelegateForwards(components) {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      if (!dispatchMeshCommand) return;
+      expireStaleUnresolvedDelegateForwards();
+      const entries = peekUnresolvedDelegateForwards();
+      if (entries.length === 0) {
+        if (unresolvedForwardRejectionCounts.size > 0) unresolvedForwardRejectionCounts.clear();
+        return;
+      }
+      const selfIds = resolveCoordinatorDaemonIds(components);
+      const isSelfCoordinatorId = (id) => selfIds.some((self) => daemonIdsEquivalent(self, id));
+      for (const entry of entries) {
+        const entryTraceCtx = {
+          taskId: entry.payload.taskId,
+          sessionId: readNonEmptyString(entry.payload.targetSessionId) || readNonEmptyString(entry.payload.sessionId),
+          nodeId: readNonEmptyString(entry.payload.nodeId),
+          event: readNonEmptyString(entry.payload.event)
+        };
+        if (isSelfCoordinatorId(entry.coordinatorDaemonId)) {
+          let localResult;
+          try {
+            traceMeshEventStage("forward_send", entryTraceCtx, `self \u2192 local router (${entry.coordinatorDaemonId})`);
+            localResult = handleMeshForwardEvent(components, entry.payload);
+          } catch (e) {
+            LOG2.warn("MeshReconcile", `Local route of self-addressed forward to ${entry.coordinatorDaemonId} threw: ${e?.message || e} \u2014 draining anyway to break the retry loop`);
+          }
+          ackUnresolvedDelegateForward(entry.id);
+          unresolvedForwardRejectionCounts.delete(entry.id);
+          if (localResult && localResult.success === false) {
+            LOG2.warn("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString(entry.payload.event)} rejected by local router (${readNonEmptyString(localResult.error) || "no reason"}) \u2014 drained to break the self-forward retry loop`);
+            traceMeshEventDrop("self_forward_local_rejected", entryTraceCtx, readNonEmptyString(localResult.error) || "no reason");
+          } else {
+            LOG2.info("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString(entry.payload.event)} routed via local router (coordinator ${entry.coordinatorDaemonId} is self) \u2014 drained`);
+          }
+          continue;
+        }
+        let pushPayload = entry.payload;
+        if (!readNonEmptyString(pushPayload.meshId)) {
+          const recoveredMeshId = resolveForwardEventMeshId(components, pushPayload);
+          if (recoveredMeshId) {
+            pushPayload = { ...pushPayload, meshId: recoveredMeshId };
+            traceMeshEventStage("forward_meshid_recovered", entryTraceCtx, `meshId=${recoveredMeshId}`);
+          }
+        }
+        let result;
+        try {
+          traceMeshEventStage("forward_send", entryTraceCtx, `retry \u2192 ${entry.coordinatorDaemonId}`);
+          result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", withStatusProbeMarker(pushPayload));
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
+          traceMeshEventDrop("retry_forward_failed", entryTraceCtx, e?.message || String(e));
+          continue;
+        }
+        if (result && result.success === false) {
+          const rejections = (unresolvedForwardRejectionCounts.get(entry.id) || 0) + 1;
+          unresolvedForwardRejectionCounts.set(entry.id, rejections);
+          const reason = readNonEmptyString(result.error) || "no reason";
+          if (rejections >= MAX_FORWARD_REJECTIONS) {
+            ackUnresolvedDelegateForward(entry.id);
+            unresolvedForwardRejectionCounts.delete(entry.id);
+            LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected ${rejections}x (${reason}) \u2014 dropping unresolved-delegate ${readNonEmptyString(entry.payload.event)} (sess=${readNonEmptyString(entry.payload.targetSessionId) || readNonEmptyString(entry.payload.sessionId) || "-"}) to stop the retry loop`);
+            traceMeshEventDrop("retry_forward_exhausted", entryTraceCtx, `${reason} (${rejections} rejections)`);
+          } else {
+            LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${reason}) \u2014 left queued (attempt ${rejections}/${MAX_FORWARD_REJECTIONS})`);
+            traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, reason);
+          }
+          continue;
+        }
+        ackUnresolvedDelegateForward(entry.id);
+        unresolvedForwardRejectionCounts.delete(entry.id);
+        LOG2.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
+      }
+    }
+    var unresolvedForwardRejectionCounts;
+    var MAX_FORWARD_REJECTIONS;
+    var UNRESOLVED_FORWARD_NUDGE_DELAY_MS;
+    var unresolvedForwardNudgeTimer;
+    var unresolvedForwardNudgeRunning;
+    var init_mesh_reconcile_unresolved_forward = __esm2({
+      "src/mesh/mesh-reconcile-unresolved-forward.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_unresolved_forward_outbox();
+        init_mesh_events_coordinator();
+        init_mesh_events_utils();
+        init_mesh_event_trace();
+        init_dist();
+        init_mesh_reconcile_identity();
+        unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
+        MAX_FORWARD_REJECTIONS = 5;
+        UNRESOLVED_FORWARD_NUDGE_DELAY_MS = 250;
+        unresolvedForwardNudgeRunning = false;
+      }
+    });
     async function runMeshReconcileTick(components) {
       const localDaemonId = readNonEmptyString(loadConfig2().machineId) || void 0;
       const drainDaemonIds = resolveCoordinatorDaemonIds(components);
@@ -68667,7 +68665,7 @@ ${cleanBody}`;
       }
       {
         const nowMs = Date.now();
-        const due = lastDiskRetentionRunAt === void 0 || nowMs - lastDiskRetentionRunAt >= DISK_RETENTION_INTERVAL_MS;
+        const due = lastDiskRetentionRunAt === void 0 || nowMs - lastDiskRetentionRunAt >= DISK_RETENTION_INTERVAL_MS2;
         if (due) {
           lastDiskRetentionRunAt = nowMs;
           try {
@@ -68861,145 +68859,6 @@ ${cleanBody}`;
         drainAndInjectIntoTargets(meshId, drainDaemonIds, localDaemonId, targetCoordinators, "idle");
       }
     }
-    function holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId) {
-      const queuedAt = typeof pending.queuedAt === "number" ? pending.queuedAt : Date.now();
-      if (Date.now() - queuedAt <= STRICT_SESSION_MATCH_TTL_MS) {
-        try {
-          const requeued = requeueDrainedPendingMeshCoordinatorEvent(pending);
-          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})${requeued ? "" : " [WARN: not durably re-queued]"}`);
-          traceMeshEventDrop("strict_route_hold", {
-            taskId: pending.metadataEvent?.taskId,
-            sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
-            nodeId: pending.nodeId,
-            meshId,
-            event: pending.event
-          }, `coordinatorSession=${wantSession} not live durable=${requeued}`);
-        } catch (e) {
-          LOG2.warn("MeshReconcile", `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
-        }
-        return;
-      }
-      const finalSummary = readMeshCompletionSummary(pending.metadataEvent || {});
-      try {
-        appendLedgerEntry(meshId, {
-          kind: "event_held",
-          ...pending.nodeId ? { nodeId: pending.nodeId } : {},
-          payload: {
-            event: pending.event,
-            reason: "strict_route_expired",
-            recoverable: true,
-            targetCoordinatorSessionId: wantSession,
-            targetCoordinatorDaemonId: pending.targetCoordinatorDaemonId ?? null,
-            nodeLabel: pending.nodeLabel,
-            ...pending.workspace ? { workspace: pending.workspace } : {},
-            queuedAt,
-            ...finalSummary ? { finalSummary } : {}
-          }
-        });
-        LOG2.warn("MeshReconcile", `Strict route expire: coordinator session ${wantSession} never returned for mesh ${meshId} \u2014 recorded to ledger (recoverable), dropped (${pending.event})`);
-        traceMeshEventDrop("strict_route_expired", {
-          taskId: pending.metadataEvent?.taskId,
-          sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
-          nodeId: pending.nodeId,
-          meshId,
-          event: pending.event
-        }, `coordinatorSession=${wantSession} never returned`);
-      } catch (e) {
-        LOG2.warn("MeshReconcile", `Failed to ledger-expire strict-unmatched ${pending.event} for mesh ${meshId}: ${e?.message || e}`);
-      }
-    }
-    function scheduleUnresolvedForwardNudge(components) {
-      if (!components.dispatchMeshCommand) return;
-      if (unresolvedForwardNudgeTimer) return;
-      unresolvedForwardNudgeTimer = setTimeout(() => {
-        unresolvedForwardNudgeTimer = void 0;
-        if (unresolvedForwardNudgeRunning) return;
-        unresolvedForwardNudgeRunning = true;
-        void retryUnresolvedDelegateForwards(components).catch((e) => LOG2.warn("MeshReconcile", `Nudged unresolved-forward retry failed: ${e?.message || e}`)).finally(() => {
-          unresolvedForwardNudgeRunning = false;
-        });
-      }, UNRESOLVED_FORWARD_NUDGE_DELAY_MS);
-      if (typeof unresolvedForwardNudgeTimer.unref === "function") unresolvedForwardNudgeTimer.unref();
-    }
-    function clearUnresolvedForwardNudge() {
-      if (unresolvedForwardNudgeTimer) {
-        clearTimeout(unresolvedForwardNudgeTimer);
-        unresolvedForwardNudgeTimer = void 0;
-      }
-    }
-    async function retryUnresolvedDelegateForwards(components) {
-      const dispatchMeshCommand = components.dispatchMeshCommand;
-      if (!dispatchMeshCommand) return;
-      expireStaleUnresolvedDelegateForwards();
-      const entries = peekUnresolvedDelegateForwards();
-      if (entries.length === 0) {
-        if (unresolvedForwardRejectionCounts.size > 0) unresolvedForwardRejectionCounts.clear();
-        return;
-      }
-      const selfIds = resolveCoordinatorDaemonIds(components);
-      const isSelfCoordinatorId = (id) => selfIds.some((self) => daemonIdsEquivalent(self, id));
-      for (const entry of entries) {
-        const entryTraceCtx = {
-          taskId: entry.payload.taskId,
-          sessionId: readNonEmptyString(entry.payload.targetSessionId) || readNonEmptyString(entry.payload.sessionId),
-          nodeId: readNonEmptyString(entry.payload.nodeId),
-          event: readNonEmptyString(entry.payload.event)
-        };
-        if (isSelfCoordinatorId(entry.coordinatorDaemonId)) {
-          let localResult;
-          try {
-            traceMeshEventStage("forward_send", entryTraceCtx, `self \u2192 local router (${entry.coordinatorDaemonId})`);
-            localResult = handleMeshForwardEvent(components, entry.payload);
-          } catch (e) {
-            LOG2.warn("MeshReconcile", `Local route of self-addressed forward to ${entry.coordinatorDaemonId} threw: ${e?.message || e} \u2014 draining anyway to break the retry loop`);
-          }
-          ackUnresolvedDelegateForward(entry.id);
-          unresolvedForwardRejectionCounts.delete(entry.id);
-          if (localResult && localResult.success === false) {
-            LOG2.warn("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString(entry.payload.event)} rejected by local router (${readNonEmptyString(localResult.error) || "no reason"}) \u2014 drained to break the self-forward retry loop`);
-            traceMeshEventDrop("self_forward_local_rejected", entryTraceCtx, readNonEmptyString(localResult.error) || "no reason");
-          } else {
-            LOG2.info("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString(entry.payload.event)} routed via local router (coordinator ${entry.coordinatorDaemonId} is self) \u2014 drained`);
-          }
-          continue;
-        }
-        let pushPayload = entry.payload;
-        if (!readNonEmptyString(pushPayload.meshId)) {
-          const recoveredMeshId = resolveForwardEventMeshId(components, pushPayload);
-          if (recoveredMeshId) {
-            pushPayload = { ...pushPayload, meshId: recoveredMeshId };
-            traceMeshEventStage("forward_meshid_recovered", entryTraceCtx, `meshId=${recoveredMeshId}`);
-          }
-        }
-        let result;
-        try {
-          traceMeshEventStage("forward_send", entryTraceCtx, `retry \u2192 ${entry.coordinatorDaemonId}`);
-          result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", withStatusProbeMarker(pushPayload));
-        } catch (e) {
-          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
-          traceMeshEventDrop("retry_forward_failed", entryTraceCtx, e?.message || String(e));
-          continue;
-        }
-        if (result && result.success === false) {
-          const rejections = (unresolvedForwardRejectionCounts.get(entry.id) || 0) + 1;
-          unresolvedForwardRejectionCounts.set(entry.id, rejections);
-          const reason = readNonEmptyString(result.error) || "no reason";
-          if (rejections >= MAX_FORWARD_REJECTIONS) {
-            ackUnresolvedDelegateForward(entry.id);
-            unresolvedForwardRejectionCounts.delete(entry.id);
-            LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected ${rejections}x (${reason}) \u2014 dropping unresolved-delegate ${readNonEmptyString(entry.payload.event)} (sess=${readNonEmptyString(entry.payload.targetSessionId) || readNonEmptyString(entry.payload.sessionId) || "-"}) to stop the retry loop`);
-            traceMeshEventDrop("retry_forward_exhausted", entryTraceCtx, `${reason} (${rejections} rejections)`);
-          } else {
-            LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${reason}) \u2014 left queued (attempt ${rejections}/${MAX_FORWARD_REJECTIONS})`);
-            traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, reason);
-          }
-          continue;
-        }
-        ackUnresolvedDelegateForward(entry.id);
-        unresolvedForwardRejectionCounts.delete(entry.id);
-        LOG2.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
-      }
-    }
     function setupMeshReconcileLoop(components) {
       const intervalMs = resolveReconcileIntervalMs();
       let running = false;
@@ -69053,28 +68912,8 @@ ${cleanBody}`;
         }
       };
     }
-    var coordinatorModalParkState;
-    var DISK_RETENTION_INTERVAL_MS;
+    var DISK_RETENTION_INTERVAL_MS2;
     var lastDiskRetentionRunAt;
-    var heldEventLedgerRecorded;
-    var ASSIGNED_STRANDED_DEADLINE_MS;
-    var DELIVERED_NO_TURN_DEADLINE_MS;
-    var NATIVE_SOURCE_ACTIVITY_STALE_MS;
-    var ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS;
-    var RECLAIM_UNKNOWN_GRACE_TICKS;
-    var QUEUE_HOLD_HARD_DEADLINE_MS;
-    var queueHoldHardDeadlineAudited;
-    var deliveredNoTurnUnknownStreak;
-    var deliveredUnconsumedUnknownStreak;
-    var ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS;
-    var assignedIdleFinalAssistantSince;
-    var ZOMBIE_ASSIGNED_MIN_AGE_MS;
-    var STRICT_SESSION_MATCH_TTL_MS;
-    var unresolvedForwardRejectionCounts;
-    var MAX_FORWARD_REJECTIONS;
-    var UNRESOLVED_FORWARD_NUDGE_DELAY_MS;
-    var unresolvedForwardNudgeTimer;
-    var unresolvedForwardNudgeRunning;
     var init_mesh_reconcile_loop = __esm2({
       "src/mesh/mesh-reconcile-loop.ts"() {
         "use strict";
@@ -69083,52 +68922,29 @@ ${cleanBody}`;
         init_mesh_idle_reminder();
         init_logger();
         init_mesh_events_pending();
-        init_mesh_ledger();
         init_mesh_runtime_store();
         init_mesh_events_coordinator();
-        init_mesh_event_classify();
-        init_mesh_unresolved_forward_outbox();
         init_mesh_events_utils();
-        init_mesh_event_trace();
-        init_dist();
-        init_mesh_work_queue();
-        init_mesh_queue_assignment();
-        init_mesh_ledger();
-        init_mesh_events_stale();
+        init_mesh_unresolved_forward_outbox();
         init_mesh_reconcile_identity();
         init_mesh_reconcile_config();
         init_mesh_remote_event_pull();
-        init_transcript_evidence();
         init_mesh_disk_retention();
         init_mesh_worktree_retention();
         init_mesh_retention_config();
         init_mesh_completion_synthesis();
-        init_mesh_active_work();
         init_mesh_event_forwarding();
+        init_mesh_queue_assignment();
         init_mesh_turn_ledger();
-        init_mesh_turn_presentation();
+        init_mesh_reconcile_coordinator_drain();
+        init_mesh_reconcile_stranded_dispatch();
+        init_mesh_reconcile_unresolved_forward();
         init_mesh_reconcile_v2_backstop();
         init_mesh_reconcile_acked_hold();
-        coordinatorModalParkState = /* @__PURE__ */ new Map();
-        DISK_RETENTION_INTERVAL_MS = 60 * 60 * 1e3;
-        heldEventLedgerRecorded = /* @__PURE__ */ new Set();
-        ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
-        DELIVERED_NO_TURN_DEADLINE_MS = 15 * 6e4;
-        NATIVE_SOURCE_ACTIVITY_STALE_MS = 10 * 6e4;
-        ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS = 25e3;
-        RECLAIM_UNKNOWN_GRACE_TICKS = 3;
-        QUEUE_HOLD_HARD_DEADLINE_MS = 90 * 6e4;
-        queueHoldHardDeadlineAudited = /* @__PURE__ */ new Set();
-        deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
-        deliveredUnconsumedUnknownStreak = /* @__PURE__ */ new Map();
-        ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS = 8e3;
-        assignedIdleFinalAssistantSince = /* @__PURE__ */ new Map();
-        ZOMBIE_ASSIGNED_MIN_AGE_MS = 30 * 60 * 1e3;
-        STRICT_SESSION_MATCH_TTL_MS = 6e4;
-        unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
-        MAX_FORWARD_REJECTIONS = 5;
-        UNRESOLVED_FORWARD_NUDGE_DELAY_MS = 250;
-        unresolvedForwardNudgeRunning = false;
+        init_mesh_reconcile_coordinator_drain();
+        init_mesh_reconcile_stranded_dispatch();
+        init_mesh_reconcile_unresolved_forward();
+        DISK_RETENTION_INTERVAL_MS2 = 60 * 60 * 1e3;
       }
     });
     var mesh_events_exports = {};
@@ -78031,7 +77847,7 @@ ${lastSnapshot}`;
       getHostMemorySnapshot: () => getHostMemorySnapshot,
       getInstallOrigin: () => getInstallOrigin,
       getLastDisplayMessage: () => getLastDisplayMessage,
-      getLedgerDir: () => getLedgerDir,
+      getLedgerDir: () => getLedgerDir2,
       getLedgerSummary: () => getLedgerSummary,
       getLogInstanceTag: () => getLogInstanceTag,
       getLogLevel: () => getLogLevel,
@@ -79728,8 +79544,8 @@ ${lastSnapshot}`;
     var import_node_util4 = require("util");
     init_repo_mesh_types();
     init_mesh_config();
-    var import_fs12 = require("fs");
-    var import_path11 = require("path");
+    var import_fs11 = require("fs");
+    var import_path10 = require("path");
     init_refine_config();
     init_worktree_bootstrap_config();
     init_change_impact_config();
@@ -79748,22 +79564,22 @@ ${lastSnapshot}`;
       "requirements.txt"
     ];
     function writeConfigFile(workspace, relativePath, config2) {
-      const target = (0, import_path11.join)(workspace, relativePath);
-      (0, import_fs12.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
-      (0, import_fs12.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
+      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)}
 `, "utf-8");
       return target;
     }
     function suggestMeshWorktreeBootstrapConfig(workspace) {
       const commands = [];
-      const hasPackageJson = (0, import_fs12.existsSync)((0, import_path11.join)(workspace, "package.json"));
-      const hasNpmLock = (0, import_fs12.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
+      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"));
       if (hasPackageJson) {
         commands.push(
           hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
         );
       }
-      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative8) => (0, import_fs12.existsSync)((0, import_path11.join)(workspace, relative8)));
+      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative8) => (0, import_fs11.existsSync)((0, import_path10.join)(workspace, relative8)));
       if (!commands.length) {
         return { commands, staleInputs };
       }
@@ -79862,7 +79678,7 @@ ${lastSnapshot}`;
     }
     function applyConfigSuggestion(input) {
       const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-      const absolute = (0, import_path11.join)(workspace, relativePath);
+      const absolute = (0, import_path10.join)(workspace, relativePath);
       if (existing !== void 0 && !overwrite) {
         return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
       }
@@ -80389,8 +80205,8 @@ ${lastSnapshot}`;
       };
     }
     init_mesh_ledger();
-    var import_fs14 = require("fs");
-    var import_path13 = require("path");
+    var import_fs13 = require("fs");
+    var import_path12 = require("path");
     init_config();
     init_usage_normalize();
     var USAGE_DIR_NAME = "mesh-usage";
@@ -80405,13 +80221,13 @@ ${lastSnapshot}`;
       lastEvictedAt: 0
     };
     function getUsageDir() {
-      const dir = (0, import_path13.join)(getConfigDir2(), USAGE_DIR_NAME);
-      if (!(0, import_fs14.existsSync)(dir)) (0, import_fs14.mkdirSync)(dir, { recursive: true, mode: 448 });
+      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 });
       return dir;
     }
     function getUsagePath(meshId) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path13.join)(getUsageDir(), `${safe}.json`);
+      return (0, import_path12.join)(getUsageDir(), `${safe}.json`);
     }
     function emptyFile(meshId) {
       return { version: 1, meshId, sessions: {} };
@@ -80421,7 +80237,7 @@ ${lastSnapshot}`;
       const path54 = getUsagePath(meshId);
       let stat2;
       try {
-        const s2 = (0, import_fs14.statSync)(path54);
+        const s2 = (0, import_fs13.statSync)(path54);
         stat2 = { mtimeMs: s2.mtimeMs, size: s2.size };
       } catch {
         usageFileCache.delete(path54);
@@ -80432,7 +80248,7 @@ ${lastSnapshot}`;
         return cached5.file;
       }
       try {
-        const parsed = JSON.parse((0, import_fs14.readFileSync)(path54, "utf-8"));
+        const parsed = JSON.parse((0, import_fs13.readFileSync)(path54, "utf-8"));
         if (!parsed || typeof parsed !== "object" || !parsed.sessions) {
           usageFileCache.delete(path54);
           return emptyFile(meshId);
@@ -80447,19 +80263,19 @@ ${lastSnapshot}`;
     function writeUsageFile(meshId, file2) {
       const path54 = getUsagePath(meshId);
       const tmp = `${path54}.tmp`;
-      (0, import_fs14.writeFileSync)(tmp, JSON.stringify(file2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs13.writeFileSync)(tmp, JSON.stringify(file2), { encoding: "utf-8", mode: 384 });
       try {
-        (0, import_fs14.renameSync)(tmp, path54);
+        (0, import_fs13.renameSync)(tmp, path54);
       } catch (e) {
         try {
-          (0, import_fs14.unlinkSync)(tmp);
+          (0, import_fs13.unlinkSync)(tmp);
         } catch {
         }
         usageFileCache.delete(path54);
         throw e;
       }
       try {
-        const s2 = (0, import_fs14.statSync)(path54);
+        const s2 = (0, import_fs13.statSync)(path54);
         usageFileCache.set(path54, { file: file2, mtimeMs: s2.mtimeMs, size: s2.size });
       } catch {
         usageFileCache.delete(path54);
@@ -80840,7 +80656,7 @@ ${lastSnapshot}`;
     init_state_store();
     var import_child_process5 = require("child_process");
     var import_util22 = require("util");
-    var import_fs18 = require("fs");
+    var import_fs17 = require("fs");
     var import_os3 = require("os");
     var path20 = __toESM2(require("path"));
     var fs12 = __toESM2(require("fs"));
@@ -80917,7 +80733,7 @@ ${lastSnapshot}`;
       if (path20.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
         const candidate = trimmed.startsWith("~") ? path20.join((0, import_os3.homedir)(), trimmed.slice(1)) : trimmed;
         const resolved = path20.isAbsolute(candidate) ? candidate : path20.resolve(candidate);
-        return (0, import_fs18.existsSync)(resolved) ? resolved : null;
+        return (0, import_fs17.existsSync)(resolved) ? resolved : null;
       }
       const isWin = (0, import_os3.platform)() === "win32";
       const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -80927,8 +80743,8 @@ ${lastSnapshot}`;
         for (const ext of exes) {
           const fullPath = path20.join(p, trimmed + ext);
           try {
-            if ((0, import_fs18.existsSync)(fullPath)) {
-              const stat2 = (0, import_fs18.statSync)(fullPath);
+            if ((0, import_fs17.existsSync)(fullPath)) {
+              const stat2 = (0, import_fs17.statSync)(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -80946,9 +80762,9 @@ ${lastSnapshot}`;
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs18.existsSync)(resolved)) return resolved;
+          if ((0, import_fs17.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs18.existsSync)(normalized)) return normalized;
+          if ((0, import_fs17.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -80962,7 +80778,7 @@ ${lastSnapshot}`;
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os28 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs18.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs17.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os28 === "win32") {
           const { dirname: dirname22 } = await import("path");
@@ -80975,7 +80791,7 @@ ${lastSnapshot}`;
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs18.existsSync)(c)) {
+            if ((0, import_fs17.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -90470,9 +90286,9 @@ ${effect.notification.body || ""}`.trim();
       }
       return false;
     }
-    function listOwnedNodeProcesses(options) {
+    function inspectOwnedNodeProcesses(options) {
       const platform10 = options.platform ?? process.platform;
-      if (platform10 !== "win32") return [];
+      if (platform10 !== "win32") return { processes: [], probeFailed: false, probeFailureReason: null };
       const exec7 = options.execFileSync ?? defaultExecFileSync();
       const prefixes = options.prefixes.map((p) => normalizeWindowsPath(p));
       const exclude = new Set((options.excludePids ?? []).filter((n) => Number.isFinite(n) && n > 0));
@@ -90491,21 +90307,33 @@ ${effect.notification.body || ""}`.trim();
           const parsed = JSON.parse(out);
           pids = Array.isArray(parsed) ? parsed : [parsed];
         }
-      } catch {
-        return [];
+      } catch (error48) {
+        return {
+          processes: [],
+          probeFailed: true,
+          probeFailureReason: `node process enumeration failed: ${errorText(error48)}`
+        };
       }
       const results = [];
+      let unreadable = 0;
       for (const pid of pids) {
         if (!Number.isFinite(pid) || pid <= 0 || exclude.has(pid)) continue;
         const commandLine = getProcessCommandLine(pid, { platform: platform10, execFileSync: exec7 });
-        if (!commandLine) continue;
+        if (!commandLine) {
+          unreadable += 1;
+          continue;
+        }
         const lower = commandLine.toLowerCase();
         const underPrefix = prefixes.some((prefix) => lower.includes(prefix));
         if (!underPrefix) continue;
         if (markers.length > 0 && !markers.some((marker) => lower.includes(marker))) continue;
         results.push({ pid, commandLine });
       }
-      return results;
+      return {
+        processes: results,
+        probeFailed: unreadable > 0,
+        probeFailureReason: unreadable > 0 ? `${unreadable} node process(es) had an unreadable command line; their prefix could not be determined` : null
+      };
     }
     async function stopOwnedProcesses(options) {
       const waitMs = options.waitMs ?? 15e3;
@@ -90525,11 +90353,18 @@ ${effect.notification.body || ""}`.trim();
       return { stopped: options.processes.length - survivors.length, survivors };
     }
     async function stopOwnedProcessesForPrefixes(options) {
-      const processes = listOwnedNodeProcesses(options);
-      if (processes.length === 0) return { stopped: 0, survivors: [] };
-      options.log?.(`Stopping ${processes.length} owned process(es) under prefixes: ${options.prefixes.join(", ")}`);
+      const sweep = inspectOwnedNodeProcesses(options);
+      if (sweep.probeFailed) {
+        options.log?.(
+          `Process-inspection probe could not verify prefixes ${options.prefixes.join(", ")}: ${sweep.probeFailureReason}. Treating the result as UNVERIFIED rather than clean.`
+        );
+      }
+      if (sweep.processes.length === 0) {
+        return { stopped: 0, survivors: [], probeFailed: sweep.probeFailed, probeFailureReason: sweep.probeFailureReason };
+      }
+      options.log?.(`Stopping ${sweep.processes.length} owned process(es) under prefixes: ${options.prefixes.join(", ")}`);
       const result = await stopOwnedProcesses({
-        processes,
+        processes: sweep.processes,
         waitMs: options.waitMs,
         platform: options.platform,
         execFileSync: options.execFileSync
@@ -90537,10 +90372,11 @@ ${effect.notification.body || ""}`.trim();
       if (result.survivors.length > 0) {
         options.log?.(`Could not stop ${result.survivors.length} owned process(es): ${result.survivors.map((s2) => s2.pid).join(", ")}`);
       }
-      return result;
+      return { ...result, probeFailed: sweep.probeFailed, probeFailureReason: sweep.probeFailureReason };
     }
     var POINTER_NAME = ".adhdev-current";
     var STABLE_FILES = [POINTER_NAME, "adhdev.cmd", "adhdev.ps1", "adhdev"];
+    var REAL_PLATFORM = process.platform;
     function resolveDefaultHealthPort(env2 = process.env) {
       return getTrackIdentity(resolveBuildTrack(env2)).defaultPort;
     }
@@ -90798,7 +90634,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
     function restoreStableFiles(snapshots, layout) {
       const shims = stableShimContents();
       for (const [target, snapshot] of snapshots) {
-        if (snapshot.exists && snapshot.data) {
+        if (snapshot.exists && snapshot.data && snapshot.data.length > 0) {
           atomicWrite(target, snapshot.data.toString("binary"), "binary");
           continue;
         }
@@ -90806,7 +90642,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
         if (name === "adhdev.cmd" || name === "adhdev.ps1" || name === "adhdev") {
           atomicWrite(target, shims[name].content, shims[name].encoding);
         } else if (name === POINTER_NAME) {
-          if (layout.activeVersionName) atomicWrite(target, layout.activeVersionName, "ascii");
+          if (layout.activeVersionName) writePointerVerified(target, layout.activeVersionName);
           else try {
             fs19.unlinkSync(target);
           } catch {
@@ -90819,12 +90655,30 @@ exec "${portableNode}" "${cliEntry}" "$@"
         }
       }
     }
+    function writePointerVerified(pointerPath, versionName) {
+      if (!versionName || !versionName.trim()) {
+        throw new Error(`refusing to write an empty version pointer to ${pointerPath}`);
+      }
+      atomicWrite(pointerPath, versionName, "ascii");
+      if (REAL_PLATFORM !== "win32") return;
+      let readback = "";
+      try {
+        readback = fs19.readFileSync(pointerPath, "utf8").trim();
+      } catch (error48) {
+        throw new Error(`version pointer readback failed for ${pointerPath}: ${error48?.message || String(error48)}`);
+      }
+      if (readback !== versionName.trim()) {
+        throw new Error(
+          `version pointer verification failed for ${pointerPath}: expected "${versionName.trim()}", read "${readback}"`
+        );
+      }
+    }
     function publishStableShimsAndPointer(layout, versionName) {
       const shims = stableShimContents();
       for (const name of ["adhdev.cmd", "adhdev.ps1", "adhdev"]) {
         atomicWrite(path25.join(layout.stablePrefix, name), shims[name].content, shims[name].encoding);
       }
-      atomicWrite(layout.pointerPath, versionName, "ascii");
+      writePointerVerified(layout.pointerPath, versionName);
     }
     function removeFailedStagedPrefix(stagedPrefix, layout, log) {
       try {
@@ -91042,6 +90896,12 @@ exec "${portableNode}" "${cliEntry}" "$@"
           log?.(`Skipping cleanup of ${candidate}: ${stopResult.survivors.length} owned process(es) could not be stopped`);
           continue;
         }
+        if (stopResult.probeFailed) {
+          log?.(
+            `Skipping cleanup of ${candidate}: could not verify that no process is running from it (${stopResult.probeFailureReason}). Refusing to delete an install directory on an unverified sweep.`
+          );
+          continue;
+        }
         removeInactivePrefix(candidate, log);
       }
     }
@@ -91240,29 +91100,73 @@ exec "${portableNode}" "${cliEntry}" "$@"
       }
       return String(execNpmCommandSync(args, execOptions, surface)).trim();
     }
-    function isManagedSessionHostPid(pid) {
+    function classifySessionHostPid(pid) {
       const commandLine = getProcessCommandLine(pid);
-      return !!commandLine && /session-host-daemon/i.test(commandLine);
+      if (!commandLine) return "unknown";
+      return /session-host-daemon/i.test(commandLine) ? "managed" : "unrelated";
     }
     async function stopSessionHostProcesses(appName, configDir = getConfigDir2()) {
       const pidFile = path26.join(configDir, `${appName}-session-host.pid`);
+      const outcome = { pid: null, identity: null, stopped: false, survived: false };
       let killedPid = null;
+      let keepPidFile = false;
       try {
         if (fs20.existsSync(pidFile)) {
           const pid = Number.parseInt(fs20.readFileSync(pidFile, "utf8").trim(), 10);
-          if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
-            if (killProcess(pid)) killedPid = pid;
+          if (Number.isFinite(pid) && pid !== process.pid) {
+            outcome.pid = pid;
+            const identity = classifySessionHostPid(pid);
+            outcome.identity = identity;
+            if (identity === "unrelated") {
+              appendUpgradeLog(
+                `Session-host pidfile names pid ${pid}, which is positively identified as an unrelated process; treating the pidfile as stale and not killing it.`,
+                configDir
+              );
+            } else {
+              if (identity === "unknown") {
+                appendUpgradeLog(
+                  `Could not read the command line of session-host pid ${pid} (process-inspection unavailable). The pidfile is this daemon's own record, so the pid is treated as ours and stopped \u2014 a stale host surviving an upgrade breaks every create_session with a conpty.node load failure.`,
+                  configDir
+                );
+              }
+              if (killProcess(pid)) killedPid = pid;
+            }
           }
         }
       } catch {
-      } finally {
+      }
+      if (killedPid !== null) {
+        outcome.stopped = await waitForPidExit(killedPid, 15e3);
+        if (!outcome.stopped) {
+          outcome.survived = true;
+          appendUpgradeLog(
+            `Session-host pid ${killedPid} did not exit within 15000ms of the stop request.`,
+            configDir
+          );
+        }
+      } else if (outcome.pid !== null && outcome.identity !== "unrelated") {
+        outcome.survived = isPidAlive(outcome.pid);
+      }
+      keepPidFile = outcome.survived;
+      if (!keepPidFile) {
         try {
           fs20.unlinkSync(pidFile);
         } catch {
         }
+      } else {
+        appendUpgradeLog(
+          `Keeping ${pidFile} so the remaining upgrade guards can still see the surviving host.`,
+          configDir
+        );
       }
-      if (killedPid !== null) {
-        await waitForPidExit(killedPid, 15e3);
+      return outcome;
+    }
+    function isPidAlive(pid) {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error48) {
+        return error48?.code === "EPERM";
       }
     }
     var LOCKED_NATIVE_ADDON_BASENAMES = ["conpty.node", "ghostty-vt.dll"];
@@ -91506,7 +91410,17 @@ ${marker}`,
         await waitForPidExit(payload.parentPid, 15e3);
       }
       if (process.platform === "win32" || payload.killSessionHost === true) {
-        await stopSessionHostProcesses(sessionHostAppName);
+        const hostStop = await stopSessionHostProcesses(sessionHostAppName);
+        if (process.platform === "win32" && hostStop.survived && hostStop.pid !== null) {
+          const message = `Cannot upgrade: the session-host process (pid ${hostStop.pid}) is still running and could not be stopped. Upgrading now would delete the install it is running from and break every new session.`;
+          emitUpgradeFailureNotice([
+            message,
+            "To recover, stop it and retry the update:",
+            `  Stop-Process -Id ${hostStop.pid} -Force`,
+            `  ${IDENTITY.binaryName} update`
+          ], getConfigDir2(), { targetVersion: payload.targetVersion });
+          throw new Error(message);
+        }
       } else {
         appendUpgradeLog("POSIX \u2014 session-host left running (survives upgrade; sessions rebind on next boot)");
       }
@@ -92664,7 +92578,7 @@ ${marker}`,
     var os20 = __toESM2(require("os"));
     var path35 = __toESM2(require("path"));
     var crypto6 = __toESM2(require("crypto"));
-    var import_fs19 = require("fs");
+    var import_fs18 = require("fs");
     var import_child_process11 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
@@ -101411,7 +101325,7 @@ ${rawInput}` : rawInput;
       const trimmed = command.trim();
       if (!trimmed) return false;
       if (isExplicitCommand(trimmed)) {
-        return (0, import_fs19.existsSync)(expandExecutable(trimmed));
+        return (0, import_fs18.existsSync)(expandExecutable(trimmed));
       }
       try {
         (0, import_child_process11.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -101556,10 +101470,10 @@ ${rawInput}` : rawInput;
     }
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path35.join(os20.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-      (0, import_fs19.mkdirSync)(baseDir, { recursive: true });
+      (0, import_fs18.mkdirSync)(baseDir, { recursive: true });
       const workspaceHash = shortHash(path35.resolve(workspace || os20.tmpdir()));
       const filePath = path35.join(baseDir, `${workspaceHash}.json`);
-      (0, import_fs19.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+      (0, import_fs18.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
     }
     function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -108884,7 +108798,7 @@ ${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 { mkdirSync: mkdirSync29, writeFileSync: writeFileSync31 } = await import("fs");
+          const { mkdirSync: mkdirSync29, writeFileSync: writeFileSync30 } = await import("fs");
           const { dirname: dirname22, join: join62 } = await import("path");
           const scaffold = buildMeshJsonConfigScaffold2(mesh);
           const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
@@ -108926,7 +108840,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             };
           }
           mkdirSync29(dirname22(absolutePath), { recursive: true });
-          writeFileSync31(absolutePath, `${scaffoldJson}
+          writeFileSync30(absolutePath, `${scaffoldJson}
 `, "utf-8");
           return {
             success: true,
@@ -108995,7 +108909,7 @@ ${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: existsSync62, readFileSync: readFileSync53, mkdirSync: mkdirSync29, writeFileSync: writeFileSync31 } = await import("fs");
+          const { existsSync: existsSync62, readFileSync: readFileSync53, mkdirSync: mkdirSync29, writeFileSync: writeFileSync30 } = await import("fs");
           const { dirname: dirname22, join: join62 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
@@ -109061,7 +108975,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             };
           }
           mkdirSync29(dirname22(absolutePath), { recursive: true });
-          writeFileSync31(absolutePath, serialized, "utf-8");
+          writeFileSync30(absolutePath, serialized, "utf-8");
           return {
             success: true,
             written: true,
@@ -109550,11 +109464,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let node;
           const { migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           if (meshRecord.inline) {
-            const { randomUUID: randomUUID16 } = await import("crypto");
+            const { randomUUID: randomUUID17 } = await import("crypto");
             const clonedPolicy = { ...sourceNode.policy || {} };
             migrateProviderRolesToSlots2(clonedPolicy);
             node = {
-              id: `node_${randomUUID16().replace(/-/g, "")}`,
+              id: `node_${randomUUID17().replace(/-/g, "")}`,
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
               daemonId: sourceNode.daemonId,
@@ -110760,7 +110674,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         return { success: true };
       }
     };
-    var import_path17 = require("path");
+    var import_path16 = require("path");
     var fs422 = __toESM2(require("fs"));
     init_logger();
     init_mesh_host_ownership();
@@ -111041,7 +110955,7 @@ ${ptyResult.output.slice(-2e3)}`);
               };
             }
             if (cliType === "codex-cli") {
-              const repoMcpConfigPath = (0, import_path17.join)(workspace, ".mcp.json");
+              const repoMcpConfigPath = (0, import_path16.join)(workspace, ".mcp.json");
               if (fs422.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
@@ -111194,7 +111108,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync62, readFileSync: readFileSync53, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync29 } = await import("fs");
+          const { existsSync: existsSync62, readFileSync: readFileSync53, writeFileSync: writeFileSync30, copyFileSync: copyFileSync3, mkdirSync: mkdirSync29 } = await import("fs");
           const { dirname: dirname22 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -111269,7 +111183,7 @@ ${ptyResult.output.slice(-2e3)}`);
             }
           };
           try {
-            writeFileSync31(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+            writeFileSync30(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
           } catch (error48) {
             const message = `Could not write MCP config for automatic setup: ${error48?.message || error48}`;
             LOG2.error("MeshCoordinator", message);
@@ -112448,7 +112362,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_git_status();
     init_refine_config();
     init_worktree_bootstrap_config();
-    var import_path18 = require("path");
+    var import_path17 = require("path");
     var fs45 = __toESM2(require("fs"));
     var import_node_child_process9 = require("child_process");
     init_resolve_executable();
@@ -112474,13 +112388,13 @@ ${tail}`;
       const missingDependencyFailure = !spawnResolutionFailed && !outputLimitExceeded && /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
       return { outputLimitExceeded, missingDependencyFailure };
     }
-    var REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
+    var REFINE_VALIDATION_LOG_DIR = (0, import_path17.join)(".adhdev", "logs");
     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_path17.join)(workspace, REFINE_VALIDATION_LOG_DIR);
         fs45.mkdirSync(dir, { recursive: true });
         const stamp = now().toISOString().replace(/[:.]/g, "-");
-        const file2 = (0, import_path18.join)(dir, `refine-${stamp}-${index}.log`);
+        const file2 = (0, import_path17.join)(dir, `refine-${stamp}-${index}.log`);
         const asText = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
         const shown = candidate.displayCommand || [candidate.command, ...candidate.args || []].join(" ");
         fs45.writeFileSync(
@@ -112724,7 +112638,7 @@ ${e?.stderr || ""}`
             } catch {
               continue;
             }
-            const submoduleRepo = (0, import_path18.join)(repoRoot, p);
+            const submoduleRepo = (0, import_path17.join)(repoRoot, p);
             let fastForward;
             let reachableFromOriginMain;
             if (branchCommit) {
@@ -113031,7 +112945,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path54);
         const branchCommit = readTreeObject(repoRoot, branchHead, path54);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path54), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path17.resolve)(repoRoot, path54), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -113040,8 +112954,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path54);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path54);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path54);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path54), baseCommit);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path54);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path54), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -113106,9 +113020,9 @@ ${mergeTreeErr?.stderr || ""}`;
       for (const path54 of changed) {
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path54);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path54);
-        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path54);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path54);
         if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path54), baseCommit);
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path54), baseCommit);
         }
         if (!baseCommit || !branchCommit || !isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit)) {
           gitlinks.push({ path: path54, baseCommit, branchCommit, action: "skipped_not_diverged" });
@@ -113222,7 +113136,7 @@ ${mergeTreeErr?.stderr || ""}`;
         for (const p of conflicts) {
           const commit = resolveByPath.get(p);
           try {
-            (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path18.resolve)(worktreeRoot, p), stdio: "ignore" });
+            (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
           } catch {
           }
           try {
@@ -113244,7 +113158,7 @@ ${mergeTreeErr?.stderr || ""}`;
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path54) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path54);
         const branchCommit = readTreeObject(repoRoot, branchHead, path54);
-        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path54);
+        const submoduleRepoPath = (0, import_path17.resolve)(repoRoot, path54);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
         return { path: path54, baseCommit, branchCommit, fastForward };
       });
@@ -113299,7 +113213,7 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path54) => `160000 commit ${placeholderCommit}	${path54}`).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_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process9.execFileSync)(GIT3, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -113374,7 +113288,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_path17.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_process9.execFileSync)(GIT3, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -113518,7 +113432,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_path17.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -113547,7 +113461,7 @@ ${mergeTreeErr?.stderr || ""}`;
                 try {
                   const imported = await importCommitFromWorktreeSubmodule(
                     submodulePath,
-                    (0, import_path18.resolve)(options.worktreeRoot, gitlink.path),
+                    (0, import_path17.resolve)(options.worktreeRoot, gitlink.path),
                     gitlink.commit
                   );
                   if (imported) {
@@ -113767,13 +113681,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path18.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+        const command = (0, import_path17.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 (!fs45.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
-        if (fs45.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) => fs45.existsSync((0, import_path18.join)(cwd, lock)));
+        if (!fs45.existsSync((0, import_path17.join)(cwd, "package.json"))) return false;
+        if (fs45.existsSync((0, import_path17.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs45.existsSync((0, import_path17.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -113840,7 +113754,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_path17.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           const resolvedCommand = resolveWin32Executable(candidate.command);
           const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -113873,7 +113787,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_path17.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)) {
@@ -115878,7 +115792,7 @@ ${e?.stderr || ""}`;
     }
     var fs46 = __toESM2(require("fs"));
     var import_node_os2 = require("os");
-    var import_path19 = require("path");
+    var import_path18 = require("path");
     init_logger();
     init_dist();
     init_mesh_node_identity();
@@ -115888,7 +115802,7 @@ ${e?.stderr || ""}`;
     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_path19.join)((0, import_path19.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path18.join)((0, import_path18.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -115912,8 +115826,8 @@ ${e?.stderr || ""}`;
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os2.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path19.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path19.sep);
+        const trackWorktreesDir = (0, import_path18.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path18.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -115983,7 +115897,7 @@ ${e?.stderr || ""}`;
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path19.resolve)(value);
+        const resolved = (0, import_path18.resolve)(value);
         try {
           return fs46.realpathSync(resolved);
         } catch {
@@ -116079,7 +115993,7 @@ ${e?.stderr || ""}`;
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path19.resolve)(value);
+        const resolved = (0, import_path18.resolve)(value);
         try {
           return fs46.realpathSync(resolved);
         } catch {
@@ -116719,7 +116633,7 @@ ${e?.stderr || ""}`;
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path20 = require("path");
+    var import_path19 = require("path");
     var fs47 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
@@ -116760,13 +116674,13 @@ ${e?.stderr || ""}`;
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path20.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path19.join)((0, import_os5.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path20.join)(sourceHome, "config.yaml");
+      const sourceConfigPath = (0, import_path19.join)(sourceHome, "config.yaml");
       if (!fs47.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path20.resolve)(sourceConfigPath) === (0, import_path20.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path19.resolve)(sourceConfigPath) === (0, import_path19.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs47.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -116800,10 +116714,10 @@ ${e?.stderr || ""}`;
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path20.resolve)(sourceHome) === (0, import_path20.resolve)(targetHome)) return;
+      if ((0, import_path19.resolve)(sourceHome) === (0, import_path19.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path20.join)(sourceHome, fileName);
-        const targetPath = (0, import_path20.join)(targetHome, fileName);
+        const sourcePath = (0, import_path19.join)(sourceHome, fileName);
+        const targetPath = (0, import_path19.join)(targetHome, fileName);
         if (!fs47.existsSync(sourcePath)) continue;
         try {
           fs47.copyFileSync(sourcePath, targetPath);
@@ -121811,7 +121725,7 @@ async (params) => {
       const pid = ctx.autoImplProcess?.pid;
       return typeof pid === "number" && pid > 0 ? pid : null;
     }
-    function isPidAlive(pid) {
+    function isPidAlive2(pid) {
       try {
         process.kill(pid, 0);
         return true;
@@ -121822,7 +121736,7 @@ async (params) => {
     function clearStaleAutoImplState(ctx, reason) {
       if (!ctx.autoImplStatus.running && !ctx.autoImplProcess) return;
       const pid = getAutoImplPid(ctx);
-      if (pid && isPidAlive(pid)) return;
+      if (pid && isPidAlive2(pid)) return;
       ctx.log(`Clearing stale auto-implement state: ${reason}${pid ? ` (pid ${pid})` : ""}`);
       ctx.autoImplProcess = null;
       ctx.autoImplStatus.running = false;
@@ -124986,7 +124900,7 @@ data: ${JSON.stringify(msg.data)}
           }
         }
       }
-      function isPidAlive2(pid) {
+      function isPidAlive3(pid) {
         try {
           process.kill(pid, 0);
           return true;
@@ -125007,7 +124921,7 @@ data: ${JSON.stringify(msg.data)}
                 stopped = killPid(pid) || stopped;
               }
               const provenUnrelated = !managed && options.identifiesPid?.(pid) === true;
-              keepPidFile = !provenUnrelated && isPidAlive2(pid);
+              keepPidFile = !provenUnrelated && isPidAlive3(pid);
               if (keepPidFile) {
                 LOG2.warn(
                   "SessionHost",
@@ -125030,6 +124944,39 @@ data: ${JSON.stringify(msg.data)}
         }
         return stopped;
       }
+      async function stopHostRunningFromForeignEntry() {
+        let currentEntry;
+        try {
+          currentEntry = resolveEntry();
+        } catch {
+          return;
+        }
+        const client = new import_session_host_core15.SessionHostClient({ endpoint: getEndpoint() });
+        let reported;
+        try {
+          await client.connect();
+          const response = await client.request({
+            type: "get_host_diagnostics",
+            payload: { includeSessions: false }
+          });
+          if (!response.success || !response.result) return;
+          const value = response.result.hostEntryPath;
+          reported = typeof value === "string" && value.trim() ? value : void 0;
+        } catch {
+          return;
+        } finally {
+          await client.close().catch(() => {
+          });
+        }
+        if (!reported) return;
+        if (pathsEquivalent(reported, currentEntry)) return;
+        const reportedExists = fs54.existsSync(reported);
+        LOG2.warn(
+          "SessionHost",
+          `Reachable session-host reports it is running from ${reported}${reportedExists ? "" : " (which no longer exists)"}, but this install runs from ${currentEntry}. That host would fail every create_session loading node-pty from its own prefix; stopping it so a current one is spawned in its place.`
+        );
+        stopManagedSessionHostProcess();
+      }
       async function ensureReady() {
         options.beforeEnsureReady?.();
         if (process.platform === "win32") {
@@ -125060,6 +125007,9 @@ data: ${JSON.stringify(msg.data)}
             }
           }
         }
+        if (process.platform === "win32") {
+          await stopHostRunningFromForeignEntry();
+        }
         if (process.platform === "win32") {
           try {
             verifyConptyPrebuildBeforeSpawn(resolveEntry());
@@ -125393,6 +125343,136 @@ data: ${JSON.stringify(msg.data)}
     init_config();
     init_mesh_events();
     init_mesh_reconcile_loop();
+    var import_fs19 = require("fs");
+    var import_path20 = require("path");
+    var import_crypto14 = require("crypto");
+    init_logger();
+    init_mesh_ledger();
+    init_mesh_runtime_store();
+    init_mesh_events_pending();
+    var PENDING_EVENTS_SUFFIX = ".pending-events.jsonl";
+    function isPendingEventsFile(name) {
+      return name.endsWith(PENDING_EVENTS_SUFFIX) && name.length > PENDING_EVENTS_SUFFIX.length;
+    }
+    function parsePendingEventsFile(content) {
+      const events = [];
+      let skipped = 0;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          skipped++;
+          continue;
+        }
+        const event = parsed;
+        if (!event || typeof event !== "object" || typeof event.meshId !== "string" || !event.meshId || typeof event.event !== "string" || !event.event) {
+          skipped++;
+          continue;
+        }
+        events.push(event);
+      }
+      return { events, skipped };
+    }
+    function importOneEvent(event) {
+      try {
+        const fingerprint = buildPendingEventFingerprint(event);
+        MeshRuntimeStore.getInstance().insertPendingEvent({
+          id: (0, import_crypto14.randomUUID)(),
+          meshId: event.meshId,
+          coordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+          event: event.event,
+          payload: event,
+          fingerprint: fingerprint || null,
+          queuedAt: typeof event.queuedAt === "number" ? event.queuedAt : Date.now(),
+          protocolVersion: event.protocolVersion ?? null,
+          eventId: event.eventId ?? null,
+          scope: event.scope ?? null,
+          dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
+          intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
+        });
+        return true;
+      } catch (e) {
+        LOG2.warn("MeshEvents", `Pending-events migration: failed to import ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+        return false;
+      }
+    }
+    function migratePendingEventsJsonlToSqlite() {
+      const result = {
+        filesScanned: 0,
+        eventsImported: 0,
+        linesSkipped: 0,
+        filesRemoved: 0,
+        filesRetained: 0
+      };
+      let dir;
+      try {
+        dir = getLedgerDir2();
+      } catch {
+        return result;
+      }
+      if (!(0, import_fs19.existsSync)(dir)) return result;
+      let names;
+      try {
+        names = (0, import_fs19.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 path54 = (0, import_path20.join)(dir, name);
+        result.filesScanned++;
+        const claimed = `${path54}.migrating`;
+        try {
+          (0, import_fs19.renameSync)(path54, claimed);
+        } catch {
+          continue;
+        }
+        let content;
+        try {
+          content = (0, import_fs19.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_fs19.renameSync)(claimed, path54);
+          } catch {
+          }
+          result.filesRetained++;
+          continue;
+        }
+        const { events, skipped } = parsePendingEventsFile(content);
+        result.linesSkipped += skipped;
+        let allImported = true;
+        for (const event of events) {
+          if (importOneEvent(event)) result.eventsImported++;
+          else allImported = false;
+        }
+        if (!allImported) {
+          try {
+            (0, import_fs19.renameSync)(claimed, path54);
+          } catch {
+          }
+          result.filesRetained++;
+          continue;
+        }
+        try {
+          (0, import_fs19.unlinkSync)(claimed);
+          result.filesRemoved++;
+        } catch (e) {
+          LOG2.warn("MeshEvents", `Pending-events migration: imported ${name} but could not unlink it: ${e?.message || e}`);
+          result.filesRemoved++;
+        }
+      }
+      if (result.filesScanned > 0) {
+        LOG2.info(
+          "MeshEvents",
+          `Pending-events JSONL migration: imported ${result.eventsImported} event(s) from ${result.filesScanned} legacy file(s) (removed ${result.filesRemoved}, retained ${result.filesRetained}, skipped ${result.linesSkipped} unreadable line(s))`
+        );
+      }
+      return result;
+    }
     init_refresh();
     init_mesh_runtime_store();
     init_coordinator_registry();
@@ -125694,6 +125774,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         statusInstanceId: config2.statusInstanceId
       };
       setupMeshEventForwarding(components);
+      try {
+        migratePendingEventsJsonlToSqlite();
+      } catch {
+      }
       components.meshReconcileLoop = setupMeshReconcileLoop(components);
       components.quotaRefreshLoop = setupQuotaRefreshLoop(components);
       components.quotaEventRefresh = setupQuotaEventRefresh(components);