@adhdev/daemon-standalone 1.0.58-rc.2 → 1.0.58-rc.4

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 ? "8e051f2dacc04bd04da37212168709c3ade00877" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "8e051f2d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-22T14:13:56.874Z" : void 0);
+      const commit = readInjected(true ? "388d6e74b391ae9afd94d860aed141063297dca9" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "388d6e74" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.4" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-23T04:11:22.908Z" : 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;
@@ -44117,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;
@@ -44220,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(/\/+$/, "");
@@ -44260,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");
@@ -44289,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;
@@ -44302,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;
@@ -44349,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");
@@ -44373,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;
@@ -44401,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;
@@ -44466,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;
@@ -44546,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;
@@ -44570,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;
@@ -44617,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;
@@ -44629,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;
@@ -44759,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);
@@ -44776,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);
@@ -44813,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);
@@ -44859,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);
@@ -44876,6 +45056,10 @@ ${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;
@@ -44894,6 +45078,10 @@ ${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;
@@ -49721,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() : "";
@@ -50227,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,
@@ -51125,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"];
@@ -57908,6 +58268,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           "task_approval_needed",
           "task_question_pending",
           "p2p_dispatch_failed",
+          "dispatch_failed",
           "dispatch_duplicate_rebound",
           "queue_hold_hard_deadline"
         ]);
@@ -61442,6 +61803,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 {
       }
