@adhdev/daemon-standalone 1.0.58-rc.1 → 1.0.58-rc.3

package/dist/index.js

@@ -3591,14 +3591,77 @@ var require_dist = __commonJS({
         }
       };
     }
+    var establishedSockets2 = /* @__PURE__ */ new WeakSet();
     var SessionHostClient2 = class {
       endpoint;
       socket = null;
       requestWaiters = /* @__PURE__ */ new Map();
       eventListeners = /* @__PURE__ */ new Set();
+      disconnectListeners = /* @__PURE__ */ new Set();
+      /** Guards against emitting both an 'error'-path and a 'close'-path disconnect for one socket. */
+      disconnectedSockets = /* @__PURE__ */ new WeakSet();
       constructor(options = {}) {
         this.endpoint = options.endpoint || getDefaultSessionHostEndpoint2(options.appName || "adhdev");
       }
+      /**
+       * Fires when an established connection to the session host goes away.
+       *
+       * Before this existed the client registered only 'data' and 'error' handlers,
+       * so a *clean* FIN — the host process exiting normally, or dying to an
+       * uncaught exception that took the socket down without an error event on our
+       * end — ran nothing at all: `this.socket` stayed non-null pointing at a dead
+       * socket, in-flight waiters hung to their 30s timeout, and no caller was told.
+       * That silence is what let a session-host death present downstream as an
+       * unrelated application-level fault (a missing completion marker) instead of
+       * "the host is gone".
+       */
+      onDisconnect(listener) {
+        this.disconnectListeners.add(listener);
+        return () => {
+          this.disconnectListeners.delete(listener);
+        };
+      }
+      handleDisconnect(socket, reason, error48) {
+        if (this.disconnectedSockets.has(socket)) return;
+        this.disconnectedSockets.add(socket);
+        const wasEstablished = establishedSockets2.has(socket);
+        if (!wasEstablished) {
+          if (this.socket === socket) this.socket = null;
+          try {
+            socket.destroy();
+          } catch {
+          }
+          const failure2 = error48 || new Error(`Session host connect failed (${this.endpoint.path})`);
+          for (const waiter of this.requestWaiters.values()) waiter.reject(failure2);
+          this.requestWaiters.clear();
+          return;
+        }
+        const pendingRequests = this.requestWaiters.size;
+        const failure = error48 || new Error(`Session host connection ${reason} (${this.endpoint.path})`);
+        for (const waiter of this.requestWaiters.values()) {
+          waiter.reject(failure);
+        }
+        this.requestWaiters.clear();
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        try {
+          socket.destroy();
+        } catch {
+        }
+        const info = {
+          reason,
+          endpointPath: this.endpoint.path,
+          pendingRequests,
+          error: error48
+        };
+        for (const listener of this.disconnectListeners) {
+          try {
+            listener(info);
+          } catch {
+          }
+        }
+      }
       async connect() {
         if (this.socket && !this.socket.destroyed) return;
         if (this.socket) {
@@ -3624,20 +3687,19 @@ var require_dist = __commonJS({
           }
         }));
         socket.on("error", (error48) => {
-          for (const waiter of this.requestWaiters.values()) {
-            waiter.reject(error48);
-          }
-          this.requestWaiters.clear();
-          if (this.socket === socket) {
-            this.socket = null;
-          }
-          try {
-            socket.destroy();
-          } catch {
-          }
+          this.handleDisconnect(socket, "error", error48);
+        });
+        socket.on("close", () => {
+          this.handleDisconnect(socket, "closed");
+        });
+        socket.on("end", () => {
+          this.handleDisconnect(socket, "ended");
         });
         await new Promise((resolve3, reject) => {
-          socket.once("connect", () => resolve3());
+          socket.once("connect", () => {
+            establishedSockets2.add(socket);
+            resolve3();
+          });
           socket.once("error", reject);
         });
       }