@@ -61801,7 +62166,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,
@@ -61809,6 +62174,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}`);
       }
@@ -68019,7 +68387,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 {
@@ -68690,6 +69058,146 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         CLASSIFIED_DIFFICULTIES = ["easy", "medium", "difficult"];
       }
     });
+    function normalizeProviderPriority2(policy) {
+      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
+      if (!Array.isArray(raw)) return [];
+      const seen = /* @__PURE__ */ new Set();
+      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
+        if (seen.has(type2)) return false;
+        seen.add(type2);
+        return true;
+      });
+    }
+    function isTerminalSessionStatus(status) {
+      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
+    }
+    function isIdleSessionState3(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      if (isTerminalSessionStatus(status)) return false;
+      return status === "idle" || state?.activeChat?.status === "waiting_input";
+    }
+    function sessionStateLooksActive(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
+      const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
+      return active.has(status) || active.has(chatStatus);
+    }
+    function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
+      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState3(state)) return false;
+        return sessionStateLooksActive(state);
+      });
+    }
+    function isLaunchableNode(node) {
+      if (!node || node.status === "disabled" || node.status === "removed") return false;
+      if (shouldDeferDispatchForBootstrap(node)) {
+        return false;
+      }
+      return isMeshNodeHealthLaunchable(node);
+    }
+    function isLocalAutoLaunchNode(node) {
+      const daemonId = readNonEmptyString(node?.daemonId);
+      const machineId = readNonEmptyString(node?.machineId);
+      const appConfig = loadConfig2();
+      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
+      const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
+      const machineMatchesLocal = !machineId || daemonIdsEquivalent(machineId, localMachineId);
+      if (node?.isLocalWorktree === true) {
+        return daemonMatchesLocal && machineMatchesLocal;
+      }
+      if (daemonId || machineId) {
+        return daemonMatchesLocal && machineMatchesLocal;
+      }
+      return true;
+    }
+    function isSessionActivelyGenerating(components, sessionId) {
+      if (!sessionId) return false;
+      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+      if (!state) return false;
+      return sessionStateLooksActive(state);
+    }
+    function resolveSessionBusyVerdict(components, sessionId) {
+      if (!sessionId) return "UNKNOWN";
+      try {
+        const instances = components.instanceManager?.getByCategory?.("cli") || [];
+        const inst = instances.find((i) => {
+          const sid = readNonEmptyString(i?.getState?.().instanceId);
+          return sid && sessionIdsEquivalent(sid, sessionId);
+        });
+        if (!inst) return "UNKNOWN";
+        const state = inst.getState?.();
+        if (!state) return "UNKNOWN";
+        return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
+      } catch {
+        return "UNKNOWN";
+      }
+    }
+    function liveSessionCountForNode(components, meshId, nodeId) {
+      const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        return !isTerminalSessionStatus(status);
+      });
+      let count = localInstances.length;
+      const localSessionIds = localInstances.map((inst) => readNonEmptyString(inst.getState().instanceId)).filter(Boolean);
+      for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
+        if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
+      }
+      return count;
+    }
+    function nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
+      if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
+      const busySessionIds = new Set(
+        getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
+      );
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        if (readNonEmptyString(settings.meshCoordinatorFor) === meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        if (isTerminalSessionStatus(status)) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (sessionId && busySessionIds.has(sessionId)) return false;
+        const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
+        if (task.requiredTags?.length) {
+          if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
+            return false;
+          }
+        }
+        const allowance = allowedClassifiedDifficultiesForSession(node, resolveNodeCapabilitySlots(node, meshId), sessionProviderType, readSessionModel(state));
+        if (!taskMeetsSessionDifficultyFloor(task, allowance)) return false;
+        return true;
+      });
+    }
+    var init_mesh_candidacy_predicates = __esm2({
+      "src/mesh/mesh-candidacy-predicates.ts"() {
+        "use strict";
+        init_config();
+        init_mesh_work_queue();
+        init_dist();
+        init_mesh_events_utils();
+        init_mesh_node_identity();
+        init_worktree_bootstrap_config();
+        init_mesh_autolaunch_integrity();
+        init_mesh_scheduling_fitness();
+        init_mesh_node_slots();
+        init_mesh_difficulty_floor();
+      }
+    });
     function localCoordinatorDaemonId2() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
@@ -68886,6 +69394,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({
@@ -68934,6 +69443,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" });
@@ -68954,6 +69464,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
         try {
           appendLedgerEntry(ctx.meshId, {
+            // 'dispatch_failed' is a real MeshLedgerKind and a member of
+            // TASK_LIFECYCLE_LEDGER_KINDS, so appendLedgerEntry derives the top-level
+            // taskId from payload.taskId below. It spent its whole life as
+            // `as any` — off the union, hence off the lifecycle set, hence written to
+            // the indexed SQLite task_id column as NULL and unreachable by the
+            // kind+taskId join every reader uses. Do not reintroduce the cast.
             kind: "dispatch_failed",
             nodeId: ctx.nodeId,
             sessionId: ctx.sessionId,
@@ -69299,65 +69815,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (now >= until) autoLaunchCooldownUntil.delete(key2);
       }
     }
-    function normalizeProviderPriority2(policy) {
-      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
-      if (!Array.isArray(raw)) return [];
-      const seen = /* @__PURE__ */ new Set();
-      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
-        if (seen.has(type2)) return false;
-        seen.add(type2);
-        return true;
-      });
-    }
-    function isTerminalSessionStatus(status) {
-      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
-    }
-    function isIdleSessionState3(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      if (isTerminalSessionStatus(status)) return false;
-      return status === "idle" || state?.activeChat?.status === "waiting_input";
-    }
-    function sessionStateLooksActive(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
-      const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
-      return active.has(status) || active.has(chatStatus);
-    }
-    function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
-      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
-      return components.instanceManager.getByCategory("cli").some((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const sessionId = readNonEmptyString(state.instanceId);
-        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState3(state)) return false;
-        return sessionStateLooksActive(state);
-      });
-    }
-    function isLaunchableNode(node) {
-      if (!node || node.status === "disabled" || node.status === "removed") return false;
-      if (shouldDeferDispatchForBootstrap(node)) {
-        return false;
-      }
-      return isMeshNodeHealthLaunchable(node);
-    }
-    function isLocalAutoLaunchNode(node) {
-      const daemonId = readNonEmptyString(node?.daemonId);
-      const machineId = readNonEmptyString(node?.machineId);
-      const appConfig = loadConfig2();
-      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
-      const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
-      const machineMatchesLocal = !machineId || daemonIdsEquivalent(machineId, localMachineId);
-      if (node?.isLocalWorktree === true) {
-        return daemonMatchesLocal && machineMatchesLocal;
-      }
-      if (daemonId || machineId) {
-        return daemonMatchesLocal && machineMatchesLocal;
-      }
-      return true;
-    }
     function resolveAutoLaunchTarget(components, node) {
       if (isLocalAutoLaunchNode(node)) return { mode: "local" };
       const daemonId = readMeshNodeDaemonId(node ?? {});
@@ -69367,72 +69824,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
       return { mode: "remote", daemonId, coordinatorDaemonId };
     }
-    function isSessionActivelyGenerating(components, sessionId) {
-      if (!sessionId) return false;
-      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
-      if (!state) return false;
-      return sessionStateLooksActive(state);
-    }
-    function resolveSessionBusyVerdict(components, sessionId) {
-      if (!sessionId) return "UNKNOWN";
-      try {
-        const instances = components.instanceManager?.getByCategory?.("cli") || [];
-        const inst = instances.find((i) => {
-          const sid = readNonEmptyString(i?.getState?.().instanceId);
-          return sid && sessionIdsEquivalent(sid, sessionId);
-        });
-        if (!inst) return "UNKNOWN";
-        const state = inst.getState?.();
-        if (!state) return "UNKNOWN";
-        return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
-      } catch {
-        return "UNKNOWN";
-      }
-    }
-    function liveSessionCountForNode(components, meshId, nodeId) {
-      const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        return !isTerminalSessionStatus(status);
-      });
-      let count = localInstances.length;
-      const localSessionIds = localInstances.map((inst) => readNonEmptyString(inst.getState().instanceId)).filter(Boolean);
-      for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
-        if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
-      }
-      return count;
-    }
-    function nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
-      if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
-      const busySessionIds = new Set(
-        getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
-      );
-      return components.instanceManager.getByCategory("cli").some((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        if (readNonEmptyString(settings.meshCoordinatorFor) === meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        if (isTerminalSessionStatus(status)) return false;
-        const sessionId = readNonEmptyString(state.instanceId);
-        if (sessionId && busySessionIds.has(sessionId)) return false;
-        const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
-        if (task.requiredTags?.length) {
-          if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
-            return false;
-          }
-        }
-        const allowance = allowedClassifiedDifficultiesForSession(node, resolveNodeCapabilitySlots(node, meshId), sessionProviderType, readSessionModel(state));
-        if (!taskMeetsSessionDifficultyFloor(task, allowance)) return false;
-        return true;
-      });
-    }
     function markAutoLaunch(meshId, taskId, args) {
       const reason = args.reason || args.error;
       const difficultyFloorSkip = args.status === "skipped" && isDifficultyFloorWaitReason(reason);
@@ -70172,6 +70563,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_routing_decision();
         init_mesh_autolaunch_integrity();
         init_mesh_difficulty_floor();
+        init_mesh_candidacy_predicates();
         init_mesh_difficulty_floor();
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
@@ -74573,148 +74965,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) {
@@ -74946,6 +75196,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);
     }
@@ -74980,7 +75333,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}`);
@@ -74988,18 +75341,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 {
         }
@@ -75026,22 +75379,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 {
@@ -75087,7 +75440,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 : [];
@@ -75138,7 +75499,7 @@ ${cleanBody}`;
       }
       return signalled;
     }
-    var import_fs16;
+    var import_fs17;
     var import_path14;
     var DAY_MS2;
     var LEDGER_JSONL_MAX_AGE_MS;
@@ -75148,13 +75509,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;
@@ -76167,6 +76529,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",
@@ -76222,6 +76585,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;
@@ -81175,6 +81559,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 {
@@ -81220,8 +81667,52 @@ ${cleanBody}`;
       }
       return false;
     }
+    function probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit) return "undeterminable";
+      if (baseCommit === branchCommit) return true;
+      return probeGitAncestry(submoduleRepoPath, baseCommit, branchCommit);
+    }
+    function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
+      return probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) === true;
+    }
+    function buildGitlinkFastForwardUndeterminableWarning(label, gitlinks) {
+      const entries = gitlinks.filter((entry) => entry.fastForwardUndeterminable);
+      if (entries.length === 0) return void 0;
+      const detail = entries.map((entry) => `${entry.path} (base=${(entry.baseCommit || "?").slice(0, 12)} branch=${(entry.branchCommit || "?").slice(0, 12)})`).join(", ");
+      return `[Refinery] Could NOT determine submodule gitlink fast-forward for ${label} \u2014 ancestry probe had NO ANSWER (a gitlink commit is missing from the local submodule object store, or the submodule checkout is absent). "undeterminable", NOT "diverged": ${detail}`;
+    }
+    function warnGitlinkFastForwardUndeterminable(label, gitlinks) {
+      const message = buildGitlinkFastForwardUndeterminableWarning(label, gitlinks);
+      if (message) LOG2.warn("Mesh", message);
+    }
+    function readChangedPathKinds(repoRoot, fromRef, toRef) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+        });
+        const result = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const metaAndPath = line.split("	");
+          const meta3 = metaAndPath[0] || "";
+          const path60 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path60 || seen.has(path60)) continue;
+          seen.add(path60);
+          const parts = meta3.split(/\s+/);
+          const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
+          result.push({ path: path60, isGitlink });
+        }
+        return result;
+      } catch {
+        return [];
+      }
+    }
     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({
@@ -81229,6 +81720,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;
@@ -81302,7 +81795,16 @@ ${cleanBody}`;
       }
       return void 0;
     }
-    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
+    function isCommitReachableFromRemoteMain(submoduleRepoPath, commit, remoteMainRef) {
+      if (!remoteMainRef) return false;
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", commit, remoteMainRef], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead, options = {}) {
       const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
       if (changed.length === 0) {
         return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
@@ -81314,9 +81816,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 = [];
@@ -81354,6 +81856,30 @@ ${cleanBody}`;
           resolutions.push({ path: path60, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
           continue;
         }
+        const branchAlreadyPublished = isCommitReachableFromRemoteMain(submoduleRepoPath, branchCommit, remoteMainRef);
+        const willMintUnpublishedCommit = !branchAlreadyPublished;
+        const wouldConflict = (() => {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+              cwd: submoduleRepoPath,
+              encoding: "utf8",
+              stdio: ["ignore", "pipe", "pipe"]
+            });
+            return false;
+          } catch {
+            return true;
+          }
+        })();
+        if (willMintUnpublishedCommit && !wouldConflict && options.allowAutoPublishSubmoduleMainCommits !== true) {
+          gitlinks.push({
+            path: path60,
+            baseCommit,
+            branchCommit,
+            action: "publish_required_before_rebase",
+            remoteMainRef
+          });
+          return { converged: false, reason: "submodule_publish_required", resolutions: [], gitlinks };
+        }
         let rebasedCommit;
         try {
           (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
@@ -81393,7 +81919,14 @@ ${cleanBody}`;
           gitlinks.push({ path: path60, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
           return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
         }
-        gitlinks.push({ path: path60, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        gitlinks.push({
+          path: path60,
+          baseCommit,
+          branchCommit,
+          rebasedCommit,
+          action: "rebased",
+          ...willMintUnpublishedCommit ? { mintedUnpublishedCommit: true, remoteMainRef } : {}
+        });
         resolutions.push({ path: path60, baseCommit, branchCommit, rebasedCommit });
       }
       if (!sawDiverged) {
@@ -81402,6 +81935,31 @@ ${cleanBody}`;
       }
       return { converged: resolutions.length > 0, resolutions, gitlinks };
     }