@@ -3679,6 +3741,7 @@ var require_dist = __commonJS({
         if (!this.socket) return;
         const socket = this.socket;
         this.socket = null;
+        this.disconnectedSockets.add(socket);
         for (const waiter of this.requestWaiters.values()) {
           waiter.reject(new Error("Session host client closed"));
         }
@@ -36768,10 +36831,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "e38506ee9da3e916fb4e3c99c19b636f20e5a35c" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "e38506ee" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-22T12:35:42.535Z" : void 0);
+      const commit = readInjected(true ? "789e0aa08f214c5b059b3d12eff74e412488db3b" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "789e0aa0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-23T01:04:20.549Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38186,7 +38249,9 @@ var require_dist3 = __commonJS({
       }
     }
     function sizeRotationPath(logFile, generation) {
-      return logFile.replace(/\.log$/, `.${generation}.log`);
+      const match = logFile.match(/^(.*)(\.[^./\\]+)$/);
+      if (!match) return `${logFile}.${generation}`;
+      return `${match[1]}.${generation}${match[2]}`;
     }
     function rotateSizeGenerations(logFile, maxGenerations = MAX_SIZE_ROTATION_GENERATIONS) {
       if (maxGenerations < 1) return;
@@ -38205,6 +38270,20 @@ var require_dist3 = __commonJS({
       }
       fs22.renameSync(logFile, sizeRotationPath(logFile, 1));
     }
+    function rotateCaptureLogIfNeeded(logPath, maxSize = MAX_CAPTURE_LOG_SIZE, maxGenerations = MAX_CAPTURE_LOG_GENERATIONS) {
+      try {
+        const stat2 = fs22.statSync(logPath);
+        if (stat2.size <= maxSize) return false;
+      } catch {
+        return false;
+      }
+      try {
+        rotateSizeGenerations(logPath, maxGenerations);
+        return true;
+      } catch {
+        return false;
+      }
+    }
     function rotateSizeIfNeeded() {
       try {
         const stat2 = fs22.statSync(currentLogFile);
@@ -38343,6 +38422,8 @@ var require_dist3 = __commonJS({
     var currentDate;
     var currentLogDir;
     var currentLogFile;
+    var MAX_CAPTURE_LOG_SIZE;
+    var MAX_CAPTURE_LOG_GENERATIONS;
     var preparedLogDirs;
     var writeCount;
     var currentLogDirEnv;
@@ -38371,6 +38452,8 @@ var require_dist3 = __commonJS({
         currentDate = getDateStr();
         currentLogDir = resolveLogDir();
         currentLogFile = path32.join(currentLogDir, daemonLogFileName(currentDate));
+        MAX_CAPTURE_LOG_SIZE = 10 * 1024 * 1024;
+        MAX_CAPTURE_LOG_GENERATIONS = 2;
         preparedLogDirs = /* @__PURE__ */ new Set();
         writeCount = 0;
         currentLogDirEnv = process.env.ADHDEV_CONFIG_DIR;
@@ -44084,6 +44167,7 @@ ${error48.message || ""}`;
     __export2(mesh_config_exports, {
       addNode: () => addNode,
       applyMeshHostJoinRequest: () => applyMeshHostJoinRequest,
+      collectIgnoredMagiSlotFields: () => collectIgnoredMagiSlotFields,
       configureMeshHostPairing: () => configureMeshHostPairing,
       createMesh: () => createMesh,
       createMeshHostPairingToken: () => createMeshHostPairingToken,
@@ -44116,25 +44200,75 @@ ${error48.message || ""}`;
     function getMeshConfigPath() {
       return (0, import_path5.join)(getConfigDir2(), "meshes.json");
     }
-    function loadMeshConfig(options = {}) {
+    function sleepBlockingMs(ms) {
+      if (ms <= 0) return;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    function acquireMeshConfigLock() {
+      const lockPath = `${getMeshConfigPath()}.lock`;
+      const deadline = Date.now() + MESH_CONFIG_LOCK_WAIT_MS;
+      while (Date.now() <= deadline) {
+        try {
+          (0, import_fs5.mkdirSync)(lockPath);
+          return () => {
+            try {
+              (0, import_fs5.rmSync)(lockPath, { recursive: true, force: true });
+            } catch {
+            }
+          };
+        } catch (error48) {
+          if (error48?.code !== "EEXIST") return null;
+          try {
+            const stat2 = (0, import_fs5.statSync)(lockPath);
+            if (Date.now() - stat2.mtimeMs > MESH_CONFIG_LOCK_STALE_MS) {
+              (0, import_fs5.rmSync)(lockPath, { recursive: true, force: true });
+              continue;
+            }
+          } catch {
+            continue;
+          }
+          sleepBlockingMs(MESH_CONFIG_LOCK_POLL_MS);
+        }
+      }
+      return null;
+    }
+    function withMeshConfigWriteLock(fn) {
+      if (meshConfigLockHeldInProcess) return fn();
+      const release2 = acquireMeshConfigLock();
+      if (!release2) return fn();
+      meshConfigLockHeldInProcess = true;
+      try {
+        return fn();
+      } finally {
+        meshConfigLockHeldInProcess = false;
+        release2();
+      }
+    }
+    function readMeshConfigFile() {
       const path60 = getMeshConfigPath();
       if (!(0, import_fs5.existsSync)(path60)) return { meshes: [] };
       try {
         const raw = JSON.parse((0, import_fs5.readFileSync)(path60, "utf-8"));
         if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
-        const config2 = raw;
-        const migrated = migrateLoadedMeshConfig(config2);
-        if (migrated && options.persistMigrations !== false) {
-          try {
-            saveMeshConfig(config2);
-          } catch {
-          }
-        }
-        return config2;
+        return raw;
       } catch {
         return { meshes: [] };
       }
     }
+    function loadMeshConfig(options = {}) {
+      const config2 = readMeshConfigFile();
+      const migrated = migrateLoadedMeshConfig(config2);
+      if (migrated && options.persistMigrations !== false) {
+        try {
+          withMeshConfigWriteLock(() => {
+            const fresh = readMeshConfigFile();
+            if (migrateLoadedMeshConfig(fresh)) saveMeshConfig(fresh);
+          });
+        } catch {
+        }
+      }
+      return config2;
+    }
     function migrateLoadedMeshConfig(config2) {
       let changed = false;
       if (foldLegacyTopLevelMeshSetting(config2, "magiKindPanels", "mesh_magi_kind_panel_set({ meshId, task_kind, slots })")) changed = true;
@@ -44219,7 +44353,9 @@ ${error48.message || ""}`;
     }
     function saveMeshConfig(config2) {
       const path60 = getMeshConfigPath();
-      (0, import_fs5.writeFileSync)(path60, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
+      const tmpPath = `${path60}.tmp-${process.pid}`;
+      (0, import_fs5.writeFileSync)(tmpPath, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs5.renameSync)(tmpPath, path60);
     }
     function normalizeRepoIdentity(remoteUrl) {
       let identity = remoteUrl.trim().replace(/[?#].*$/, "").replace(/\/+$/, "");
@@ -44259,7 +44395,10 @@ ${error48.message || ""}`;
       const normalized = normalizeRepoIdentity(repoIdentity);
       return loadMeshConfig().meshes.find((m) => normalizeRepoIdentity(m.repoIdentity) === normalized);
     }
-    function createMesh(opts) {
+    function createMesh(...args) {
+      return withMeshConfigWriteLock(() => createMeshUnlocked(...args));
+    }
+    function createMeshUnlocked(opts) {
       const config2 = loadMeshConfig();
       if (config2.meshes.length >= 20) {
         throw new Error("Maximum 20 meshes allowed");
@@ -44288,7 +44427,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return mesh;
     }
-    function updateMesh(meshId, opts) {
+    function updateMesh(...args) {
+      return withMeshConfigWriteLock(() => updateMeshUnlocked(...args));
+    }
+    function updateMeshUnlocked(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44301,7 +44443,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return mesh;
     }
-    function deleteMesh(meshId) {
+    function deleteMesh(...args) {
+      return withMeshConfigWriteLock(() => deleteMeshUnlocked(...args));
+    }
+    function deleteMeshUnlocked(meshId) {
       const config2 = loadMeshConfig();
       const idx = config2.meshes.findIndex((m) => m.id === meshId);
       if (idx === -1) return false;
@@ -44348,7 +44493,10 @@ ${error48.message || ""}`;
       }
       return { ok: true, tokenId: presentedTokenId };
     }
-    function configureMeshHostPairing(meshId, opts) {
+    function configureMeshHostPairing(...args) {
+      return withMeshConfigWriteLock(() => configureMeshHostPairingUnlocked(...args));
+    }
+    function configureMeshHostPairingUnlocked(meshId, opts) {
       const hostAddress = normalizeManualHostAddress(opts.hostAddress);
       const token = opts.token.trim();
       if (!token) throw new Error("token required");
@@ -44372,7 +44520,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return { mesh, meshHost, hostAddress };
     }
-    function createMeshHostPairingToken(meshId, opts = {}) {
+    function createMeshHostPairingToken(...args) {
+      return withMeshConfigWriteLock(() => createMeshHostPairingTokenUnlocked(...args));
+    }
+    function createMeshHostPairingTokenUnlocked(meshId, opts = {}) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44400,7 +44551,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return { mesh, meshHost, token, tokenId, ...expiresAt ? { expiresAt } : {} };
     }
-    function applyMeshHostJoinRequest(meshId, opts) {
+    function applyMeshHostJoinRequest(...args) {
+      return withMeshConfigWriteLock(() => applyMeshHostJoinRequestUnlocked(...args));
+    }
+    function applyMeshHostJoinRequestUnlocked(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44465,7 +44619,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return { accepted: true, mesh, meshHost: mesh.meshHost, node, tokenId: validation.tokenId };
     }
-    function setMeshHostPin(meshId, opts) {
+    function setMeshHostPin(...args) {
+      return withMeshConfigWriteLock(() => setMeshHostPinUnlocked(...args));
+    }
+    function setMeshHostPinUnlocked(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44545,7 +44702,10 @@ ${error48.message || ""}`;
         ...mesh.meshHost.hostNodeId ? { hostNodeId: mesh.meshHost.hostNodeId } : {}
       };
     }
-    function markMeshHostPairingJoined(meshId, opts) {
+    function markMeshHostPairingJoined(...args) {
+      return withMeshConfigWriteLock(() => markMeshHostPairingJoinedUnlocked(...args));
+    }
+    function markMeshHostPairingJoinedUnlocked(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44569,7 +44729,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return { mesh, meshHost: mesh.meshHost };
     }
-    function addNode(meshId, opts) {
+    function addNode(...args) {
+      return withMeshConfigWriteLock(() => addNodeUnlocked(...args));
+    }
+    function addNodeUnlocked(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44616,7 +44779,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return node;
     }
-    function removeNode(meshId, nodeId) {
+    function removeNode(...args) {
+      return withMeshConfigWriteLock(() => removeNodeUnlocked(...args));
+    }
+    function removeNodeUnlocked(meshId, nodeId) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return false;
@@ -44628,7 +44794,10 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return true;
     }
-    function updateNode(meshId, nodeId, opts) {
+    function updateNode(...args) {
+      return withMeshConfigWriteLock(() => updateNodeUnlocked(...args));
+    }
+    function updateNodeUnlocked(meshId, nodeId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
       if (!mesh) return void 0;
@@ -44680,6 +44849,22 @@ ${error48.message || ""}`;
       }
       return s2;
     }
+    function collectIgnoredMagiSlotFields(slots) {
+      if (!Array.isArray(slots)) return [];
+      const out = [];
+      slots.forEach((entry, idx) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
+        for (const key2 of Object.keys(entry)) {
+          if (MAGI_SLOT_KNOWN_KEYS.includes(key2)) continue;
+          out.push({
+            slot: idx,
+            field: key2,
+            reason: MAGI_SLOT_IGNORED_FIELD_REASONS[key2] ?? `not a recognized MAGI slot key (accepted: ${MAGI_SLOT_KNOWN_KEYS.join(", ")}); it was dropped and has no effect.`
+          });
+        }
+      });
+      return out;
+    }
     function normalizeMagiSlots(slots, knownNodeIds) {
       const allowed = knownNodeIds ? new Set(knownNodeIds) : void 0;
       if (!Array.isArray(slots) || slots.length === 0) {
@@ -44742,7 +44927,10 @@ ${error48.message || ""}`;
       const config2 = loadMeshConfig();
       return resolveScopedMesh(config2, meshId)?.magiKindPanels?.[key2];
     }
-    function setMagiKindPanel(kind, slots, meshId) {
+    function setMagiKindPanel(...args) {
+      return withMeshConfigWriteLock(() => setMagiKindPanelUnlocked(...args));
+    }
+    function setMagiKindPanelUnlocked(kind, slots, meshId) {
       const key2 = normalizeMagiTaskKindKey(kind);
       const stored = loadMeshConfig();
       const mesh = resolveScopedMesh(stored, meshId);
@@ -44759,7 +44947,10 @@ ${error48.message || ""}`;
       saveMeshConfig(stored);
       return normalized;
     }
-    function removeMagiKindPanel(kind, meshId) {
+    function removeMagiKindPanel(...args) {
+      return withMeshConfigWriteLock(() => removeMagiKindPanelUnlocked(...args));
+    }
+    function removeMagiKindPanelUnlocked(kind, meshId) {
       let key2;
       try {
         key2 = normalizeMagiTaskKindKey(kind);
@@ -44796,7 +44987,10 @@ ${error48.message || ""}`;
       const normalized = normalizeDifficultyBrainMap(stored);
       return Object.keys(normalized).length > 0 ? normalized : { ...DEFAULT_DIFFICULTY_BRAINS };
     }
-    function setDifficultyBrains(map3, meshId) {
+    function setDifficultyBrains(...args) {
+      return withMeshConfigWriteLock(() => setDifficultyBrainsUnlocked(...args));
+    }
+    function setDifficultyBrainsUnlocked(map3, meshId) {
       const normalized = normalizeDifficultyBrainMap(map3);
       const stored = loadMeshConfig();
       const mesh = resolveScopedMesh(stored, meshId);
@@ -44842,7 +45036,10 @@ ${error48.message || ""}`;
       const stored = resolveScopedMesh(config2, meshId)?.policy?.quotaRouting;
       return normalizeQuotaRoutingPolicy(stored) ?? {};
     }
-    function setMeshQuotaRouting(input, meshId) {
+    function setMeshQuotaRouting(...args) {
+      return withMeshConfigWriteLock(() => setMeshQuotaRoutingUnlocked(...args));
+    }
+    function setMeshQuotaRoutingUnlocked(input, meshId) {
       const overrides = validateQuotaRoutingOverrides(input);
       const stored = loadMeshConfig();
       const mesh = resolveScopedMesh(stored, meshId);
@@ -44859,9 +45056,15 @@ ${error48.message || ""}`;
     var import_fs5;
     var import_path5;
     var import_crypto3;
+    var MESH_CONFIG_LOCK_WAIT_MS;
+    var MESH_CONFIG_LOCK_STALE_MS;
+    var MESH_CONFIG_LOCK_POLL_MS;
+    var meshConfigLockHeldInProcess;
     var mergeMeshPolicy;
     var MAGI_KIND_PANEL_KINDS;
     var MAX_MAGI_KIND_SLOTS;
+    var MAGI_SLOT_KNOWN_KEYS;
+    var MAGI_SLOT_IGNORED_FIELD_REASONS;
     var QUOTA_ROUTING_PERCENT_FIELDS;
     var QUOTA_ROUTING_NONNEGATIVE_FIELDS;
     var init_mesh_config = __esm2({
@@ -44875,9 +45078,20 @@ ${error48.message || ""}`;
         init_dist();
         init_repo_mesh_types();
         init_mesh_host_ownership();
+        MESH_CONFIG_LOCK_WAIT_MS = 2e3;
+        MESH_CONFIG_LOCK_STALE_MS = 15e3;
+        MESH_CONFIG_LOCK_POLL_MS = 25;
+        meshConfigLockHeldInProcess = false;
         mergeMeshPolicy = mergeAndNormalizePolicy;
         MAGI_KIND_PANEL_KINDS = ["claim_audit", "rca", "design", "freeform"];
         MAX_MAGI_KIND_SLOTS = 24;
+        MAGI_SLOT_KNOWN_KEYS = ["provider", "nodeId", "model", "capabilityTags", "n"];
+        MAGI_SLOT_IGNORED_FIELD_REASONS = Object.freeze({
+          thinkingLevel: "not part of a MAGI slot \u2014 a panel selects WHO answers independently, not how hard each replica thinks. Set thinkingLevel on the node's capability slots (mesh_node_slots_set), which is the routing axis.",
+          difficulty: "not part of a MAGI slot \u2014 MAGI always enqueues its replicas with the fixed 'freeform' difficulty sentinel because the panel has already chosen the (node, provider) target. Set difficulty on the node's capability slots instead.",
+          maxParallel: "not part of a MAGI slot \u2014 per-slot concurrency is a node capability-slot axis. Use the per-slot `n` replica count to control MAGI fan-out width.",
+          capability: "not a MAGI slot key \u2014 did you mean `capabilityTags`?"
+        });
         QUOTA_ROUTING_PERCENT_FIELDS = /* @__PURE__ */ new Set(["sessionMinRemainingPercent", "weeklyMinRemainingPercent"]);
         QUOTA_ROUTING_NONNEGATIVE_FIELDS = /* @__PURE__ */ new Set(["staleAfterMs", "sessionResetImminentMs", "spreadBonusMax"]);
       }
@@ -48569,6 +48783,36 @@ ${blocks.join("\n\n")}`;
         divergenceLogOnce = /* @__PURE__ */ new Set();
       }
     });
+    function s(v) {
+      return typeof v === "string" && v.trim() ? v.trim() : "";
+    }
+    function meshEventTraceKey(ctx) {
+      const segs = [`task=${s(ctx.taskId) || "-"}`];
+      const eventId = s(ctx.eventId);
+      if (eventId) segs.push(`evt=${eventId}`);
+      segs.push(`sess=${s(ctx.sessionId) || "-"}`);
+      const nodeId = s(ctx.nodeId);
+      if (nodeId) segs.push(`node=${nodeId}`);
+      const meshId = s(ctx.meshId);
+      if (meshId) segs.push(`mesh=${meshId}`);
+      const event = s(ctx.event);
+      if (event) segs.push(`event=${event}`);
+      return segs.join(" ");
+    }
+    function traceMeshEventStage(stage, ctx, detail) {
+      LOG2.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+    }
+    function traceMeshEventDrop(reason, ctx, detail) {
+      LOG2.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+    }
+    var CAT;
+    var init_mesh_event_trace = __esm2({
+      "src/mesh/mesh-event-trace.ts"() {
+        "use strict";
+        init_logger();
+        CAT = "EvtTrace";
+      }
+    });
     function isSupportedMeshProtocolVersion(value) {
       return typeof value === "string" && SUPPORTED_MESH_PROTOCOL_VERSIONS.includes(value);
     }
@@ -49039,13 +49283,55 @@ ${blocks.join("\n\n")}`;
       }
       return backfilled.reverse();
     }
+    function readPendingEventTaskId(event) {
+      const metadataEvent = readRecord2(event.metadataEvent);
+      return readNonEmptyString(metadataEvent?.taskId);
+    }
+    function dropStaleTerminalTaskEvents(meshId, events) {
+      if (!events.some((event) => STALE_TASK_DROPPABLE_EVENTS.has(event.event))) return events;
+      let store;
+      try {
+        store = MeshRuntimeStore.getInstance();
+      } catch {
+        return events;
+      }
+      const terminalByTaskId = /* @__PURE__ */ new Map();
+      const isTaskTerminal = (taskId) => {
+        const cached5 = terminalByTaskId.get(taskId);
+        if (cached5 !== void 0) return cached5;
+        let terminal = false;
+        try {
+          const entry = store.findQueueEntryById(meshId, taskId);
+          terminal = !!entry && STALE_TASK_TERMINAL_STATUSES.has(entry.status);
+        } catch {
+          terminal = false;
+        }
+        terminalByTaskId.set(taskId, terminal);
+        return terminal;
+      };
+      return events.filter((event) => {
+        if (!STALE_TASK_DROPPABLE_EVENTS.has(event.event)) return true;
+        const taskId = readPendingEventTaskId(event);
+        if (!taskId) return true;
+        if (!isTaskTerminal(taskId)) return true;
+        traceMeshEventDrop("stale_task_terminal", {
+          taskId,
+          sessionId: resolveEventSessionId(event.metadataEvent) ?? event.targetCoordinatorSessionId,
+          nodeId: event.nodeId,
+          meshId,
+          event: event.event
+        }, "task row is already terminal (completed/failed/cancelled) \u2014 non-terminal alert is stale");
+        return false;
+      });
+    }
     function reconcilePendingMeshCoordinatorEvents(meshId, events) {
       const backfilled = refineTerminalEventFromLedger(meshId, events);
       const terminalJobIds = new Set(
         [...events.filter((event) => REFINE_TERMINAL_EVENTS.has(event.event)), ...backfilled].map((event) => readRefineJobId2(event)).filter(Boolean)
       );
       const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
-      return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
+      const fresh = dropStaleTerminalTaskEvents(meshId, reconciled);
+      return backfilled.length === 0 ? fresh : [...fresh, ...backfilled];
     }
     function getPendingRetentionCounters() {
       return { ...pendingRetentionCounters };
@@ -49430,6 +49716,8 @@ ${blocks.join("\n\n")}`;
     var TERMINAL_COMPLETION_EVENTS;
     var COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT;
     var TERMINAL_COMPLETION_DEDUP_TTL_MS;
+    var STALE_TASK_DROPPABLE_EVENTS;
+    var STALE_TASK_TERMINAL_STATUSES;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
     var PENDING_RETENTION_EXPIRED_HOLD_REASON;
@@ -49444,6 +49732,7 @@ ${blocks.join("\n\n")}`;
         init_mesh_runtime_store();
         init_mesh_turn_presentation();
         init_mesh_events_utils();
+        init_mesh_event_trace();
         init_dist();
         init_contracts();
         REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
@@ -49484,6 +49773,15 @@ ${blocks.join("\n\n")}`;
           "mesh:dispatch_blocked"
         ]);
         TERMINAL_COMPLETION_DEDUP_TTL_MS = 60 * 60 * 1e3;
+        STALE_TASK_DROPPABLE_EVENTS = /* @__PURE__ */ new Set([
+          // Actionable dispatch-skip page ("this task will NOT dispatch on its own"). Meaningless
+          // once the task is terminal — the measured 081317f3 case.
+          "mesh:dispatch_blocked",
+          // Stall watchdog ("no progress observed"). A terminal task cannot make progress; the
+          // alert only invites the coordinator to re-drive already-finished work.
+          "monitor:no_progress"
+        ]);
+        STALE_TASK_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
         PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
         PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
         PENDING_RETENTION_EXPIRED_HOLD_REASON = "pending_retention_expired";
@@ -49504,36 +49802,6 @@ ${blocks.join("\n\n")}`;
         };
       }
     });
-    function s(v) {
-      return typeof v === "string" && v.trim() ? v.trim() : "";
-    }
-    function meshEventTraceKey(ctx) {
-      const segs = [`task=${s(ctx.taskId) || "-"}`];
-      const eventId = s(ctx.eventId);
-      if (eventId) segs.push(`evt=${eventId}`);
-      segs.push(`sess=${s(ctx.sessionId) || "-"}`);
-      const nodeId = s(ctx.nodeId);
-      if (nodeId) segs.push(`node=${nodeId}`);
-      const meshId = s(ctx.meshId);
-      if (meshId) segs.push(`mesh=${meshId}`);
-      const event = s(ctx.event);
-      if (event) segs.push(`event=${event}`);
-      return segs.join(" ");
-    }
-    function traceMeshEventStage(stage, ctx, detail) {
-      LOG2.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
-    }
-    function traceMeshEventDrop(reason, ctx, detail) {
-      LOG2.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
-    }
-    var CAT;
-    var init_mesh_event_trace = __esm2({
-      "src/mesh/mesh-event-trace.ts"() {
-        "use strict";
-        init_logger();
-        CAT = "EvtTrace";
-      }
-    });
     function taskIsParked(task) {
       return !!readNonEmptyString(task?.parked?.reason);
     }
@@ -49641,6 +49909,176 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         PARK_RETENTION_EXPIRED_REASON = "parked_task_retention_expired";
       }
     });
+    function isWorkerAbsenceDispatchFailure(reason) {
+      const text = readNonEmptyString(reason);
+      if (!text) return false;
+      const normalized = text.toLowerCase();
+      return normalized.includes("cli agent not running") || normalized.includes("no provider instance for session") || normalized.includes("no mesh worker session bound to node");
+    }
+    function resolveTunedReconcileMs(envName, def, min, max) {
+      const raw = readNonEmptyString(process.env[envName]);
+      if (raw) {
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
+      }
+      return def;
+    }
+    function resolveAckedDeathDeadlineMs() {
+      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
+    }
+    function resolveAckedTranscriptFastTrackGraceMs() {
+      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
+    }
+    function resolveAckedHoldHardCeilingMs() {
+      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_HOLD_HARD_CEILING_MS", 90 * 6e4, 0, 24 * 60 * 6e4);
+    }
+    function inFlightSynthKey(meshId, taskId) {
+      return `${meshId}::${taskId}`;
+    }
+    function taskIdFromSynthKey(meshId, synthKey) {
+      const prefix = `${meshId}::`;
+      return synthKey.startsWith(prefix) ? synthKey.slice(prefix.length) : synthKey;
+    }
+    function holdStore() {
+      try {
+        return MeshRuntimeStore.getInstance();
+      } catch {
+        return void 0;
+      }
+    }
+    function getHoldState(synthKey, meshId) {
+      const cached5 = inFlightAckedHoldState.get(synthKey);
+      if (cached5) return cached5;
+      const store = holdStore();
+      if (!store) return void 0;
+      let row;
+      try {
+        row = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey));
+      } catch {
+        return void 0;
+      }
+      if (!row) return void 0;
+      const state = {
+        liveConfirmedSinceAck: row.holdReason === "live",
+        consecutiveReadFailures: row.readFailureCount ?? 0,
+        ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {},
+        ...row.heldAt !== null && row.heldAt !== void 0 ? { heldSinceMs: row.heldAt } : {}
+      };
+      inFlightAckedHoldState.set(synthKey, state);
+      return state;
+    }
+    function setHoldState(synthKey, meshId, state) {
+      const store = holdStore();
+      let priorHeldSinceMs = state.heldSinceMs ?? inFlightAckedHoldState.get(synthKey)?.heldSinceMs;
+      if (priorHeldSinceMs === void 0 && store) {
+        try {
+          priorHeldSinceMs = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey))?.heldAt ?? void 0;
+        } catch {
+        }
+      }
+      const heldSinceMs = priorHeldSinceMs ?? Date.now();
+      inFlightAckedHoldState.set(synthKey, { ...state, heldSinceMs });
+      if (!store) return;
+      try {
+        store.upsertInflightHold({
+          taskId: taskIdFromSynthKey(meshId, synthKey),
+          meshId,
+          holdReason: state.liveConfirmedSinceAck ? "live" : "unconfirmed",
+          // Only meaningful when the row is NEW — upsertInflightHold deliberately
+          // preserves held_at on conflict, so an existing row keeps its original anchor.
+          heldAt: heldSinceMs,
+          firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
+          readFailureCount: state.consecutiveReadFailures
+        });
+      } catch {
+      }
+    }
+    function deleteHoldState(synthKey, meshId) {
+      inFlightAckedHoldState.delete(synthKey);
+      const store = holdStore();
+      if (!store) return;
+      try {
+        store.deleteInflightHold(taskIdFromSynthKey(meshId, synthKey));
+      } catch {
+      }
+    }
+    function recordAckedHoldDispatchOutcome(meshId, taskId, outcome) {
+      const key2 = inFlightSynthKey(meshId, taskId);
+      if (outcome.ok || !isWorkerAbsenceDispatchFailure(outcome.reason)) {
+        ackedHoldDispatchFailureStreak.delete(key2);
+        return;
+      }
+      const prior = ackedHoldDispatchFailureStreak.get(key2)?.count ?? 0;
+      ackedHoldDispatchFailureStreak.set(key2, {
+        count: prior + 1,
+        lastReason: readNonEmptyString(outcome.reason) || "worker_absent"
+      });
+    }
+    function getAckedHoldDispatchFailureStreak(meshId, taskId) {
+      return ackedHoldDispatchFailureStreak.get(inFlightSynthKey(meshId, taskId));
+    }
+    function clearAckedHoldDispatchFailureStreak(synthKey) {
+      ackedHoldDispatchFailureStreak.delete(synthKey);
+    }
+    function rehydrateAckedHoldsForMesh(meshId) {
+      if (rehydratedHoldMeshes.has(meshId)) return;
+      rehydratedHoldMeshes.add(meshId);
+      const store = holdStore();
+      if (!store) return;
+      let rows;
+      try {
+        rows = store.listInflightHoldsByMesh(meshId);
+      } catch {
+        return;
+      }
+      for (const row of rows) {
+        const synthKey = inFlightSynthKey(meshId, row.taskId);
+        if (inFlightAckedHoldState.has(synthKey)) continue;
+        inFlightAckedHoldState.set(synthKey, {
+          liveConfirmedSinceAck: row.holdReason === "live",
+          consecutiveReadFailures: row.readFailureCount ?? 0,
+          ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {},
+          ...row.heldAt !== null && row.heldAt !== void 0 ? { heldSinceMs: row.heldAt } : {}
+        });
+      }
+      if (rows.length > 0) {
+        LOG2.info("MeshReconcile", `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
+      }
+    }
+    function collectHeldSynthKeysForMesh(meshId) {
+      const heldKeys = /* @__PURE__ */ new Set();
+      for (const key2 of inFlightAckedHoldState.keys()) {
+        if (key2.startsWith(`${meshId}::`)) heldKeys.add(key2);
+      }
+      const store = holdStore();
+      if (store) {
+        try {
+          for (const row of store.listInflightHoldsByMesh(meshId)) {
+            heldKeys.add(inFlightSynthKey(meshId, row.taskId));
+          }
+        } catch {
+        }
+      }
+      return heldKeys;
+    }
+    var ACKED_DEATH_CONSECUTIVE_READ_FAILURES;
+    var ACKED_DEATH_CONSECUTIVE_DISPATCH_FAILURES;
+    var inFlightAckedHoldState;
+    var rehydratedHoldMeshes;
+    var ackedHoldDispatchFailureStreak;
+    var init_mesh_reconcile_acked_hold = __esm2({
+      "src/mesh/mesh-reconcile-acked-hold.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_runtime_store();
+        init_mesh_events_utils();
+        ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
+        ACKED_DEATH_CONSECUTIVE_DISPATCH_FAILURES = 3;
+        inFlightAckedHoldState = /* @__PURE__ */ new Map();
+        rehydratedHoldMeshes = /* @__PURE__ */ new Set();
+        ackedHoldDispatchFailureStreak = /* @__PURE__ */ new Map();
+      }
+    });
     function readPayloadTaskId(entry) {
       const value = entry.payload?.taskId;
       return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -50147,6 +50585,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
       normalizeMeshTaskPriority: () => normalizeMeshTaskPriority,
       parkTaskTargetPin: () => parkTaskTargetPin,
       reclaimStrandedAssignedTask: () => reclaimStrandedAssignedTask,
+      recordAckedHoldDispatchOutcome: () => recordAckedHoldDispatchOutcome,
       recordDirectDispatchTask: () => recordDirectDispatchTask,
       recordMeshToolCall: () => recordMeshToolCall,
       recordTaskAutoLaunch: () => recordTaskAutoLaunch,
@@ -51045,6 +51484,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         init_mesh_task_mode_guardrail();
         init_mesh_task_parking();
         init_mesh_task_mode_guardrail();
+        init_mesh_reconcile_acked_hold();
         ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
         HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
         MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -58370,6 +58810,7 @@ ${rules.join("\n")}`;
 - **Classify task difficulty honestly.** Judge each task's real difficulty (\`easy\`/\`medium\`/\`difficult\`/\`freeform\`) per the Task difficulty section above \u2014 it is a routing hint, and the matched slot's own model/thinking is what launches. Never bend difficulty to chase a model; retune slots instead (\`mesh_node_slots_set\`).
 - **Retune node profiles when routing is a poor fit \u2014 but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via \`mesh_node_slots_list\`) are what task\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 e.g. every \`difficult\` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared \u2014 you MAY propose a slot change with \`mesh_node_slots_set\` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.
 - **Bootstrap a node's slots from what's actually installed.** When a node has NO slots configured (routing then falls back to "first available provider"), or CLI agents were newly installed on it, call \`mesh_node_slots_propose({ node_id })\` instead of hand-writing a profile. It detects the node's installed CLI agents and drafts a slot list from them \u2014 read-only, it never writes. Present its \`proposedSlots\` with the \`droppedSlots\` / \`destructive\` fields it reports (a wholesale write would delete any existing hand-tuned slot the draft doesn't reproduce, including providers not currently on PATH), then apply with \`mesh_node_slots_set({ slots: proposedSlots, write: true })\` after approval. It flags \`unknownProvider\` / \`provisional\` slots whose placement is a conservative guess rather than an attested one \u2014 call those out rather than presenting them as settled.
+- **When a MAGI panel is unconfigured, bootstrap it from the same detection.** \`mesh_magi_review({ task_kind })\` resolves its panel SOLELY from the configured kind-panel binding, so a task_kind with no slots fails outright with \`magi_kind_not_configured\` \u2014 MAGI is simply unavailable until someone binds it, and the usual reason nobody has is that this path is easy to miss. Pass \`mesh_node_slots_propose({ node_id, include_magi: true })\` to also get a \`magiPanel\` draft: one slot per DISTINCT detected provider, with no model pinned, because a panel's value is cross-provider independence rather than picking the best provider. It is read-only like the rest of the tool. Apply it per kind with \`mesh_magi_kind_panel_set({ task_kind, slots, write: true })\` after approval \u2014 and note that write is a WHOLESALE replacement of that kind's binding, so present the dry-run's \`currentSlots\` first. Do NOT reach for \`include_magi\` on every slot proposal; it is for when the panels are actually empty or a newly installed provider should join them.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Match concurrency to task kind.** Independent read-only tasks (\`live_debug_readonly\`) dispatch all at once up to the read-only cap \u2014 no worktree, no free node needed. Each write task needs its OWN branch workspace (Workflow 3.b0); spreading writes across base nodes is NOT a substitute: a mesh with four base nodes still has zero branch isolation. Ramp up cautiously only when tasks share a base branch or submodule pointer (landing order matters). Never launch a second session onto in-flight work for the same issue, even when \`mesh_read_chat\` shows no final message yet \u2014 successive stages of one investigation stay in their session (see Workflow 3f).
@@ -58530,6 +58971,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
    f. **Let the investigator apply the fix when the findings settle it \u2014 otherwise split deliberately.** An investigator that has read the source and named the file:line and the fix already holds context a fresh worker must rebuild from scratch, and you would have to restate its findings in the new task message to get there. Task mode is **per task, not per session**: the read-only guardrail is evaluated on each dispatch from that task's own \`readonly\`/\`task_mode\`, so you hand off by sending a follow-up \`mesh_send_task\` to the SAME session WITHOUT the read-only flag (use \`task_mode: "code_change"\`). You do not need a new session or a fresh worktree for the mode to change. **Hand off in-session when** the findings match your hypothesis, the fix stays inside the files just investigated, and no user decision is pending. **Split to a separate task when** the investigation needs a user decision (it surfaced design options, or a cost/risk tradeoff), when it OVERTURNED your hypothesis so the direction itself needs rethinking, or when the fix touches files another in-flight worker owns. **Never convert an investigation whose own conclusion was "do not change this"** \u2014 a correct no-op finding is a completed task, and pushing it into a fix produces an unverified change nobody asked for. Dispatching the investigation as an ordinary report-first task skips the handoff, but drops the guardrail against premature fixes \u2014 keep \`live_debug_readonly\` whenever the point is to find out whether anything is wrong at all.
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` \u2014 do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
+       - **Arrival order is not occurrence order \u2014 identify every notification by its \`taskId\`/\`sessionId\`.** While you are generating, worker notifications are held in the queue and injected together on the tick after you go idle. This is intended (a raw write into a generating session is not consumed as a turn), and the delay is normally well under a minute \u2014 measured median ~1 minute, worst case ~10 minutes. The consequence is that a notification arriving now is **not necessarily about the task you most recently dispatched**. Never infer a notification's subject from timing or from what you just sent: read the \`taskId\`/\`sessionId\` in the notification itself and match it to your own record of what you dispatched. Also note that your own coordinator session id appears in these traces, so a session id in a notification is not automatically a worker's. If a notification refers to a task you have already cancelled or completed, treat it as stale \u2014 do not act on it, and say so rather than silently reinterpreting it as being about current work.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe \u2014 but when 2+ sibling worktrees share a base, converge them with \`mesh_refine_batch\` rather than repeated single-node calls (see the sequencing rule in Rules). Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -61360,6 +61802,10 @@ ${rendered}`, "utf-8");
         if (cachedInline && registry2?.updateInlineMeshNode) {
           registry2.updateInlineMeshNode(req.meshId, cachedInline, node);
           published = true;
+        } else if (!cachedInline && !mesh && registry2?.updateInlineMeshNode) {
+          const shell = { id: req.meshId, nodes: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          registry2.updateInlineMeshNode(req.meshId, shell, node);
+          published = true;
         }
       } catch {
       }
@@ -61719,7 +62165,7 @@ ${rendered}`, "utf-8");
     }
     async function registerWorkspaceNodeBestEffort(intent, created, ports, bootstrapStatus) {
       try {
-        await ports.registerNode({
+        const published = await ports.registerNode({
           meshId: intent.meshId,
           nodeId: created.nodeId,
           worktreePath: created.worktreePath,
@@ -61727,6 +62173,9 @@ ${rendered}`, "utf-8");
           sourceNodeId: intent.sourceNodeId,
           bootstrapStatus
         });
+        if (!published) {
+          LOG2.warn("MeshGraphWorkspace", `node registration (${bootstrapStatus}) published NOTHING for ${intent.graphId}/${intent.workspaceRef}: node ${created.nodeId} exists on disk at ${created.worktreePath} but is in no membership view (mesh ${intent.meshId} has no config twin on this daemon and no inline-cache seam accepted it) \u2014 mesh_list_nodes will not show it`);
+        }
       } catch (e) {
         LOG2.warn("MeshGraphWorkspace", `node registration (${bootstrapStatus}) failed for ${intent.graphId}/${intent.workspaceRef}: ${e?.message || e}`);
       }
@@ -67937,7 +68386,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const base = 1;
       let difficulty = 0;
       const diff = isMeshTaskDifficulty(task.difficulty) ? task.difficulty : void 0;
-      if (diff) {
+      if (diff && diff !== "freeform") {
         if (slot.difficulty?.length) {
           difficulty = slot.difficulty.includes(diff) ? 100 : 0;
         } else {
@@ -68804,6 +69253,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (timer) clearTimeout(timer);
         const isQueued = res && typeof res === "object" && res.status === "queued";
         updateSessionDeliveryStatus(delivery.id, isQueued ? "queued" : "delivered");
+        recordAckedHoldDispatchOutcome(ctx.meshId, ctx.task.id, { ok: true });
         if (ctx.task.attemptId) {
           try {
             recordTurnAck({
@@ -68852,6 +69302,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
         LOG2.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
+        recordAckedHoldDispatchOutcome(ctx.meshId, ctx.task.id, { ok: false, reason: e?.message });
         endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
         try {
           closeAttemptForReassignment({ meshId: ctx.meshId, taskId: ctx.task.id, reason: "dispatch_failed" });
@@ -74491,148 +74942,6 @@ ${cleanBody}`;
         init_mesh_events_utils();
       }
     });
-    function resolveTunedReconcileMs(envName, def, min, max) {
-      const raw = readNonEmptyString(process.env[envName]);
-      if (raw) {
-        const parsed = Number.parseInt(raw, 10);
-        if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
-      }
-      return def;
-    }
-    function resolveAckedDeathDeadlineMs() {
-      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
-    }
-    function resolveAckedTranscriptFastTrackGraceMs() {
-      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
-    }
-    function resolveAckedHoldHardCeilingMs() {
-      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_HOLD_HARD_CEILING_MS", 90 * 6e4, 0, 24 * 60 * 6e4);
-    }
-    function inFlightSynthKey(meshId, taskId) {
-      return `${meshId}::${taskId}`;
-    }
-    function taskIdFromSynthKey(meshId, synthKey) {
-      const prefix = `${meshId}::`;
-      return synthKey.startsWith(prefix) ? synthKey.slice(prefix.length) : synthKey;
-    }
-    function holdStore() {
-      try {
-        return MeshRuntimeStore.getInstance();
-      } catch {
-        return void 0;
-      }
-    }
-    function getHoldState(synthKey, meshId) {
-      const cached5 = inFlightAckedHoldState.get(synthKey);
-      if (cached5) return cached5;
-      const store = holdStore();
-      if (!store) return void 0;
-      let row;
-      try {
-        row = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey));
-      } catch {
-        return void 0;
-      }
-      if (!row) return void 0;
-      const state = {
-        liveConfirmedSinceAck: row.holdReason === "live",
-        consecutiveReadFailures: row.readFailureCount ?? 0,
-        ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {},
-        ...row.heldAt !== null && row.heldAt !== void 0 ? { heldSinceMs: row.heldAt } : {}
-      };
-      inFlightAckedHoldState.set(synthKey, state);
-      return state;
-    }
-    function setHoldState(synthKey, meshId, state) {
-      const store = holdStore();
-      let priorHeldSinceMs = state.heldSinceMs ?? inFlightAckedHoldState.get(synthKey)?.heldSinceMs;
-      if (priorHeldSinceMs === void 0 && store) {
-        try {
-          priorHeldSinceMs = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey))?.heldAt ?? void 0;
-        } catch {
-        }
-      }
-      const heldSinceMs = priorHeldSinceMs ?? Date.now();
-      inFlightAckedHoldState.set(synthKey, { ...state, heldSinceMs });
-      if (!store) return;
-      try {
-        store.upsertInflightHold({
-          taskId: taskIdFromSynthKey(meshId, synthKey),
-          meshId,
-          holdReason: state.liveConfirmedSinceAck ? "live" : "unconfirmed",
-          // Only meaningful when the row is NEW — upsertInflightHold deliberately
-          // preserves held_at on conflict, so an existing row keeps its original anchor.
-          heldAt: heldSinceMs,
-          firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
-          readFailureCount: state.consecutiveReadFailures
-        });
-      } catch {
-      }
-    }
-    function deleteHoldState(synthKey, meshId) {
-      inFlightAckedHoldState.delete(synthKey);
-      const store = holdStore();
-      if (!store) return;
-      try {
-        store.deleteInflightHold(taskIdFromSynthKey(meshId, synthKey));
-      } catch {
-      }
-    }
-    function rehydrateAckedHoldsForMesh(meshId) {
-      if (rehydratedHoldMeshes.has(meshId)) return;
-      rehydratedHoldMeshes.add(meshId);
-      const store = holdStore();
-      if (!store) return;
-      let rows;
-      try {
-        rows = store.listInflightHoldsByMesh(meshId);
-      } catch {
-        return;
-      }
-      for (const row of rows) {
-        const synthKey = inFlightSynthKey(meshId, row.taskId);
-        if (inFlightAckedHoldState.has(synthKey)) continue;
-        inFlightAckedHoldState.set(synthKey, {
-          liveConfirmedSinceAck: row.holdReason === "live",
-          consecutiveReadFailures: row.readFailureCount ?? 0,
-          ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {},
-          ...row.heldAt !== null && row.heldAt !== void 0 ? { heldSinceMs: row.heldAt } : {}
-        });
-      }
-      if (rows.length > 0) {
-        LOG2.info("MeshReconcile", `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
-      }
-    }
-    function collectHeldSynthKeysForMesh(meshId) {
-      const heldKeys = /* @__PURE__ */ new Set();
-      for (const key2 of inFlightAckedHoldState.keys()) {
-        if (key2.startsWith(`${meshId}::`)) heldKeys.add(key2);
-      }
-      const store = holdStore();
-      if (store) {
-        try {
-          for (const row of store.listInflightHoldsByMesh(meshId)) {
-            heldKeys.add(inFlightSynthKey(meshId, row.taskId));
-          }
-        } catch {
-        }
-      }
-      return heldKeys;
-    }
-    var ACKED_DEATH_CONSECUTIVE_READ_FAILURES;
-    var inFlightAckedHoldState;
-    var rehydratedHoldMeshes;
-    var init_mesh_reconcile_acked_hold = __esm2({
-      "src/mesh/mesh-reconcile-acked-hold.ts"() {
-        "use strict";
-        init_logger();
-        init_mesh_runtime_store();
-        init_mesh_events_utils();
-        ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
-        inFlightAckedHoldState = /* @__PURE__ */ new Map();
-        rehydratedHoldMeshes = /* @__PURE__ */ new Set();
-      }
-    });
     function resolveAutoPruneMinAgeMs() {
       const raw = readNonEmptyString(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
       if (raw) {
@@ -74864,6 +75173,109 @@ ${cleanBody}`;
         init_mesh_reconcile_identity();
       }
     });
+    function formatBytes(bytes) {
+      if (!Number.isFinite(bytes) || bytes < 0) return "unknown";
+      const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+      let value = bytes;
+      let unit = 0;
+      while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+      }
+      return `${value >= 10 || unit === 0 ? Math.round(value) : value.toFixed(1)}${units[unit]}`;
+    }
+    function classifyDiskSpace(stats) {
+      if (!Number.isFinite(stats.totalBytes) || stats.totalBytes <= 0) return "ok";
+      const { percentFree, freeBytes } = stats;
+      if (percentFree < DISK_CRITICAL_PERCENT_FREE && freeBytes < DISK_CRITICAL_FREE_BYTES) {
+        return "critical";
+      }
+      if (percentFree < DISK_WARNING_PERCENT_FREE && freeBytes < DISK_WARNING_FREE_BYTES) {
+        return "warning";
+      }
+      return "ok";
+    }
+    function describeDiskSpace(stats, level, path60) {
+      const pct = Number.isFinite(stats.percentFree) ? stats.percentFree.toFixed(1) : "?";
+      const used = Number.isFinite(stats.percentFree) ? (100 - stats.percentFree).toFixed(1) : "?";
+      return `disk ${level.toUpperCase()} at ${path60}: ${formatBytes(stats.freeBytes)} free of ${formatBytes(stats.totalBytes)} (${pct}% free / ${used}% used)`;
+    }
+    function readDiskSpace(path60) {
+      try {
+        const stats = (0, import_fs16.statfsSync)(path60);
+        const blockSize = Number(stats.bsize);
+        const freeBytes = Number(stats.bavail) * blockSize;
+        const totalBytes = Number(stats.blocks) * blockSize;
+        if (!Number.isFinite(freeBytes) || !Number.isFinite(totalBytes) || totalBytes <= 0) {
+          return null;
+        }
+        return {
+          freeBytes,
+          totalBytes,
+          percentFree: freeBytes / totalBytes * 100
+        };
+      } catch {
+        return null;
+      }
+    }
+    function checkDiskSpace(path60) {
+      const stats = readDiskSpace(path60);
+      if (!stats) return null;
+      const level = classifyDiskSpace(stats);
+      return { ...stats, level, path: path60, summary: describeDiskSpace(stats, level, path60) };
+    }
+    function logDiskSpaceStatus(status, context) {
+      if (!status) {
+        LOG2.debug("DiskSpace", `${context}: volume not measurable (statfs unavailable)`);
+        return;
+      }
+      switch (status.level) {
+        case "critical":
+          LOG2.error("DiskSpace", `${context}: ${status.summary} \u2014 writes are expected to fail with ENOSPC`);
+          break;
+        case "warning":
+          LOG2.warn("DiskSpace", `${context}: ${status.summary}`);
+          break;
+        default:
+          LOG2.debug("DiskSpace", `${context}: ${status.summary}`);
+          break;
+      }
+    }
+    function preflightDiskSpace(path60, operation, options = {}) {
+      const status = checkDiskSpace(path60);
+      logDiskSpaceStatus(status, `preflight before ${operation}`);
+      if (status?.level === "critical" && options.throwOnCritical !== false) {
+        throw new LowDiskSpaceError(status, operation);
+      }
+      return status;
+    }
+    var import_fs16;
+    var DISK_CRITICAL_PERCENT_FREE;
+    var DISK_CRITICAL_FREE_BYTES;
+    var DISK_WARNING_PERCENT_FREE;
+    var DISK_WARNING_FREE_BYTES;
+    var LowDiskSpaceError;
+    var init_disk_space_preflight = __esm2({
+      "src/diagnostics/disk-space-preflight.ts"() {
+        "use strict";
+        import_fs16 = require("fs");
+        init_logger();
+        DISK_CRITICAL_PERCENT_FREE = 2;
+        DISK_CRITICAL_FREE_BYTES = 1 * 1024 * 1024 * 1024;
+        DISK_WARNING_PERCENT_FREE = 5;
+        DISK_WARNING_FREE_BYTES = 5 * 1024 * 1024 * 1024;
+        LowDiskSpaceError = class extends Error {
+          status;
+          constructor(status, operation) {
+            super(
+              `Refusing to ${operation}: ${status.summary}. Writes would fail with ENOSPC mid-operation. Free space and retry (see \`adhdev doctor\` for the largest reclaimable paths).`
+            );
+            this.name = "LowDiskSpaceError";
+            this.status = status;
+          }
+        };
+      }
+    });
     function selectExpiredLedgerJsonl(files, now, maxAgeMs = LEDGER_JSONL_MAX_AGE_MS) {
       return files.filter((f) => now - f.mtimeMs > maxAgeMs);
     }
@@ -74898,7 +75310,7 @@ ${cleanBody}`;
     }
     function safeUnlink(path60) {
       try {
-        (0, import_fs16.unlinkSync)(path60);
+        (0, import_fs17.unlinkSync)(path60);
         return true;
       } catch (e) {
         LOG2.warn("DiskRetention", `Failed to delete ${path60}: ${e?.message || e}`);
@@ -74906,18 +75318,18 @@ ${cleanBody}`;
       }
     }
     function listDirFiles(dir) {
-      if (!(0, import_fs16.existsSync)(dir)) return [];
+      if (!(0, import_fs17.existsSync)(dir)) return [];
       const out = [];
       let names;
       try {
-        names = (0, import_fs16.readdirSync)(dir);
+        names = (0, import_fs17.readdirSync)(dir);
       } catch {
         return [];
       }
       for (const name of names) {
         const path60 = (0, import_path14.join)(dir, name);
         try {
-          const st = (0, import_fs16.statSync)(path60);
+          const st = (0, import_fs17.statSync)(path60);
           if (st.isFile()) out.push({ path: path60, mtimeMs: st.mtimeMs });
         } catch {
         }
@@ -74944,22 +75356,22 @@ ${cleanBody}`;
     }
     function pruneExpiredSessionHostRuntimes(now = Date.now()) {
       const root = (0, import_path14.join)(getConfigDir2(), "session-host");
-      if (!(0, import_fs16.existsSync)(root)) return 0;
+      if (!(0, import_fs17.existsSync)(root)) return 0;
       let apps;
       try {
-        apps = (0, import_fs16.readdirSync)(root);
+        apps = (0, import_fs17.readdirSync)(root);
       } catch {
         return 0;
       }
       const candidates = [];
       for (const app of apps) {
         const runtimesDir = (0, import_path14.join)(root, app, "runtimes");
-        if (!(0, import_fs16.existsSync)(runtimesDir)) continue;
+        if (!(0, import_fs17.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_fs16.readFileSync)(f.path, "utf-8"));
+            const parsed = JSON.parse((0, import_fs17.readFileSync)(f.path, "utf-8"));
             const rec = parsed && typeof parsed === "object" ? parsed.record : null;
             record2 = rec && typeof rec === "object" ? rec : null;
           } catch {
@@ -75005,7 +75417,15 @@ ${cleanBody}`;
       } catch (e) {
         LOG2.warn("DiskRetention", `Ledger rotation cap sweep failed: ${e?.message || e}`);
       }
-      return { ledgerJsonl, dbBackups, sessionHostRuntimes, rotationEvicted, rotationEvictedBytes };
+      let diskLevel = "ok";
+      try {
+        const status = checkDiskSpace(getConfigDir2());
+        logDiskSpaceStatus(status, "disk retention sweep");
+        if (status) diskLevel = status.level;
+      } catch (e) {
+        LOG2.warn("DiskRetention", `Disk space check failed: ${e?.message || e}`);
+      }
+      return { ledgerJsonl, dbBackups, sessionHostRuntimes, rotationEvicted, rotationEvictedBytes, diskLevel };
     }
     async function detectAndSignalOrphanWorktrees(mesh, now = Date.now()) {
       const nodes = Array.isArray(mesh.nodes) ? mesh.nodes : [];
@@ -75056,7 +75476,7 @@ ${cleanBody}`;
       }
       return signalled;
     }
-    var import_fs16;
+    var import_fs17;
     var import_path14;
     var DAY_MS2;
     var LEDGER_JSONL_MAX_AGE_MS;
@@ -75066,13 +75486,14 @@ ${cleanBody}`;
     var init_mesh_disk_retention = __esm2({
       "src/mesh/mesh-disk-retention.ts"() {
         "use strict";
-        import_fs16 = require("fs");
+        import_fs17 = require("fs");
         import_path14 = require("path");
         init_config();
         init_mesh_ledger();
         init_runtime_surface();
         init_git_worktree();
         init_logger();
+        init_disk_space_preflight();
         DAY_MS2 = 24 * 60 * 60 * 1e3;
         LEDGER_JSONL_MAX_AGE_MS = 30 * DAY_MS2;
         SESSION_HOST_RUNTIME_MAX_AGE_MS = 14 * DAY_MS2;
@@ -76085,6 +76506,7 @@ ${cleanBody}`;
       const { meshId, taskId, sessionId, nodeId, providerType, synthKey, reason, detail } = args;
       updateDirectDispatchStatus(meshId, sessionId, "stale", taskId);
       deleteHoldState(synthKey, meshId);
+      clearAckedHoldDispatchFailureStreak(synthKey);
       try {
         appendLedgerEntry(meshId, {
           kind: "acked_hold_terminalized",
@@ -76140,6 +76562,27 @@ ${cleanBody}`;
         };
         const synthKey = inFlightSynthKey(mesh.id, taskId);
         const isAcked = dispatch.status === "acked";
+        if (isAcked) {
+          const dispatchStreak = getAckedHoldDispatchFailureStreak(mesh.id, taskId);
+          if (dispatchStreak && dispatchStreak.count >= ACKED_DEATH_CONSECUTIVE_DISPATCH_FAILURES) {
+            LOG2.warn("MeshReconcile", `Acked-hold dispatch-failure death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) failed dispatch ${dispatchStreak.count}x consecutively with a worker-absence reason ("${dispatchStreak.lastReason}") \u2014 the target adapter does not exist, so the worker cannot be holding this turn; marking the dispatch row STALE and deleting the synth hold (no completion is asserted \u2014 the transcript never showed one).`);
+            terminalizeAckedHold({
+              meshId: mesh.id,
+              taskId,
+              sessionId,
+              nodeId,
+              ...providerType ? { providerType } : {},
+              synthKey,
+              reason: "acked_dispatch_failure_death",
+              detail: {
+                consecutiveDispatchFailures: dispatchStreak.count,
+                threshold: ACKED_DEATH_CONSECUTIVE_DISPATCH_FAILURES,
+                lastReason: dispatchStreak.lastReason
+              }
+            });
+            continue;
+          }
+        }
         if (isAcked) {
           const ceilingMs = resolveAckedHoldHardCeilingMs();
           const heldSinceMs = getHoldState(synthKey, mesh.id)?.heldSinceMs;
@@ -81093,6 +81536,69 @@ ${cleanBody}`;
         return void 0;
       }
     }
+    function gitRefsResolvable(cwd, refs) {
+      for (const ref of refs) {
+        if (!ref) return false;
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { cwd, stdio: "ignore", windowsHide: true });
+        } catch {
+          return false;
+        }
+      }
+      return true;
+    }
+    function probeGitAncestry(cwd, ancestor, descendant) {
+      try {
+        if (!fs51.existsSync(cwd)) return "undeterminable";
+      } catch {
+        return "undeterminable";
+      }
+      if (!gitRefsResolvable(cwd, [ancestor, descendant])) return "undeterminable";
+      try {
+        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", ancestor, descendant], { cwd, stdio: "ignore", windowsHide: true });
+        return true;
+      } catch (e) {
+        return e?.status === 1 ? false : "undeterminable";
+      }
+    }
+    function probeSubmoduleGitlinkReachability(input) {
+      const { path: path60, baseCommit, branchCommit, probeRoot, baseRepoRoot } = input;
+      const submoduleRepo = (0, import_path17.resolve)(probeRoot, path60);
+      const baseSubmoduleRepo = (0, import_path17.resolve)(baseRepoRoot, path60);
+      if (baseCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, baseCommit);
+      if (branchCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, branchCommit);
+      let fastForward;
+      let reachableFromOriginMain;
+      const undeterminable = [];
+      if (branchCommit) {
+        if (baseCommit) {
+          const ff = probeGitAncestry(submoduleRepo, baseCommit, branchCommit);
+          if (ff === "undeterminable") undeterminable.push("fastForward");
+          else fastForward = ff;
+        }
+        const reach = probeGitAncestry(submoduleRepo, branchCommit, "refs/remotes/origin/main");
+        if (reach === "undeterminable") undeterminable.push("reachableFromOriginMain");
+        else reachableFromOriginMain = reach;
+      }
+      return {
+        path: path60,
+        baseCommit,
+        branchCommit,
+        fastForward,
+        reachableFromOriginMain,
+        ...undeterminable.length ? { undeterminable } : {},
+        probedRepo: submoduleRepo
+      };
+    }
+    function buildSubmoduleReachabilityUndeterminableWarning(nodeId, evidence) {
+      if (!evidence.submoduleReachabilityUndeterminable) return void 0;
+      const entries = (evidence.submoduleGitlinks || []).filter((g) => (g.undeterminable || []).includes("reachableFromOriginMain")).map((g) => `${g.path}@${(g.branchCommit || "?").slice(0, 12)} (probed: ${g.probedRepo || "unknown"})`).join(", ");
+      return `[Refinery] Could NOT determine submodule gitlink reachability from submodule origin/main for node ${nodeId} \u2014 probe had NO ANSWER (missing commit object and/or missing refs/remotes/origin/main in the probed repo). "undeterminable", NOT "unpublished" and NOT "nothing to converge": ${entries}`;
+    }
+    function warnRefineSubmoduleUndeterminable(nodeId, evidence) {
+      const message = buildSubmoduleReachabilityUndeterminableWarning(nodeId, evidence);
+      if (message) LOG2.warn("Mesh", message);
+    }
     function submoduleCommitPresent(submoduleRepoPath, commit) {
       if (!commit) return false;
       try {
@@ -81140,6 +81646,7 @@ ${cleanBody}`;
     }
     var fs51;
     var import_node_child_process11;
+    var import_path17;
     var GIT4;
     var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
     var init_mesh_refine_gitlink_utils = __esm2({
@@ -81147,6 +81654,8 @@ ${cleanBody}`;
         "use strict";
         fs51 = __toESM2(require("fs"));
         import_node_child_process11 = require("child_process");
+        import_path17 = require("path");
+        init_logger();
         init_resolve_executable();
         GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
         REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
@@ -81232,9 +81741,9 @@ ${cleanBody}`;
       for (const path60 of changed) {
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path60);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path60);
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path60);
+        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path60);
         if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path60), baseCommit);
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path60), baseCommit);
         }
         const markUndeterminable = () => {
           const unavailable = [];
@@ -81380,7 +81889,7 @@ ${cleanBody}`;
         for (const p of conflicts) {
           const commit = resolveByPath.get(p);
           try {
-            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path18.resolve)(worktreeRoot, p), stdio: "ignore" });
           } catch {
           }
           try {
@@ -81399,13 +81908,13 @@ ${cleanBody}`;
       return { ok: true, branchHead };
     }
     var fs52;
-    var import_path17;
+    var import_path18;
     var import_node_child_process12;
     var init_mesh_refine_submodule_converge = __esm2({
       "src/mesh/mesh-refine-submodule-converge.ts"() {
         "use strict";
         fs52 = __toESM2(require("fs"));
-        import_path17 = require("path");
+        import_path18 = require("path");
         import_node_child_process12 = require("child_process");
         init_mesh_refine_gitlink_utils();
       }
@@ -81427,10 +81936,10 @@ ${tail}`;
     }
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
-        const dir = (0, import_path18.join)(workspace, REFINE_VALIDATION_LOG_DIR);
+        const dir = (0, import_path19.join)(workspace, REFINE_VALIDATION_LOG_DIR);
         fs53.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_path19.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(" ");
         fs53.writeFileSync(
@@ -81618,9 +82127,15 @@ ${e?.stderr || ""}`
         };
       }
     }
+    async function classifyAndWarnPatchEquivalenceFailure(nodeId, repoRoot, baseHead, branchHead, summary, options = {}) {
+      const classification = await classifyPatchEquivalenceFailure(repoRoot, baseHead, branchHead, summary, options);
+      warnRefineSubmoduleUndeterminable(nodeId, classification.evidence);
+      return classification;
+    }
     async function classifyPatchEquivalenceFailure(repoRoot, baseHead, branchHead, summary, options = {}) {
       const targetBaseRef = options.targetBaseRef || baseHead;
       const autoPublish = options.autoPublishSubmoduleMainCommits;
+      const submoduleProbeRoot = options.worktreeRoot || repoRoot;
       const evidence = {
         baseHead,
         branchHead,
@@ -81685,20 +82200,19 @@ ${e?.stderr || ""}`
             } catch {
               continue;
             }
-            const submoduleRepo = (0, import_path18.join)(repoRoot, p);
-            let fastForward;
-            let reachableFromOriginMain;
-            if (branchCommit) {
-              if (baseCommit) {
-                fastForward = execGitOk(submoduleRepo, ["merge-base", "--is-ancestor", baseCommit, branchCommit]);
-              }
-              reachableFromOriginMain = execGitOk(submoduleRepo, ["merge-base", "--is-ancestor", branchCommit, "refs/remotes/origin/main"]);
-            }
-            submoduleGitlinks.push({ path: p, baseCommit, branchCommit, fastForward, reachableFromOriginMain });
+            submoduleGitlinks.push(probeSubmoduleGitlinkReachability({
+              path: p,
+              baseCommit,
+              branchCommit,
+              probeRoot: submoduleProbeRoot,
+              baseRepoRoot: repoRoot
+            }));
           }
         } catch {
         }
         if (submoduleGitlinks.length) evidence.submoduleGitlinks = submoduleGitlinks;
+        const undeterminableGitlinks = submoduleGitlinks.filter((g) => (g.undeterminable || []).includes("reachableFromOriginMain"));
+        if (undeterminableGitlinks.length > 0) evidence.submoduleReachabilityUndeterminable = true;
         const gitlinkFf = summary.gitlinkTrivialFastForward;
         const noResidualDiff = !evidence.diffStat && (!summary.actualPatchId || summary.actualPatchId === "");
         if (ahead === 0 && behind === 0 && noResidualDiff) {
@@ -81719,6 +82233,15 @@ ${e?.stderr || ""}`
             evidence
           };
         }
+        if (undeterminableGitlinks.length > 0) {
+          const refs = undeterminableGitlinks.map((g) => `${g.path}@${(g.branchCommit || "?").slice(0, 12)} (probed: ${g.probedRepo || "unknown"})`).join(", ");
+          return {
+            detailedReason: "submodule_reachability_undeterminable",
+            detailedReasonDescription: `Could NOT determine whether submodule gitlink commit(s) are reachable from submodule origin/main \u2014 the probe had no answer (missing commit object and/or missing refs/remotes/origin/main in the probed repo): ${refs}. This is "undeterminable", NOT "unpublished".`,
+            recommendedAction: "Make the probe answerable, then rerun mesh_refine_node: fetch the submodule remote in the probed checkout (`git -C <probedRepo> fetch origin main`) so both the gitlink commit object and refs/remotes/origin/main exist locally. Do NOT publish/push the submodule commit on the strength of this result \u2014 reachability was never established either way.",
+            evidence
+          };
+        }
         const changedGitlinks = submoduleGitlinks.length > 0;
         const allGitlinksFf = changedGitlinks && submoduleGitlinks.every((g) => g.fastForward === true);
         const gateSawUnresolvedGitlinkFf = gitlinkFf?.resolved === false && Array.isArray(gitlinkFf.gitlinks) && gitlinkFf.gitlinks.some((g) => g.fastForward);
@@ -81754,14 +82277,6 @@ ${e?.stderr || ""}`
         };
       }
     }
-    function execGitOk(cwd, args) {
-      try {
-        (0, import_node_child_process13.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
-        return true;
-      } catch {
-        return false;
-      }
-    }
     async function checkWorktreeChangesPatchEquivalentInRef(repoRoot, ref, worktreeHead) {
       const startedAt = Date.now();
       try {
@@ -81955,7 +82470,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path60);
         const branchCommit = readTreeObject(repoRoot, branchHead, path60);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path60), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path19.resolve)(repoRoot, path60), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -81964,8 +82479,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path60);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path60);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path60);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path60), baseCommit);
+        const submoduleRepoPath = (0, import_path19.resolve)(worktreeRoot, path60);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path19.resolve)(baseRepoRoot, path60), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -81981,7 +82496,7 @@ ${mergeTreeErr?.stderr || ""}`;
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path60) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path60);
         const branchCommit = readTreeObject(repoRoot, branchHead, path60);
-        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path60);
+        const submoduleRepoPath = (0, import_path19.resolve)(repoRoot, path60);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
         return { path: path60, baseCommit, branchCommit, fastForward };
       });
@@ -82036,7 +82551,7 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path60) => `160000 commit ${placeholderCommit}	${path60}`).join("\n");
         if (!updates) return tree;