+    function describeSubmodulePublishRequired(nodeId, gitlinks) {
+      const pending = gitlinks.filter((g) => g.action === "publish_required_before_rebase");
+      return `[Refinery] Refusing to auto-converge diverged submodule gitlink(s) for node ${nodeId} \u2014 the rebase would create a NEW submodule commit that is not reachable from the submodule remote, and allowAutoPublishSubmoduleMainCommits is disabled, so the reachability gate would reject it. The branch was left untouched. NEXT STEP: publish the branch-side submodule commit(s) to submodule origin main, then rerun mesh_refine_node \u2014 do NOT rebase: ` + pending.map((g) => `${g.path} (branch=${(g.branchCommit || "?").slice(0, 12)} base=${(g.baseCommit || "?").slice(0, 12)} remote=${g.remoteMainRef || "unresolved"})`).join(", ");
+    }
+    function describeSubmoduleConvergeDecline(nodeId, reason, gitlinks) {
+      if (reason === "submodule_publish_required") {
+        return describeSubmodulePublishRequired(nodeId, gitlinks);
+      }
+      if (reason === "submodule_commit_unavailable") {
+        return `[Refinery] Could NOT determine submodule gitlink divergence for node ${nodeId} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", ");
+      }
+      return void 0;
+    }
+    function buildSubmoduleConvergeDeclineDetails(reason, autoPublishEnabled) {
+      if (reason !== "submodule_publish_required") return {};
+      return {
+        recommendedAction: SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION,
+        autoPublishAllowed: autoPublishEnabled
+      };
+    }
+    function describeMintedUnpublishedCommits(nodeId, gitlinks, autoPublishEnabled) {
+      const minted = gitlinks.filter((g) => g.mintedUnpublishedCommit);
+      if (minted.length === 0) return void 0;
+      return `[Refinery] Node ${nodeId}: the convergence MINTED ${minted.length} new submodule commit(s) not reachable from the submodule remote (allowed because allowAutoPublishSubmoduleMainCommits=${autoPublishEnabled}); a publish is still required before merge: ` + minted.map((g) => `${g.path}\u2192${(g.rebasedCommit || "?").slice(0, 12)} (remote=${g.remoteMainRef || "unresolved"})`).join(", ");
+    }
     function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
       const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
       const runRebase = (args) => {
@@ -81462,7 +82020,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 {
@@ -81481,15 +82039,17 @@ ${cleanBody}`;
       return { ok: true, branchHead };
     }
     var fs52;
-    var import_path17;
+    var import_path18;
     var import_node_child_process12;
+    var SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION;
     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();
+        SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION = "Publish the branch-side submodule commit(s) to submodule origin main, then rerun mesh_refine_node. Do NOT retry the rebase: the branch was intentionally left unrewritten because a rebase here would mint a submodule commit the reachability gate must reject.";
       }
     });
     function truncateValidationOutput(value) {
@@ -81509,10 +82069,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(
@@ -81632,6 +82192,7 @@ ${mergeTreeErr?.stderr || ""}`;
           if (!isSubmoduleConflict) throw mergeTreeErr;
           const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead);
           if (!evaluation.trivial) {
+            warnGitlinkFastForwardUndeterminable("patch-equivalence gate", evaluation.gitlinks);
             return {
               status: "failed",
               equivalent: false,
@@ -81700,9 +82261,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,
@@ -81719,14 +82286,6 @@ ${e?.stderr || ""}`
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
           windowsHide: true
         });
-        const gitOk = (args) => {
-          try {
-            git3(args);
-            return true;
-          } catch {
-            return false;
-          }
-        };
         let ahead = 0;
         let behind = 0;
         try {
@@ -81738,8 +82297,13 @@ ${e?.stderr || ""}`
         }
         evidence.ahead = ahead;
         evidence.behind = behind;
-        const baseIsAncestor = gitOk(["merge-base", "--is-ancestor", targetBaseRef, branchHead]);
-        evidence.baseDiverged = !baseIsAncestor;
+        const baseAncestry = probeGitAncestry(repoRoot, targetBaseRef, branchHead);
+        const baseIsAncestor = baseAncestry === true;
+        if (baseAncestry === "undeterminable") {
+          evidence.baseAncestryUndeterminable = true;
+        } else {
+          evidence.baseDiverged = !baseAncestry;
+        }
         let diffStat = "";
         try {
           if (summary.mergedTree) {
@@ -81767,20 +82331,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) {
@@ -81801,6 +82364,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);
@@ -81812,6 +82384,14 @@ ${e?.stderr || ""}`
             evidence
           };
         }
+        if (baseAncestry === "undeterminable") {
+          return {
+            detailedReason: "base_ancestry_undeterminable",
+            detailedReasonDescription: `Could NOT determine whether HEAD descends ${targetBaseRef} \u2014 the ancestry probe had no answer (${targetBaseRef} and/or ${branchHead.slice(0, 12)} does not resolve in ${repoRoot}). This is "undeterminable", NOT "diverged": the ahead/behind counts above are unmeasured, not zero.`,
+            recommendedAction: `Make the probe answerable before judging: fetch/verify that ${targetBaseRef} and the branch head both resolve in ${repoRoot} (e.g. git fetch origin, git rev-parse --verify), then retry mesh_refine_node. Do NOT rebase on the strength of this result \u2014 no divergence has been measured.`,
+            evidence
+          };
+        }
         if (!baseIsAncestor) {
           return {
             detailedReason: "base_divergence",
@@ -81836,14 +82416,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 {
@@ -81865,6 +82437,7 @@ ${mergeTreeErr?.stderr || ""}`;
           if (!isSubmoduleConflict) throw mergeTreeErr;
           const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, ref, worktreeHead);
           if (!evaluation.trivial) {
+            warnGitlinkFastForwardUndeterminable(`containment check for ${ref}`, evaluation.gitlinks);
             return {
               contained: false,
               ref,
@@ -81994,50 +82567,12 @@ ${mergeTreeErr?.stderr || ""}`;
       }).trim();
       return out;
     }