-        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path19.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -82111,7 +82626,7 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!contentTree) return void 0;
         const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
         if (!updates) return contentTree;
-        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path19.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -82268,7 +82783,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return match ? { commit: match[1], path: match[2] } : null;
         }).filter((entry) => !!entry);
         for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path18.resolve)(repoRoot, gitlink.path);
+          const submodulePath = (0, import_path19.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -82295,7 +82810,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path18.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path19.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
                   if (imported) {
                     entry.localReachable = true;
                     entry.importedFromWorktree = true;
@@ -82525,13 +83040,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path18.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+        const command = (0, import_path19.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs53.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
-        if (fs53.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) => fs53.existsSync((0, import_path18.join)(cwd, lock)));
+        if (!fs53.existsSync((0, import_path19.join)(cwd, "package.json"))) return false;
+        if (fs53.existsSync((0, import_path19.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs53.existsSync((0, import_path19.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -82598,7 +83113,7 @@ ${mergeTreeErr?.stderr || ""}`;
         summary.bootstrap = { stage: "legacy" };
         for (const candidate of selection.bootstrapCommands) {
           const startedAt = Date.now();
-          const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
+          const cwd = candidate.cwd ? (0, import_path19.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           const resolvedCommand = resolveWin32Executable(candidate.command);
           const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -82631,7 +83146,7 @@ ${mergeTreeErr?.stderr || ""}`;
       let missingDepsBlocked = false;
       for (const candidate of commandsToRun) {
         const startedAt = Date.now();
-        const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
+        const cwd = candidate.cwd ? (0, import_path19.resolve)(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
         if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
@@ -82698,7 +83213,7 @@ ${mergeTreeErr?.stderr || ""}`;
       summary.status = "passed";
       return summary;
     }
-    var import_path18;
+    var import_path19;
     var fs53;
     var import_node_child_process13;
     var REFINE_VALIDATION_TIMEOUT_MS;
@@ -82713,7 +83228,7 @@ ${mergeTreeErr?.stderr || ""}`;
         init_git_status();
         init_refine_config();
         init_worktree_bootstrap_config();
-        import_path18 = require("path");
+        import_path19 = require("path");
         fs53 = __toESM2(require("fs"));
         import_node_child_process13 = require("child_process");
         init_resolve_executable();
@@ -82725,7 +83240,7 @@ ${mergeTreeErr?.stderr || ""}`;
         REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
         REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
         REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-        REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
+        REFINE_VALIDATION_LOG_DIR = (0, import_path19.join)(".adhdev", "logs");
       }
     });
     function findOpenRefineDispatchForNode(args) {
@@ -83807,16 +84322,11 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
             error: submoduleHintPatchEquivalence.error,
             actionableHint: submoduleHintPatchEquivalence.actionableHint
           });
-          const classification = await classifyPatchEquivalenceFailure(
-            repoRoot,
-            baseHead,
-            ctx.branchHead,
-            submoduleHintPatchEquivalence,
-            {
-              targetBaseRef: baseHead,
-              autoPublishSubmoduleMainCommits: resolveRefineryAutoPublishSubmoduleMainCommits(ctx.mesh, node.workspace).enabled
-            }
-          );
+          const classification = await classifyAndWarnPatchEquivalenceFailure(node.id, repoRoot, baseHead, ctx.branchHead, submoduleHintPatchEquivalence, {
+            targetBaseRef: baseHead,
+            worktreeRoot: node.workspace,
+            autoPublishSubmoduleMainCommits: resolveRefineryAutoPublishSubmoduleMainCommits(ctx.mesh, node.workspace).enabled
+          });
           return { kind: "terminal", result: {
             success: false,
             code: "patch_equivalence_failed",
@@ -84000,19 +84510,15 @@ ${tail}` : ""
       if (!patchEquivalence.equivalent) {
         const alreadyMergedViaOtherPath = !patchEquivalence.actualPatchId && !!patchEquivalence.expectedPatchId;
         if (!alreadyMergedViaOtherPath) {
-          const classification = await classifyPatchEquivalenceFailure(
-            repoRoot,
-            baseHead,
-            branchHead,
-            patchEquivalence,
-            {
-              targetBaseRef: baseHead,
-              autoPublishSubmoduleMainCommits: resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace).enabled
-            }
-          );
+          const classification = await classifyAndWarnPatchEquivalenceFailure(node.id, repoRoot, baseHead, branchHead, patchEquivalence, {
+            targetBaseRef: baseHead,
+            worktreeRoot: node.workspace,
+            autoPublishSubmoduleMainCommits: resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace).enabled
+          });
           recordMeshRefineStage(refineStages, "patch_equivalence_classification", "failed", patchEquivalenceStarted, {
             detailedReason: classification.detailedReason,
-            recommendedAction: classification.recommendedAction
+            recommendedAction: classification.recommendedAction,
+            ...classification.evidence.submoduleReachabilityUndeterminable ? { submoduleReachabilityUndeterminable: true } : {}
           });
           return { kind: "terminal", result: {
             success: false,
@@ -85391,6 +85897,10 @@ ${e?.stderr || ""}`;
       DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS: () => DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS,
       DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS: () => DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS,
       DEV_SERVER_PORT: () => DEV_SERVER_PORT,
+      DISK_CRITICAL_FREE_BYTES: () => DISK_CRITICAL_FREE_BYTES,
+      DISK_CRITICAL_PERCENT_FREE: () => DISK_CRITICAL_PERCENT_FREE,
+      DISK_WARNING_FREE_BYTES: () => DISK_WARNING_FREE_BYTES,
+      DISK_WARNING_PERCENT_FREE: () => DISK_WARNING_PERCENT_FREE,
       DUPLICATE_MESH_DISPATCH_CODE: () => DUPLICATE_MESH_DISPATCH_CODE,
       DaemonAgentStreamManager: () => DaemonAgentStreamManager,
       DaemonCdpInitializer: () => DaemonCdpInitializer,
@@ -85415,8 +85925,11 @@ ${e?.stderr || ""}`;
       KNOWN_DIGEST_ALGORITHMS: () => KNOWN_DIGEST_ALGORITHMS,
       LEGACY_UNVERIFIED_ALGORITHM: () => LEGACY_UNVERIFIED_ALGORITHM,
       LOG: () => LOG2,
+      LowDiskSpaceError: () => LowDiskSpaceError,
       MAGI_NEEDS_VERIFICATION_PREVIEW_CAP: () => MAGI_NEEDS_VERIFICATION_PREVIEW_CAP,
       MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
+      MAX_CAPTURE_LOG_GENERATIONS: () => MAX_CAPTURE_LOG_GENERATIONS,
+      MAX_CAPTURE_LOG_SIZE: () => MAX_CAPTURE_LOG_SIZE,
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
       MAX_SESSIONS_PER_MESH: () => MAX_SESSIONS_PER_MESH,
       MAX_SIZE_ROTATION_GENERATIONS: () => MAX_SIZE_ROTATION_GENERATIONS,
@@ -85546,9 +86059,11 @@ ${e?.stderr || ""}`;
       buildUserChatMessage: () => buildUserChatMessage,
       cancelTask: () => cancelTask,
       canonicalDaemonId: () => canonicalDaemonId,
+      checkDiskSpace: () => checkDiskSpace,
       claimMeshGraphGate: () => claimMeshGraphGate,
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
+      classifyDiskSpace: () => classifyDiskSpace,
       classifyDuplicateMeshDispatch: () => classifyDuplicateMeshDispatch,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       classifyP2pRelayFailure: () => classifyP2pRelayFailure,
@@ -85561,6 +86076,7 @@ ${e?.stderr || ""}`;
       clearDebugTrace: () => clearDebugTrace,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
       codexSessionsDir: () => codexSessionsDir,
+      collectIgnoredMagiSlotFields: () => collectIgnoredMagiSlotFields,
       collectPendingApprovals: () => collectPendingApprovals,
       collectSyncTargetTypes: () => collectSyncTargetTypes,
       commitMeshGraphPlan: () => commitMeshGraphPlan,
@@ -85599,6 +86115,7 @@ ${e?.stderr || ""}`;
       deriveMeshReviewInboxItems: () => deriveMeshReviewInboxItems,
       deriveWorkspaceBranchIdentity: () => deriveWorkspaceBranchIdentity,
       deriveWorkspaceOwnerTag: () => deriveWorkspaceOwnerTag,
+      describeDiskSpace: () => describeDiskSpace,
       describeTaskDependencyState: () => describeTaskDependencyState,
       detectAllVersions: () => detectAllVersions,
       detectCLI: () => detectCLI,
@@ -85634,6 +86151,7 @@ ${e?.stderr || ""}`;
       flattenMessageParts: () => flattenMessageParts,
       foldUsageRecords: () => foldUsageRecords,
       forceRefreshQuota: () => forceRefreshQuota2,
+      formatBytes: () => formatBytes,
       formatManifestValidationIssues: () => formatManifestValidationIssues,
       formatMeshTaskModeViolations: () => formatMeshTaskModeViolations,
       forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance2,
@@ -85751,6 +86269,7 @@ ${e?.stderr || ""}`;
       loadRepoSettings: () => loadRepoSettings,
       loadState: () => loadState,
       logCommand: () => logCommand,
+      logDiskSpaceStatus: () => logDiskSpaceStatus,
       machineCoreFromDaemonId: () => machineCoreFromDaemonId,
       magiAutoLaunchedSessionCleanupDecision: () => magiAutoLaunchedSessionCleanupDecision,
       makeUsage: () => makeUsage,
@@ -85807,6 +86326,7 @@ ${e?.stderr || ""}`;
       partitionSessionHostDiagnosticsSessions: () => import_session_host_core32.partitionSessionHostDiagnosticsSessions,
       partitionSessionHostRecords: () => import_session_host_core32.partitionSessionHostRecords,
       planMeshOnboarding: () => planMeshOnboarding,
+      preflightDiskSpace: () => preflightDiskSpace,
       prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate2,
       prepareSessionModalUpdate: () => prepareSessionModalUpdate2,
       presentationFromAttemptRow: () => presentationFromAttemptRow,
@@ -85828,6 +86348,7 @@ ${e?.stderr || ""}`;
       readChatHistory: () => readChatHistory,
       readClaudeCliSession: () => readSession,
       readCodexCliSession: () => readSession2,
+      readDiskSpace: () => readDiskSpace,
       readHermesCliSession: () => readSession4,
       readLatestCodexRateLimits: () => readLatestCodexRateLimits,
       readLedgerEntries: () => readLedgerEntries,
@@ -85909,6 +86430,7 @@ ${e?.stderr || ""}`;
       resolveTurnAttemptRow: () => resolveTurnAttemptRow,
       resolveWorktreeBaseDir: () => resolveWorktreeBaseDir,
       resolveWorktreePath: () => resolveWorktreePath,
+      rotateCaptureLogIfNeeded: () => rotateCaptureLogIfNeeded,
       runAsyncBatch: () => runAsyncBatch2,
       runGit: () => runGit,
       runMeshWorktreeBootstrap: () => runMeshWorktreeBootstrap,
@@ -89460,7 +89982,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
     init_state_store();
     var import_child_process5 = require("child_process");
     var import_util22 = require("util");
-    var import_fs17 = require("fs");
+    var import_fs18 = require("fs");
     var import_os3 = require("os");
     var path24 = __toESM2(require("path"));
     var fs16 = __toESM2(require("fs"));
@@ -89537,7 +90059,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
       if (path24.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
         const candidate = trimmed.startsWith("~") ? path24.join((0, import_os3.homedir)(), trimmed.slice(1)) : trimmed;
         const resolved = path24.isAbsolute(candidate) ? candidate : path24.resolve(candidate);
-        return (0, import_fs17.existsSync)(resolved) ? resolved : null;
+        return (0, import_fs18.existsSync)(resolved) ? resolved : null;
       }
       const isWin = (0, import_os3.platform)() === "win32";
       const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -89547,8 +90069,8 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
         for (const ext of exes) {
           const fullPath = path24.join(p, trimmed + ext);
           try {
-            if ((0, import_fs17.existsSync)(fullPath)) {
-              const stat2 = (0, import_fs17.statSync)(fullPath);
+            if ((0, import_fs18.existsSync)(fullPath)) {
+              const stat2 = (0, import_fs18.statSync)(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -89566,9 +90088,9 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs17.existsSync)(resolved)) return resolved;
+          if ((0, import_fs18.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs17.existsSync)(normalized)) return normalized;
+          if ((0, import_fs18.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -89582,7 +90104,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os33 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs17.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs18.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os33 === "win32") {
           const { dirname: dirname24 } = await import("path");
@@ -89595,7 +90117,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs17.existsSync)(c)) {
+            if ((0, import_fs18.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -101233,7 +101755,7 @@ ${marker}`,
     var os24 = __toESM2(require("os"));
     var path40 = __toESM2(require("path"));
     var crypto6 = __toESM2(require("crypto"));
-    var import_fs18 = require("fs");
+    var import_fs19 = require("fs");
     var import_child_process11 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     var fs322 = __toESM2(require("fs"));
@@ -112557,7 +113079,7 @@ ${rawInput}` : rawInput;
       const trimmed = command.trim();
       if (!trimmed) return false;
       if (isExplicitCommand(trimmed)) {
-        return (0, import_fs18.existsSync)(expandExecutable(trimmed));
+        return (0, import_fs19.existsSync)(expandExecutable(trimmed));
       }
       try {
         (0, import_child_process11.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -112703,10 +113225,10 @@ ${rawInput}` : rawInput;
     }
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path40.join(os24.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-      (0, import_fs18.mkdirSync)(baseDir, { recursive: true });
+      (0, import_fs19.mkdirSync)(baseDir, { recursive: true });
       const workspaceHash = shortHash(path40.resolve(workspace || os24.tmpdir()));
       const filePath = path40.join(baseDir, `${workspaceHash}.json`);
-      (0, import_fs18.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+      (0, import_fs19.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
     }
     function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -120458,7 +120980,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: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
+          const { mkdirSync: mkdirSync32, writeFileSync: writeFileSync31 } = await import("fs");
           const { dirname: dirname24, join: join68 } = await import("path");
           const scaffold = buildMeshJsonConfigScaffold2(mesh);
           const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
@@ -120499,7 +121021,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               note: "Dry-run: nothing written. Re-run with write=true to persist to the repo (commit target). meshes.json is untouched."
             };
           }
-          mkdirSync31(dirname24(absolutePath), { recursive: true });
+          mkdirSync32(dirname24(absolutePath), { recursive: true });
           writeFileSync31(absolutePath, `${scaffoldJson}
 `, "utf-8");
           return {
@@ -120569,7 +121091,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: existsSync70, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
+          const { existsSync: existsSync70, readFileSync: readFileSync55, mkdirSync: mkdirSync32, writeFileSync: writeFileSync31 } = await import("fs");
           const { dirname: dirname24, join: join68 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
@@ -120634,7 +121156,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               note: "Dry-run: nothing written. Re-run with write=true to persist. Only the providerDefaults zone is merged; other repo zones are preserved."
             };
           }
-          mkdirSync31(dirname24(absolutePath), { recursive: true });
+          mkdirSync32(dirname24(absolutePath), { recursive: true });
           writeFileSync31(absolutePath, serialized, "utf-8");
           return {
             success: true,
@@ -120702,10 +121224,17 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         if (!kind) return { success: false, error: "invalid_magi_kind_panel: task_kind is required" };
         const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { setMagiKindPanel: setMagiKindPanel2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const { setMagiKindPanel: setMagiKindPanel2, resolveScopedMeshId: resolveScopedMeshId2, collectIgnoredMagiSlotFields: collectIgnoredMagiSlotFields2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const ignoredFields = collectIgnoredMagiSlotFields2(args?.slots);
           const slots = setMagiKindPanel2(kind, args?.slots, requestedMeshId || void 0);
           const meshId = requestedMeshId || resolveScopedMeshId2();
-          return { success: true, kind, slots, meshId: meshId ?? null };
+          return {
+            success: true,
+            kind,
+            slots,
+            meshId: meshId ?? null,
+            ...ignoredFields.length ? { ignoredFields } : {}
+          };
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -121584,7 +122113,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               error: applied.reason
             };
           }
-          ctx.inlineMeshCache.set(meshId, applied.mesh);
+          ctx.getCachedInlineMesh(meshId, applied.mesh);
           ctx.invalidateAggregateMeshStatus(meshId);
           try {
             const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
@@ -122936,7 +123465,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync70, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
+          const { existsSync: existsSync70, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync32 } = await import("fs");
           const { dirname: dirname24 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -122974,7 +123503,7 @@ ${ptyResult.output.slice(-2e3)}`);
             ...mcpServerEnv ? { env: mcpServerEnv } : {}
           });
           try {
-            mkdirSync31(dirname24(mcpConfigPath), { recursive: true });
+            mkdirSync32(dirname24(mcpConfigPath), { recursive: true });
           } catch (error48) {
             const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
             LOG2.error("MeshCoordinator", message);
@@ -124002,7 +124531,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_router_refine();
     var fs54 = __toESM2(require("fs"));
     var import_node_os22 = require("os");
-    var import_path19 = require("path");
+    var import_path20 = require("path");
     init_logger();
     init_git_locale();
     init_dist();
@@ -124014,7 +124543,7 @@ ${ptyResult.output.slice(-2e3)}`);
     function acceptableManagedWorktreePaths(resolveWorktreePath2, normalizePath2, repoRoot, meshName, branch, worktreeBaseDir) {
       const safeBranch = branch.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
       const safeMeshName = meshName.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
-      const legacyPath = (0, import_path19.join)((0, import_path19.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path20.join)((0, import_path20.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -124041,8 +124570,8 @@ ${ptyResult.output.slice(-2e3)}`);
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os22.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path19.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path19.sep);
+        const trackWorktreesDir = (0, import_path20.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path20.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -124152,7 +124681,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path19.resolve)(value);
+        const resolved = (0, import_path20.resolve)(value);
         try {
           return fs54.realpathSync(resolved);
         } catch {
@@ -124279,7 +124808,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path19.resolve)(value);
+        const resolved = (0, import_path20.resolve)(value);
         try {
           return fs54.realpathSync(resolved);
         } catch {
@@ -124947,7 +125476,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path20 = require("path");
+    var import_path21 = require("path");
     var fs55 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
@@ -124988,13 +125517,13 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path20.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path21.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_path21.join)(sourceHome, "config.yaml");
       if (!fs55.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path20.resolve)(sourceConfigPath) === (0, import_path20.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path21.resolve)(sourceConfigPath) === (0, import_path21.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs55.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -125028,10 +125557,10 @@ ${ptyResult.output.slice(-2e3)}`);
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path20.resolve)(sourceHome) === (0, import_path20.resolve)(targetHome)) return;
+      if ((0, import_path21.resolve)(sourceHome) === (0, import_path21.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_path21.join)(sourceHome, fileName);
+        const targetPath = (0, import_path21.join)(targetHome, fileName);
         if (!fs55.existsSync(sourcePath)) continue;
         try {
           fs55.copyFileSync(sourcePath, targetPath);
@@ -126168,6 +126697,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_track_identity();
     init_normalize();
     init_logger();
+    init_disk_space_preflight();
     var UNICODE_SYMBOLS = {
       ok: "\u2713",
       fail: "\u2717",
@@ -133236,6 +133766,7 @@ data: ${JSON.stringify(msg.data)}
     var path59 = __toESM2(require("path"));
     var import_session_host_core14 = require_dist();
     init_logger();
+    init_disk_space_preflight();
     init_runtime_defaults();
     function createManagedSessionHost2(options) {
       const appName = options.appName;
@@ -133339,6 +133870,7 @@ data: ${JSON.stringify(msg.data)}
       function spawnHost() {
         const entry = resolveEntry();
         verifyConptyPrebuildBeforeSpawn(entry);
+        preflightDiskSpace(instance().configDir, "spawn the session host");
         const nodeExecutable = resolveSessionHostNode();
         let stdio = "ignore";
         let logFd = null;
@@ -133354,7 +133886,20 @@ data: ${JSON.stringify(msg.data)}
           windowsHide: true,
           env: buildEnv(process.env)
         });
-        child.unref();
+        if (typeof child?.on === "function") {
+          child.on("error", (error48) => {
+            LOG2.error("SessionHost", `Failed to spawn session-host process: ${error48?.message || error48}`);
+          });
+          child.on("exit", (code, signal) => {
+            const how = signal ? `signal ${signal}` : `code ${code}`;
+            const detail = options.spawnStdio === "logfile" ? ` \u2014 see ${path59.join(instance().configDir, "logs", "session-host.log")} for its stderr` : "";
+            LOG2.error(
+              "SessionHost",
+              `Session-host process (pid ${child.pid ?? "unknown"}) exited with ${how}${detail}`
+            );
+          });
+        }
+        if (typeof child?.unref === "function") child.unref();
         if (logFd !== null) {
           try {
             fs62.closeSync(logFd);
@@ -133805,8 +134350,8 @@ data: ${JSON.stringify(msg.data)}
     init_config_dir();
     init_mesh_events();
     init_mesh_reconcile_loop();
-    var import_fs19 = require("fs");
-    var import_path21 = require("path");
+    var import_fs20 = require("fs");
+    var import_path222 = require("path");
     var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -133874,31 +134419,31 @@ data: ${JSON.stringify(msg.data)}
       } catch {
         return result;
       }
-      if (!(0, import_fs19.existsSync)(dir)) return result;
+      if (!(0, import_fs20.existsSync)(dir)) return result;
       let names;
       try {
-        names = (0, import_fs19.readdirSync)(dir);
+        names = (0, import_fs20.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 path60 = (0, import_path21.join)(dir, name);
+        const path60 = (0, import_path222.join)(dir, name);
         result.filesScanned++;
         const claimed = `${path60}.migrating`;
         try {
-          (0, import_fs19.renameSync)(path60, claimed);
+          (0, import_fs20.renameSync)(path60, claimed);
         } catch {
           continue;
         }
         let content;
         try {
-          content = (0, import_fs19.readFileSync)(claimed, "utf-8");
+          content = (0, import_fs20.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, path60);
+            (0, import_fs20.renameSync)(claimed, path60);
           } catch {
           }
           result.filesRetained++;
@@ -133913,14 +134458,14 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!allImported) {
           try {
-            (0, import_fs19.renameSync)(claimed, path60);
+            (0, import_fs20.renameSync)(claimed, path60);
           } catch {
           }
           result.filesRetained++;
           continue;
         }
         try {
-          (0, import_fs19.unlinkSync)(claimed);
+          (0, import_fs20.unlinkSync)(claimed);
           result.filesRemoved++;
         } catch (e) {
           LOG2.warn("MeshEvents", `Pending-events migration: imported ${name} but could not unlink it: ${e?.message || e}`);
@@ -135339,14 +135884,77 @@ function createLineParser(onEnvelope) {
     }
   };
 }
+var establishedSockets = /* @__PURE__ */ new WeakSet();
 var SessionHostClient = class {
   endpoint;
   socket = null;
   requestWaiters = /* @__PURE__ */ new Map();
   eventListeners = /* @__PURE__ */ new Set();
+  disconnectListeners = /* @__PURE__ */ new Set();
+  /** Guards against emitting both an 'error'-path and a 'close'-path disconnect for one socket. */
+  disconnectedSockets = /* @__PURE__ */ new WeakSet();
   constructor(options = {}) {
     this.endpoint = options.endpoint || getDefaultSessionHostEndpoint(options.appName || "adhdev");
   }
+  /**
+   * Fires when an established connection to the session host goes away.
+   *
+   * Before this existed the client registered only 'data' and 'error' handlers,
+   * so a *clean* FIN — the host process exiting normally, or dying to an
+   * uncaught exception that took the socket down without an error event on our
+   * end — ran nothing at all: `this.socket` stayed non-null pointing at a dead
+   * socket, in-flight waiters hung to their 30s timeout, and no caller was told.
+   * That silence is what let a session-host death present downstream as an
+   * unrelated application-level fault (a missing completion marker) instead of
+   * "the host is gone".
+   */
+  onDisconnect(listener) {
+    this.disconnectListeners.add(listener);
+    return () => {
+      this.disconnectListeners.delete(listener);
+    };
+  }
+  handleDisconnect(socket, reason, error48) {
+    if (this.disconnectedSockets.has(socket)) return;
+    this.disconnectedSockets.add(socket);
+    const wasEstablished = establishedSockets.has(socket);
+    if (!wasEstablished) {
+      if (this.socket === socket) this.socket = null;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      const failure2 = error48 || new Error(`Session host connect failed (${this.endpoint.path})`);
+      for (const waiter of this.requestWaiters.values()) waiter.reject(failure2);
+      this.requestWaiters.clear();
+      return;
+    }
+    const pendingRequests = this.requestWaiters.size;
+    const failure = error48 || new Error(`Session host connection ${reason} (${this.endpoint.path})`);
+    for (const waiter of this.requestWaiters.values()) {
+      waiter.reject(failure);
+    }
+    this.requestWaiters.clear();
+    if (this.socket === socket) {
+      this.socket = null;
+    }
+    try {
+      socket.destroy();
+    } catch {
+    }
+    const info = {
+      reason,
+      endpointPath: this.endpoint.path,
+      pendingRequests,
+      error: error48
+    };
+    for (const listener of this.disconnectListeners) {
+      try {
+        listener(info);
+      } catch {
+      }
+    }
+  }
   async connect() {
     if (this.socket && !this.socket.destroyed) return;
     if (this.socket) {
@@ -135372,20 +135980,19 @@ var SessionHostClient = class {
       }
     }));
     socket.on("error", (error48) => {
-      for (const waiter of this.requestWaiters.values()) {
-        waiter.reject(error48);
-      }
-      this.requestWaiters.clear();
-      if (this.socket === socket) {
-        this.socket = null;
-      }
-      try {
-        socket.destroy();
-      } catch {
-      }
+      this.handleDisconnect(socket, "error", error48);
+    });
+    socket.on("close", () => {
+      this.handleDisconnect(socket, "closed");
+    });
+    socket.on("end", () => {
+      this.handleDisconnect(socket, "ended");
     });
     await new Promise((resolve3, reject) => {
-      socket.once("connect", () => resolve3());
+      socket.once("connect", () => {
+        establishedSockets.add(socket);
+        resolve3();
+      });
       socket.once("error", reject);
     });
   }
@@ -135427,6 +136034,7 @@ var SessionHostClient = class {
     if (!this.socket) return;
     const socket = this.socket;
     this.socket = null;
+    this.disconnectedSockets.add(socket);
     for (const waiter of this.requestWaiters.values()) {
       waiter.reject(new Error("Session host client closed"));
     }