-    function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
-      if (!baseCommit || !branchCommit) return false;
-      if (baseCommit === branchCommit) return true;
-      try {
-        if (!fs53.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    function readChangedPathKinds(repoRoot, fromRef, toRef) {
-      try {
-        const output = (0, import_node_child_process13.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
-        });
-        const result = [];
-        const seen = /* @__PURE__ */ new Set();
-        for (const line of output.split("\n")) {
-          if (!line.trim()) continue;
-          const metaAndPath = line.split("	");
-          const meta3 = metaAndPath[0] || "";
-          const path60 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path60 || seen.has(path60)) continue;
-          seen.add(path60);
-          const parts = meta3.split(/\s+/);
-          const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
-          result.push({ path: path60, isGitlink });
-        }
-        return result;
-      } catch {
-        return [];
-      }
-    }
     function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
       return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path60) => {
         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) {
@@ -82046,8 +82581,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;
         }
@@ -82063,20 +82598,28 @@ ${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 fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
-        return { path: path60, baseCommit, branchCommit, fastForward };
+        const submoduleRepoPath = (0, import_path19.resolve)(repoRoot, path60);
+        const probe = !!baseCommit && !!branchCommit ? probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) : "undeterminable";
+        return {
+          path: path60,
+          baseCommit,
+          branchCommit,
+          fastForward: probe === true,
+          ...probe === "undeterminable" ? { fastForwardUndeterminable: true } : {}
+        };
       });
       if (changedGitlinks.length === 0) {
         return { trivial: false, reason: "no_changed_gitlinks", gitlinks: changedGitlinks };
       }
-      const nonFastForward = changedGitlinks.filter((entry) => !entry.fastForward);
-      if (nonFastForward.length > 0) {
-        return {
-          trivial: false,
-          reason: `diverged_gitlinks:${nonFastForward.map((entry) => entry.path).join(",")}`,
-          gitlinks: changedGitlinks
-        };
+      const undeterminable = changedGitlinks.filter((entry) => entry.fastForwardUndeterminable);
+      const diverged = changedGitlinks.filter((entry) => !entry.fastForward && !entry.fastForwardUndeterminable);
+      if (undeterminable.length > 0 || diverged.length > 0) {
+        const parts = [];
+        if (diverged.length > 0) parts.push(`diverged_gitlinks:${diverged.map((entry) => entry.path).join(",")}`);
+        if (undeterminable.length > 0) {
+          parts.push(`undeterminable_gitlinks:${undeterminable.map((entry) => entry.path).join(",")}`);
+        }
+        return { trivial: false, reason: parts.join(" "), gitlinks: changedGitlinks };
       }
       let mergeBase = "";
       try {
@@ -82118,7 +82661,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" });
@@ -82193,7 +82736,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" });
@@ -82350,7 +82893,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,
@@ -82377,7 +82920,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;
@@ -82607,13 +83150,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) => {
@@ -82680,7 +83223,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);
@@ -82713,7 +83256,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)) {
@@ -82780,7 +83323,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;
@@ -82795,19 +83338,20 @@ ${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();
         init_mesh_refine_worker_cap();
         init_mesh_refine_gitlink_utils();
         init_mesh_refine_submodule_converge();
+        init_mesh_refine_gitlink_utils();
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
         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) {
@@ -83791,7 +84335,14 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
           return { kind: "continue", ctx };
         }
         if (submoduleConflict) {
-          const converge = convergeDivergedSubmoduleGitlinks(node.workspace, repoRoot, baseHead, branchHead);
+          const convergeAutoPublish = resolveRefineryAutoPublishSubmoduleMainCommits(ctx.mesh, node.workspace);
+          const converge = convergeDivergedSubmoduleGitlinks(
+            node.workspace,
+            repoRoot,
+            baseHead,
+            branchHead,
+            { allowAutoPublishSubmoduleMainCommits: convergeAutoPublish.enabled }
+          );
           if (converge.converged) {
             gitlinkResolutions = converge.resolutions;
             recordMeshRefineStage(refineStages, "submodule_gitlink_converge", "passed", syncStarted, {
@@ -83799,15 +84350,19 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
               gitlinks: converge.gitlinks
             });
             LOG2.info("Mesh", `[Refinery] Auto-converged diverged submodule gitlink(s) onto base for node ${node.id}: ` + converge.resolutions.map((r) => `${r.path}\u2192${r.rebasedCommit.slice(0, 12)}`).join(", "));
+            const minted = describeMintedUnpublishedCommits(node.id, converge.gitlinks, convergeAutoPublish.enabled);
+            if (minted) LOG2.warn("Mesh", minted);
           } else {
             recordMeshRefineStage(refineStages, "submodule_gitlink_converge", "skipped", syncStarted, {
               reason: "submodule_conflict_defer_to_patch_equivalence",
               convergeReason: converge.reason,
-              gitlinks: converge.gitlinks
+              gitlinks: converge.gitlinks,
+              // ★Structural next step, so the coordinator is told to PUBLISH
+              // rather than retry the rebase (retrying re-mints the orphan).
+              ...buildSubmoduleConvergeDeclineDetails(converge.reason, convergeAutoPublish.enabled)
             });
-            if (converge.reason === "submodule_commit_unavailable") {
-              LOG2.warn("Mesh", `[Refinery] Could NOT determine submodule gitlink divergence for node ${node.id} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + converge.gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", "));
-            }
+            const declined = describeSubmoduleConvergeDecline(node.id, converge.reason, converge.gitlinks);
+            if (declined) LOG2.warn("Mesh", declined);
             recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
               ahead: divergence.ahead,
               behind: divergence.behind,
@@ -83889,16 +84444,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",
@@ -84082,19 +84632,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,
@@ -85473,6 +86019,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,
@@ -85497,8 +86047,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,
@@ -85628,9 +86181,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,
@@ -85682,6 +86237,7 @@ ${e?.stderr || ""}`;
       deriveMeshReviewInboxItems: () => deriveMeshReviewInboxItems,
       deriveWorkspaceBranchIdentity: () => deriveWorkspaceBranchIdentity,
       deriveWorkspaceOwnerTag: () => deriveWorkspaceOwnerTag,
+      describeDiskSpace: () => describeDiskSpace,
       describeTaskDependencyState: () => describeTaskDependencyState,
       detectAllVersions: () => detectAllVersions,
       detectCLI: () => detectCLI,
@@ -85717,6 +86273,7 @@ ${e?.stderr || ""}`;
       flattenMessageParts: () => flattenMessageParts,
       foldUsageRecords: () => foldUsageRecords,
       forceRefreshQuota: () => forceRefreshQuota2,
+      formatBytes: () => formatBytes,
       formatManifestValidationIssues: () => formatManifestValidationIssues,
       formatMeshTaskModeViolations: () => formatMeshTaskModeViolations,
       forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance2,
@@ -85834,6 +86391,7 @@ ${e?.stderr || ""}`;
       loadRepoSettings: () => loadRepoSettings,
       loadState: () => loadState,
       logCommand: () => logCommand,
+      logDiskSpaceStatus: () => logDiskSpaceStatus,
       machineCoreFromDaemonId: () => machineCoreFromDaemonId,
       magiAutoLaunchedSessionCleanupDecision: () => magiAutoLaunchedSessionCleanupDecision,
       makeUsage: () => makeUsage,
@@ -85890,6 +86448,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,
@@ -85911,6 +86470,7 @@ ${e?.stderr || ""}`;
       readChatHistory: () => readChatHistory,
       readClaudeCliSession: () => readSession,
       readCodexCliSession: () => readSession2,
+      readDiskSpace: () => readDiskSpace,
       readHermesCliSession: () => readSession4,
       readLatestCodexRateLimits: () => readLatestCodexRateLimits,
       readLedgerEntries: () => readLedgerEntries,
@@ -85992,6 +86552,7 @@ ${e?.stderr || ""}`;
       resolveTurnAttemptRow: () => resolveTurnAttemptRow,
       resolveWorktreeBaseDir: () => resolveWorktreeBaseDir,
       resolveWorktreePath: () => resolveWorktreePath,
+      rotateCaptureLogIfNeeded: () => rotateCaptureLogIfNeeded,
       runAsyncBatch: () => runAsyncBatch2,
       runGit: () => runGit,
       runMeshWorktreeBootstrap: () => runMeshWorktreeBootstrap,
@@ -89543,7 +90104,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"));
@@ -89620,7 +90181,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 ? ";" : ":");
@@ -89630,8 +90191,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;
               }
@@ -89649,9 +90210,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;
@@ -89665,7 +90226,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");
@@ -89678,7 +90239,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;
             }
@@ -101316,7 +101877,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"));
@@ -112640,7 +113201,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], {
@@ -112786,10 +113347,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) {
@@ -120541,7 +121102,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);
@@ -120582,7 +121143,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 {
@@ -120652,7 +121213,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];
@@ -120717,7 +121278,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,
@@ -121674,7 +122235,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));
@@ -121807,14 +122368,14 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         let daemonId;
         if (nodeId) {
           try {
-            const [{ getMesh: getMesh2 }, { meshNodeIdMatches: meshNodeIdMatches2 }, { readMeshNodeDaemonId: readMeshNodeDaemonId2 }] = await Promise.all([
+            const [{ getMesh: getMesh2 }, { meshNodeIdMatches: meshNodeIdMatches2 }, { readMeshNodeDaemonId: readMeshNodeDaemonId3 }] = await Promise.all([
               Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)),
               Promise.resolve().then(() => (init_dist(), dist_exports)),
               Promise.resolve().then(() => (init_mesh_node_identity(), mesh_node_identity_exports))
             ]);
             const mesh = getMesh2(meshId);
             const node = mesh?.nodes?.find((n) => meshNodeIdMatches2(n, nodeId));
-            daemonId = node ? readMeshNodeDaemonId2(node) || void 0 : void 0;
+            daemonId = node ? readMeshNodeDaemonId3(node) || void 0 : void 0;
           } catch {
           }
         }
@@ -123026,7 +123587,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;
@@ -123064,7 +123625,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);
@@ -124092,7 +124653,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();
@@ -124104,7 +124665,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
@@ -124131,8 +124692,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) {
@@ -124242,7 +124803,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 {
@@ -124369,7 +124930,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 {
@@ -125037,7 +125598,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) {
@@ -125078,13 +125639,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 };
@@ -125118,10 +125679,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);
@@ -126258,6 +126819,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_track_identity();
     init_normalize();
     init_logger();
+    init_disk_space_preflight();
     var UNICODE_SYMBOLS = {
       ok: "\u2713",
       fail: "\u2717",
@@ -133326,6 +133888,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;
@@ -133429,6 +133992,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;
@@ -133444,7 +134008,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);
@@ -133895,8 +134472,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();
@@ -133964,31 +134541,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++;
@@ -134003,14 +134580,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}`);
@@ -135429,14 +136006,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) {
@@ -135462,20 +136102,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);
     });
   }
@@ -135517,6 +136156,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"));
     }