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

package/dist/index.js

@@ -63,6 +63,7 @@ var require_config_dir = __commonJS({
       detectOccupiedConfigDir: () => detectOccupiedConfigDir2,
       formatOccupiedConfigDirWarning: () => formatOccupiedConfigDirWarning2,
       isCrossTrackConfigDirOverride: () => isCrossTrackConfigDirOverride,
+      isTestRuntimeEnv: () => isTestRuntimeEnv,
       otherTrackConfigDir: () => otherTrackConfigDir,
       resolveConfigDir: () => resolveConfigDir,
       resolveConfigLogsDir: () => resolveConfigLogsDir
@@ -104,17 +105,56 @@ var require_config_dir = __commonJS({
     }
     var IDENTITY = getTrackIdentity(TRACK);
     var DEFAULT_CONFIG_DIR_NAME = ".adhdev";
+    function isTestRuntimeEnv(env2 = process.env) {
+      if (env2.VITEST) return true;
+      if (env2.NODE_ENV === "test") return true;
+      if (env2.NODE_TEST_CONTEXT) return true;
+      return false;
+    }
     function resolveConfigDir(env2 = process.env, homeDir) {
       const override = env2.ADHDEV_CONFIG_DIR;
-      if (override && override.trim()) return override.trim();
-      assertConfigDirPinnedInTestRuntime(env2);
+      if (override && override.trim()) {
+        const resolved = override.trim();
+        assertConfigDirIsolatedInTestRuntime(env2, resolved);
+        return resolved;
+      }
+      assertConfigDirIsolatedInTestRuntime(env2);
       return (0, import_path2.join)(homeDir ?? (0, import_os2.homedir)(), getTrackIdentity(resolveBuildTrack(env2)).configDirName);
     }
-    function assertConfigDirPinnedInTestRuntime(env2) {
+    function normalizeConfigPath(p, platform = process.platform) {
+      const unified = p.trim().replace(/[\\/]+$/, "").replace(/\\/g, "/");
+      return platform === "win32" ? unified.toLowerCase() : unified;
+    }
+    function liveTrackHomeDirs(homeDir = (0, import_os2.homedir)()) {
+      return [
+        (0, import_path2.join)(homeDir, getTrackIdentity("stable").configDirName),
+        (0, import_path2.join)(homeDir, getTrackIdentity("preview").configDirName)
+      ];
+    }
+    var ORIGINAL_HOME_DIR = typeof process.env.HOME === "string" && process.env.HOME.trim() !== "" ? process.env.HOME.trim() : typeof process.env.USERPROFILE === "string" ? process.env.USERPROFILE.trim() : "";
+    function isLiveTrackHomeDir(resolved, homeDir) {
+      const needle = normalizeConfigPath(resolved);
+      const bases = homeDir !== void 0 ? [homeDir] : [ORIGINAL_HOME_DIR].filter((v) => v !== "");
+      return bases.some((base) => liveTrackHomeDirs(base).some((live) => normalizeConfigPath(live) === needle));
+    }
+    function processLooksLikeNodeTestRunner() {
+      return process.execArgv.some((arg) => arg === "--test" || arg.startsWith("--test="));
+    }
+    function assertConfigDirIsolatedInTestRuntime(env2, resolvedOverride) {
       if (env2 !== process.env) return;
-      if (!env2.VITEST && env2.NODE_ENV !== "test") return;
+      if (!isTestRuntimeEnv(env2) && !processLooksLikeNodeTestRunner()) return;
+      if (resolvedOverride) {
+        if (isLiveTrackHomeDir(resolvedOverride)) {
+          throw new Error(
+            `resolveConfigDir() is pinned to the LIVE ~/.adhdev(-preview) dir in a test runtime: a test inherited or re-assigned ADHDEV_CONFIG_DIR to the developer's real state dir (${resolvedOverride}). Pin ADHDEV_CONFIG_DIR to a tmp dir in test setup, or pass an explicit env/homeDir to resolveConfigDir.`
+          );
+        }
+        return;
+      }
+      const fallbackDir = (0, import_path2.join)((0, import_os2.homedir)(), getTrackIdentity(resolveBuildTrack(env2)).configDirName);
+      if (!isLiveTrackHomeDir(fallbackDir)) return;
       throw new Error(
-        "resolveConfigDir() reached the real-home fallback in a test runtime with ADHDEV_CONFIG_DIR unset: a test is about to touch the LIVE ~/.adhdev(-preview) state dir. Pin ADHDEV_CONFIG_DIR to a tmp dir in test setup, or pass an explicit env/homeDir to resolveConfigDir."
+        `resolveConfigDir() reached the real-home fallback in a test runtime with ADHDEV_CONFIG_DIR unset: a test is about to touch the LIVE ${fallbackDir} state dir. Pin ADHDEV_CONFIG_DIR to a tmp dir in test setup, or pass an explicit env/homeDir to resolveConfigDir.`
       );
     }
     function resolveConfigLogsDir(env2 = process.env, homeDir) {
@@ -31632,9 +31672,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/node_modules/b4a/index.js
+// ../daemon-core/node_modules/b4a/index.js
 var require_b4a2 = __commonJS({
-  "../../node_modules/tar-stream/node_modules/b4a/index.js"(exports2, module2) {
+  "../daemon-core/node_modules/b4a/index.js"(exports2, module2) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -31790,9 +31830,9 @@ var require_b4a2 = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/headers.js
+// ../daemon-core/node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../../node_modules/tar-stream/headers.js"(exports2) {
+  "../daemon-core/node_modules/tar-stream/headers.js"(exports2) {
     "use strict";
     var b4a = require_b4a2();
     var ZEROS = "0000000000000000000";
@@ -32053,9 +32093,9 @@ var require_headers = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/extract.js
+// ../daemon-core/node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../../node_modules/tar-stream/extract.js"(exports2, module2) {
+  "../daemon-core/node_modules/tar-stream/extract.js"(exports2, module2) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
@@ -32398,9 +32438,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/constants.js
+// ../daemon-core/node_modules/tar-stream/constants.js
 var require_constants = __commonJS({
-  "../../node_modules/tar-stream/constants.js"(exports2, module2) {
+  "../daemon-core/node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -32419,9 +32459,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/pack.js
+// ../daemon-core/node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../../node_modules/tar-stream/pack.js"(exports2, module2) {
+  "../daemon-core/node_modules/tar-stream/pack.js"(exports2, module2) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a2();
@@ -32654,9 +32694,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/index.js
+// ../daemon-core/node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../../node_modules/tar-stream/index.js"(exports2) {
+  "../daemon-core/node_modules/tar-stream/index.js"(exports2) {
     "use strict";
     exports2.extract = require_extract();
     exports2.pack = require_pack();
@@ -32899,9 +32939,9 @@ var require_pump = __commonJS({
   }
 });
 
-// ../../node_modules/tar-fs/index.js
+// ../daemon-core/node_modules/tar-fs/index.js
 var require_tar_fs = __commonJS({
-  "../../node_modules/tar-fs/index.js"(exports2) {
+  "../daemon-core/node_modules/tar-fs/index.js"(exports2) {
     "use strict";
     var tar = require_tar_stream();
     var pump = require_pump();
@@ -36831,10 +36871,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      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);
+      const commit = readInjected(true ? "671c36c8e29818de2b734954da347d681324d185" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "671c36c8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-23T15:46:11.432Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38030,8 +38070,20 @@ var require_dist3 = __commonJS({
           static buffers = /* @__PURE__ */ new Map();
           static writePromises = /* @__PURE__ */ new Map();
           static flushTimer = null;
+          static pendingBytes = /* @__PURE__ */ new Map();
+          /**
+           * Line/byte ceilings that force a synchronous flush. Sized so an idle daemon
+           * never reaches them (the 50ms timer wins) while a loop-blocking handler
+           * still gets its lines out: the status tick emits on the order of tens of
+           * lines, so 64 lines bounds a stalled window to roughly one tick's worth.
+           */
+          static MAX_PENDING_LINES = 64;
+          static MAX_PENDING_BYTES = 64 * 1024;
           /**
            * Queues data to be written to a file asynchronously in a batch.
+           *
+           * Crossing either pending threshold flushes synchronously before returning,
+           * so a caller on a blocked event loop still lands its line on disk.
            */
           static write(filePath, data) {
             let buf = this.buffers.get(filePath);
@@ -38040,6 +38092,12 @@ var require_dist3 = __commonJS({
               this.buffers.set(filePath, buf);
             }
             buf.push(data);
+            const bytes = (this.pendingBytes.get(filePath) ?? 0) + Buffer.byteLength(data);
+            this.pendingBytes.set(filePath, bytes);
+            if (buf.length >= this.MAX_PENDING_LINES || bytes >= this.MAX_PENDING_BYTES) {
+              this.flushPathSync(filePath);
+              return;
+            }
             if (!this.flushTimer) {
               this.flushTimer = setTimeout(() => {
                 this.flushTimer = null;
@@ -38047,9 +38105,35 @@ var require_dist3 = __commonJS({
               }, 50);
             }
           }
+          /**
+           * Synchronously drain every buffered path. Safe to call from shutdown
+           * handlers and from code that has just blocked (or is about to block) the
+           * event loop. Best-effort: never throws.
+           */
+          static flushSync() {
+            if (this.flushTimer) {
+              clearTimeout(this.flushTimer);
+              this.flushTimer = null;
+            }
+            for (const filePath of Array.from(this.buffers.keys())) {
+              this.flushPathSync(filePath);
+            }
+          }
+          /** Append one path's pending buffer with a blocking write. Never throws. */
+          static flushPathSync(filePath) {
+            const buffer = this.buffers.get(filePath);
+            this.buffers.delete(filePath);
+            this.pendingBytes.delete(filePath);
+            if (!buffer || buffer.length === 0) return;
+            try {
+              fs4.appendFileSync(filePath, buffer.join(""), { encoding: "utf-8", mode: 384 });
+            } catch {
+            }
+          }
           static async flushAll() {
             const entries = Array.from(this.buffers.entries());
             this.buffers.clear();
+            this.pendingBytes.clear();
             for (const [filePath, buffer] of entries) {
               const dataToWrite = buffer.join("");
               const doWrite = async () => {
@@ -38126,17 +38210,55 @@ var require_dist3 = __commonJS({
         IDENTITY = getTrackIdentity(TRACK);
       }
     });
+    function isTestRuntimeEnv(env2 = process.env) {
+      if (env2.VITEST) return true;
+      if (env2.NODE_ENV === "test") return true;
+      if (env2.NODE_TEST_CONTEXT) return true;
+      return false;
+    }
     function resolveConfigDir(env2 = process.env, homeDir) {
       const override = env2.ADHDEV_CONFIG_DIR;
-      if (override && override.trim()) return override.trim();
-      assertConfigDirPinnedInTestRuntime(env2);
+      if (override && override.trim()) {
+        const resolved = override.trim();
+        assertConfigDirIsolatedInTestRuntime(env2, resolved);
+        return resolved;
+      }
+      assertConfigDirIsolatedInTestRuntime(env2);
       return (0, import_path3.join)(homeDir ?? (0, import_os2.homedir)(), getTrackIdentity(resolveBuildTrack(env2)).configDirName);
     }
-    function assertConfigDirPinnedInTestRuntime(env2) {
+    function normalizeConfigPath(p, platform10 = process.platform) {
+      const unified = p.trim().replace(/[\\/]+$/, "").replace(/\\/g, "/");
+      return platform10 === "win32" ? unified.toLowerCase() : unified;
+    }
+    function liveTrackHomeDirs(homeDir = (0, import_os2.homedir)()) {
+      return [
+        (0, import_path3.join)(homeDir, getTrackIdentity("stable").configDirName),
+        (0, import_path3.join)(homeDir, getTrackIdentity("preview").configDirName)
+      ];
+    }
+    function isLiveTrackHomeDir(resolved, homeDir) {
+      const needle = normalizeConfigPath(resolved);
+      const bases = homeDir !== void 0 ? [homeDir] : [ORIGINAL_HOME_DIR].filter((v) => v !== "");
+      return bases.some((base) => liveTrackHomeDirs(base).some((live) => normalizeConfigPath(live) === needle));
+    }
+    function processLooksLikeNodeTestRunner() {
+      return process.execArgv.some((arg) => arg === "--test" || arg.startsWith("--test="));
+    }
+    function assertConfigDirIsolatedInTestRuntime(env2, resolvedOverride) {
       if (env2 !== process.env) return;
-      if (!env2.VITEST && env2.NODE_ENV !== "test") return;
+      if (!isTestRuntimeEnv(env2) && !processLooksLikeNodeTestRunner()) return;
+      if (resolvedOverride) {
+        if (isLiveTrackHomeDir(resolvedOverride)) {
+          throw new Error(
+            `resolveConfigDir() is pinned to the LIVE ~/.adhdev(-preview) dir in a test runtime: a test inherited or re-assigned ADHDEV_CONFIG_DIR to the developer's real state dir (${resolvedOverride}). Pin ADHDEV_CONFIG_DIR to a tmp dir in test setup, or pass an explicit env/homeDir to resolveConfigDir.`
+          );
+        }
+        return;
+      }
+      const fallbackDir = (0, import_path3.join)((0, import_os2.homedir)(), getTrackIdentity(resolveBuildTrack(env2)).configDirName);
+      if (!isLiveTrackHomeDir(fallbackDir)) return;
       throw new Error(
-        "resolveConfigDir() reached the real-home fallback in a test runtime with ADHDEV_CONFIG_DIR unset: a test is about to touch the LIVE ~/.adhdev(-preview) state dir. Pin ADHDEV_CONFIG_DIR to a tmp dir in test setup, or pass an explicit env/homeDir to resolveConfigDir."
+        `resolveConfigDir() reached the real-home fallback in a test runtime with ADHDEV_CONFIG_DIR unset: a test is about to touch the LIVE ${fallbackDir} state dir. Pin ADHDEV_CONFIG_DIR to a tmp dir in test setup, or pass an explicit env/homeDir to resolveConfigDir.`
       );
     }
     function resolveConfigLogsDir(env2 = process.env, homeDir) {
@@ -38166,12 +38288,14 @@ var require_dist3 = __commonJS({
     }
     var import_os2;
     var import_path3;
+    var ORIGINAL_HOME_DIR;
     var init_config_dir = __esm2({
       "src/config/config-dir.ts"() {
         "use strict";
         import_os2 = require("os");
         import_path3 = require("path");
         init_track_identity();
+        ORIGINAL_HOME_DIR = typeof process.env.HOME === "string" && process.env.HOME.trim() !== "" ? process.env.HOME.trim() : typeof process.env.USERPROFILE === "string" ? process.env.USERPROFILE.trim() : "";
       }
     });
     function setLogLevel(level) {
@@ -38831,6 +38955,13 @@ var require_dist3 = __commonJS({
         MACHINE_ID_PREFIX = "mach_";
       }
     });
+    function assertInjectedNetworkFetchInTest(overrides, caller) {
+      if (overrides.fetch) return;
+      if (!isTestRuntimeEnv()) return;
+      throw new Error(
+        `${caller}() in a test runtime without an injected fetch: this would hit a live provider endpoint. Mock the fetcher module, or pass deps.fetch (see test/quota/grok-quota.test.ts).`
+      );
+    }
     function resolveDeps(overrides = {}) {
       return {
         fetch: overrides.fetch ?? ((url2, init) => fetch(url2, init)),
@@ -38858,6 +38989,7 @@ var require_dist3 = __commonJS({
       "src/quota/fetchers/deps.ts"() {
         "use strict";
         import_node_child_process2 = require("child_process");
+        init_config_dir();
         init_config();
       }
     });
@@ -39173,6 +39305,7 @@ var require_dist3 = __commonJS({
       return Number.isNaN(at) ? void 0 : at;
     }
     async function fetchAntigravityQuota2(overrides = {}) {
+      assertInjectedNetworkFetchInTest(overrides, "fetchAntigravityQuota");
       const deps = resolveDeps(overrides);
       const credentialsResult = await readCredentials(deps);
       if (credentialsResult.kind === "unsupported-platform") {
@@ -40795,6 +40928,7 @@ child.on('exit', () => process.exit(0));
       return Number.isNaN(at) ? void 0 : at;
     }
     async function fetchGrokQuota2(overrides = {}) {
+      assertInjectedNetworkFetchInTest(overrides, "fetchGrokQuota");
       const deps = resolveDeps(overrides);
       const credentialsResult = readCredentials2(deps);
       if (credentialsResult.kind === "missing") {
@@ -41034,6 +41168,7 @@ child.on('exit', () => process.exit(0));
       return Number.isNaN(at) ? void 0 : at;
     }
     async function fetchKimiQuota2(overrides = {}) {
+      assertInjectedNetworkFetchInTest(overrides, "fetchKimiQuota");
       const deps = resolveDeps(overrides);
       const credentialsResult = readCredentials3(deps);
       if (credentialsResult.kind === "missing") {
@@ -41389,6 +41524,15 @@ child.on('exit', () => process.exit(0));
       if (cache.size === 0) return void 0;
       return Object.fromEntries(cache);
     }
+    function notifyQuotaCacheChanged() {
+      const listener = quotaCacheChangedListener;
+      if (!listener) return;
+      try {
+        listener();
+      } catch (e) {
+        LOG2.warn("Quota", `Quota cache-change listener failed: ${e?.message || e}`);
+      }
+    }
     function hasFreshlyMeasuredQuota() {
       for (const provider of cache.keys()) {
         if (!hydratedOnly.has(provider)) return true;
@@ -41467,6 +41611,7 @@ child.on('exit', () => process.exit(0));
       }
       const snapshot = readQuotaCache();
       if (snapshot) saveQuotaCache(snapshot);
+      notifyQuotaCacheChanged();
     }
     function cancelFailureRetry(provider) {
       const state = failureRetries.get(provider);
@@ -41532,13 +41677,81 @@ child.on('exit', () => process.exit(0));
       }
       return false;
     }
+    function computeNextWakeDelayMs(fetchers, isEnabled, active, now = Date.now()) {
+      if (!isEnabled) return void 0;
+      let nextAt = Number.POSITIVE_INFINITY;
+      for (const { provider } of fetchers) {
+        if (!isEnabled(provider)) continue;
+        const entry = cache.get(provider);
+        if (!entry) return 0;
+        if (entry.status !== "ok") {
+          const retryAtMs = entry.metadata?.retryAtMs;
+          if (typeof retryAtMs === "number" && (failureRetries.get(provider)?.failures ?? 0) <= QUOTA_FAILURE_MAX_RETRIES) {
+            nextAt = Math.min(nextAt, retryAtMs);
+          }
+        }
+        const updatedAtMs = Number(entry.updatedAt);
+        const dataDueAt = Number.isFinite(updatedAtMs) && updatedAtMs > 0 ? updatedAtMs + QUOTA_ROUTABLE_MAX_AGE_MS : Number.NEGATIVE_INFINITY;
+        const attemptedAt = lastAttemptAt(entry);
+        const attemptDueAt = attemptedAt === void 0 ? Number.NEGATIVE_INFINITY : attemptedAt + QUOTA_ROUTABLE_MAX_AGE_MS;
+        nextAt = Math.min(nextAt, Math.max(dataDueAt, attemptDueAt));
+        if (active) {
+          const ttl = QUOTA_AXIS_TTL_MS[provider];
+          if (Number.isFinite(ttl)) {
+            nextAt = Math.min(nextAt, attemptedAt === void 0 ? now : attemptedAt + ttl);
+          }
+        }
+      }
+      if (!Number.isFinite(nextAt)) return void 0;
+      return Math.max(nextAt - now, 0);
+    }
     function startQuotaRefreshLoop(options) {
       const intervalMs = options.intervalMs ?? QUOTA_REFRESH_INTERVAL_MS;
       const fetchers = options.fetchers ?? REFRESHERS;
       if (options.isEnabled) ambientIsEnabled = options.isEnabled;
       let running = false;
-      const timer = setInterval(() => {
-        if (running) return;
+      let stopped = false;
+      let timer = null;
+      const scheduleNext = () => {
+        if (stopped) return;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        let delayMs = intervalMs;
+        try {
+          let active = false;
+          try {
+            active = options.hasRecentCliActivity();
+          } catch {
+            active = false;
+          }
+          const computed = computeNextWakeDelayMs(fetchers, options.isEnabled, active);
+          if (computed !== void 0) {
+            delayMs = Math.max(computed, MIN_CHAIN_WAKE_DELAY_MS);
+            delayMs = Math.min(delayMs, QUOTA_ROUTABLE_MAX_AGE_MS);
+            if (options.isEnabled && fetchers.some(({ provider }) => !options.isEnabled(provider))) {
+              delayMs = Math.min(delayMs, intervalMs);
+            }
+          }
+        } catch {
+          delayMs = intervalMs;
+        }
+        timer = setTimeout(runWake, delayMs);
+        if (typeof timer.unref === "function") timer.unref();
+      };
+      const rescheduleFromOutside = () => {
+        if (stopped || running) return;
+        scheduleNext();
+      };
+      quotaCacheChangedListener = rescheduleFromOutside;
+      const runWake = () => {
+        timer = null;
+        if (stopped) return;
+        if (running) {
+          scheduleNext();
+          return;
+        }
         let active = false;
         try {
           active = options.hasRecentCliActivity();
@@ -41552,18 +41765,30 @@ child.on('exit', () => process.exit(0));
           return active && isDueByAxisTtl(provider);
         });
         const needsPrune = !!options.isEnabled && fetchers.some(({ provider }) => !options.isEnabled(provider) && cache.has(provider));
-        if (due.length === 0 && !needsPrune) return;
+        if (due.length === 0 && !needsPrune) {
+          scheduleNext();
+          return;
+        }
         running = true;
         const probeOnly = new Set(due.map(({ provider }) => provider));
         void refreshQuotaCacheOnce(fetchers, options.isEnabled, { probeOnly }).catch((e) => LOG2.warn("Quota", `Quota refresh tick error: ${e?.message || e}`)).finally(() => {
           running = false;
+          scheduleNext();
         });
-      }, intervalMs);
+      };
+      timer = setTimeout(runWake, intervalMs);
       if (typeof timer.unref === "function") timer.unref();
-      LOG2.info("Quota", `Quota refresh loop started (interval ${intervalMs}ms, per-axis TTL, idle machines skipped)`);
+      LOG2.info("Quota", `Quota refresh loop started (first wake ${intervalMs}ms, then per-provider expiry chain; per-axis TTL, idle machines skipped)`);
       return {
         stop() {
-          clearInterval(timer);
+          stopped = true;
+          if (timer) {
+            clearTimeout(timer);
+            timer = null;
+          }
+          if (quotaCacheChangedListener === rescheduleFromOutside) {
+            quotaCacheChangedListener = void 0;
+          }
           LOG2.info("Quota", "Quota refresh loop stopped");
         }
       };
@@ -41689,12 +41914,14 @@ child.on('exit', () => process.exit(0));
     var REFRESHERS;
     var cache;
     var ambientIsEnabled;
+    var quotaCacheChangedListener;
     var hydratedOnly;
     var hydrated;
     var QUOTA_FAILURE_MAX_RETRIES;
     var failureRetries;
     var QUOTA_ROUTABLE_MAX_AGE_MS;
     var WORKING_STATUSES;
+    var MIN_CHAIN_WAKE_DELAY_MS;
     var bootRefreshInFlight;
     var QUOTA_EVENT_REFRESH_DEBOUNCE_MS;
     var QUOTA_REFRESH_EVENTS;
@@ -41761,6 +41988,7 @@ child.on('exit', () => process.exit(0));
           "no_progress",
           "long_generating"
         ]);
+        MIN_CHAIN_WAKE_DELAY_MS = 1e3;
         bootRefreshInFlight = false;
         QUOTA_EVENT_REFRESH_DEBOUNCE_MS = 6e4;
         QUOTA_REFRESH_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
@@ -51064,7 +51292,6 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           nodeId: entry.assignedNodeId,
           providerType: entry.assignedProviderType
         } : void 0;
-        entry.status = "cancelled";
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
         delete entry.parked;
@@ -51076,20 +51303,17 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
         delete entry.attemptId;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
-        endTaskDispatchInFlight(meshId, taskId);
         terminalizeSiblingDispatch(meshId, taskId, "queue_task_cancelled");
-        try {
-          proposeTurnCompletion({
-            meshId,
-            taskId,
-            outcome: "cancelled",
-            source: "cancellation",
-            reason: opts?.reason ?? "operator_cancel"
-          });
-        } catch {
-        }
+        const commit = commitTaskTerminalAndAdvanceGraph({
+          meshId,
+          taskId,
+          status: "cancelled",
+          sessionId: priorAssignment?.sessionId,
+          source: "cancellation",
+          reason: opts?.reason ?? "operator_cancel"
+        });
         const cascaded = propagateDependencyFailure(meshId, taskId);
-        return { entry, cascaded, priorAssignment };
+        return { entry: commit.entry ?? entry, cascaded, priorAssignment };
       });
       if (result) scheduleMissionCloseCandidateCheck(meshId, [result.entry, ...result.cascaded]);
       if (result?.priorAssignment) lastCancelledTaskAssignment.set(`${meshId}::${taskId}`, result.priorAssignment);
@@ -81710,6 +81934,51 @@ ${cleanBody}`;
         return [];
       }
     }
+    async function verifyRemoteBranchContainsCommit(runGit3, submodulePath, commit, branch = "main") {
+      try {
+        await runGit3(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+      } catch (fetchError) {
+        return { state: "undeterminable", error: fetchError };
+      }
+      const remoteRef = `refs/remotes/origin/${branch}`;
+      try {
+        await runGit3(submodulePath, ["rev-parse", "--verify", "--quiet", `${remoteRef}^{commit}`]);
+      } catch (resolveError) {
+        return { state: "undeterminable", error: resolveError };
+      }
+      try {
+        await runGit3(submodulePath, ["rev-parse", "--verify", "--quiet", `${commit}^{commit}`]);
+      } catch (missingCandidate) {
+        return { state: "absent", error: missingCandidate };
+      }
+      try {
+        await runGit3(submodulePath, ["merge-base", "--is-ancestor", commit, remoteRef]);
+        return { state: "contained" };
+      } catch (ancestryError) {
+        return ancestryError?.code === 1 ? { state: "absent", error: ancestryError } : { state: "undeterminable", error: ancestryError };
+      }
+    }
+    function buildSubmodulePublishRequiredNextStep(entries) {
+      const undeterminable = entries.filter((entry) => entry.remoteMainUndeterminable);
+      const decided = entries.filter((entry) => !entry.remoteMainUndeterminable);
+      const convergeable = decided.filter((entry) => entry.equivalentPublishedCommit);
+      const publishable = decided.filter((entry) => !entry.equivalentPublishedCommit);
+      const parts = [];
+      if (undeterminable.length > 0) {
+        const refs = undeterminable.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
+        parts.push(`Submodule remote main containment could not be determined for (${refs}) \u2014 the submodule remote was not successfully consulted (network, auth, or a missing remote). This is NOT evidence that the commit is unpublished, so do not push it: restore access to the submodule remote and rerun mesh_refine_node to obtain a real verdict.`);
+      }
+      if (convergeable.length > 0) {
+        const refs = convergeable.map((entry) => `${entry.path}: ${entry.commit} \u2192 ${entry.equivalentPublishedCommit}`).join(", ");
+        parts.push(`Converge the submodule gitlink(s) to the already-published equivalent commit(s) (${refs}): a commit with an identical tree already exists on the submodule remote main branch, so publishing the local same-content twin is wrong. Retarget the gitlink to the published commit, commit the root pointer update, then rerun mesh_refine_node.`);
+      }
+      if (publishable.length > 0) {
+        const refs = publishable.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
+        parts.push(`Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node.`);
+      }
+      parts.push("Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.");
+      return parts.join(" ");
+    }
     var fs51;
     var import_node_child_process11;
     var import_path17;
@@ -81795,15 +82064,22 @@ ${cleanBody}`;
       }
       return void 0;
     }
-    function isCommitReachableFromRemoteMain(submoduleRepoPath, commit, remoteMainRef) {
-      if (!remoteMainRef) return false;
+    function submoduleHasOriginRemote(submoduleRepoPath) {
       try {
-        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", commit, remoteMainRef], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return true;
+        const url2 = (0, import_node_child_process12.execFileSync)(GIT4, ["remote", "get-url", "origin"], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        return !!url2.trim();
       } catch {
         return false;
       }
     }
+    function probeCommitReachableFromRemoteMain(submoduleRepoPath, commit, remoteMainRef) {
+      if (!remoteMainRef) return "undeterminable";
+      return probeGitAncestry(submoduleRepoPath, commit, remoteMainRef);
+    }
     function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead, options = {}) {
       const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
       if (changed.length === 0) {
@@ -81841,9 +82117,12 @@ ${cleanBody}`;
           continue;
         }
         sawDiverged = true;
+        const originConfigured = submoduleHasOriginRemote(submoduleRepoPath);
+        let remoteFetched = true;
         try {
           (0, import_node_child_process12.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
         } catch {
+          remoteFetched = false;
         }
         const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
         const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
@@ -81856,8 +82135,9 @@ ${cleanBody}`;
           resolutions.push({ path: path60, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
           continue;
         }
-        const branchAlreadyPublished = isCommitReachableFromRemoteMain(submoduleRepoPath, branchCommit, remoteMainRef);
-        const willMintUnpublishedCommit = !branchAlreadyPublished;
+        const branchPublished = probeCommitReachableFromRemoteMain(submoduleRepoPath, branchCommit, remoteMainRef);
+        const publicationUndeterminable = originConfigured && (branchPublished === "undeterminable" || !remoteFetched);
+        const willMintUnpublishedCommit = branchPublished !== true;
         const wouldConflict = (() => {
           try {
             (0, import_node_child_process12.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
@@ -81870,6 +82150,17 @@ ${cleanBody}`;
             return true;
           }
         })();
+        if (publicationUndeterminable && !wouldConflict) {
+          gitlinks.push({
+            path: path60,
+            baseCommit,
+            branchCommit,
+            action: "publication_undeterminable",
+            remoteMainRef,
+            remoteFetched
+          });
+          return { converged: false, reason: "submodule_publication_undeterminable", resolutions: [], gitlinks };
+        }
         if (willMintUnpublishedCommit && !wouldConflict && options.allowAutoPublishSubmoduleMainCommits !== true) {
           gitlinks.push({
             path: path60,
@@ -81943,12 +82234,18 @@ ${cleanBody}`;
       if (reason === "submodule_publish_required") {
         return describeSubmodulePublishRequired(nodeId, gitlinks);
       }
+      if (reason === "submodule_publication_undeterminable") {
+        return `[Refinery] Could NOT determine whether the branch-side submodule commit(s) are already published for node ${nodeId} \u2014 the submodule remote was not successfully consulted, so refs/remotes/origin/* is stale or absent. Refusing to rebase: minting a submodule commit on absent evidence can synthesize a redundant twin of a commit that is already on origin. The branch was left untouched. NEXT STEP: restore access to the submodule remote and rerun mesh_refine_node \u2014 do NOT publish or rebase on this evidence: ` + gitlinks.filter((g) => g.action === "publication_undeterminable").map((g) => `${g.path} (branch=${(g.branchCommit || "?").slice(0, 12)} base=${(g.baseCommit || "?").slice(0, 12)} remote=${g.remoteMainRef || "unresolved"} fetched=${g.remoteFetched === true})`).join(", ");
+      }
       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_publication_undeterminable") {
+        return { recommendedAction: SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION };
+      }
       if (reason !== "submodule_publish_required") return {};
       return {
         recommendedAction: SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION,
@@ -82042,6 +82339,7 @@ ${cleanBody}`;
     var import_path18;
     var import_node_child_process12;
     var SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION;
+    var SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION;
     var init_mesh_refine_submodule_converge = __esm2({
       "src/mesh/mesh-refine-submodule-converge.ts"() {
         "use strict";
@@ -82050,6 +82348,7 @@ ${cleanBody}`;
         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.";
+        SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION = "Restore access to the submodule remote (the publication check could not be run), then rerun mesh_refine_node. Do NOT publish and do NOT retry the rebase on this evidence: it is unknown whether the branch-side commit is already on origin, so minting or pushing here can synthesize a redundant twin of a published commit.";
       }
     });
     function truncateValidationOutput(value) {
@@ -82115,21 +82414,6 @@ ${asText(streams.stderr)}
         ...details || {}
       });
     }
-    function buildSubmodulePublishRequiredNextStep(entries) {
-      const convergeable = entries.filter((entry) => entry.equivalentPublishedCommit);
-      const publishable = entries.filter((entry) => !entry.equivalentPublishedCommit);
-      const parts = [];
-      if (convergeable.length > 0) {
-        const refs = convergeable.map((entry) => `${entry.path}: ${entry.commit} \u2192 ${entry.equivalentPublishedCommit}`).join(", ");
-        parts.push(`Converge the submodule gitlink(s) to the already-published equivalent commit(s) (${refs}): a commit with an identical tree already exists on the submodule remote main branch, so publishing the local same-content twin is wrong. Retarget the gitlink to the published commit, commit the root pointer update, then rerun mesh_refine_node.`);
-      }
-      if (publishable.length > 0) {
-        const refs = publishable.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
-        parts.push(`Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node.`);
-      }
-      parts.push("Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.");
-      return parts.join(" ");
-    }
     function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
       if (mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true) {
         process.stderr.write(
@@ -82848,10 +83132,7 @@ ${mergeTreeErr?.stderr || ""}`;
           });
           return String(stdout || "");
         };
-        const verifyRemoteMainContainsCommit = async (submodulePath, commit, branch = "main") => {
-          await runGit3(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
-          await runGit3(submodulePath, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
-        };
+        const verifyRemoteMainContainsCommit = (submodulePath, commit, branch = "main") => verifyRemoteBranchContainsCommit(runGit3, submodulePath, commit, branch);
         const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
           const refspec = `${commit}:refs/heads/${branch}`;
           const { stdout, stderr } = await execFileAsync7(GIT4, ["push", "origin", refspec], {
@@ -82880,8 +83161,13 @@ ${mergeTreeErr?.stderr || ""}`;
             if (!targetTree) return void 0;
             const candidates = (await runGit3(submodulePath, ["rev-list", "--max-count=100", remoteRef])).split("\n").map((s2) => s2.trim()).filter(Boolean);
             for (const candidate of candidates) {
-              const tree = (await runGit3(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
-              if (tree === targetTree) return candidate;
+              let tree = "";
+              try {
+                tree = (await runGit3(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
+              } catch {
+                continue;
+              }
+              if (tree && tree === targetTree) return candidate;
             }
           } catch {
           }
@@ -82954,13 +83240,25 @@ ${mergeTreeErr?.stderr || ""}`;
                 submodulePath: gitlink.path
               });
               entry.remoteMainBranch = submoduleDefaultBranch;
-              try {
-                await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
+              const verdict = await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
+              if (verdict.state === "contained") {
                 entry.fetchedFromOrigin = true;
                 entry.remoteReachable = true;
                 entry.remoteMainReachable = true;
                 entry.reachable = true;
-              } catch (e) {
+              } else if (verdict.state === "undeterminable") {
+                const e = verdict.error;
+                entry.remoteMainUndeterminable = true;
+                entry.publishRequired = false;
+                const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                entry.error = `Submodule remote main reachability for origin/${submoduleDefaultBranch} could not be determined (the remote was not successfully consulted): ${details}. This is not evidence that ${gitlink.commit} is unpublished \u2014 resolve the remote access problem and re-run; Refinery will not publish on an undetermined verdict.`;
+                if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                  entry.autoPublishAllowed = true;
+                  entry.autoPublishAttempted = false;
+                  entry.autoPublishSkippedReason = `remote main containment for origin/${submoduleDefaultBranch} could not be determined, so Refinery will not push \u2014 a failed fetch is not proof the commit is unpublished`;
+                }
+              } else {
+                const e = verdict.error;
                 entry.remoteReachable = false;
                 entry.remoteMainReachable = false;
                 const equivalentPublished = await findEquivalentPublishedCommit(submodulePath, gitlink.commit, `refs/remotes/origin/${submoduleDefaultBranch}`);
@@ -82986,14 +83284,24 @@ ${mergeTreeErr?.stderr || ""}`;
                       entry.publishStdout = truncateValidationOutput(publish.stdout);
                       entry.publishStderr = truncateValidationOutput(publish.stderr);
                       entry.autoPublishSucceeded = true;
-                      await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
-                      entry.fetchedFromOrigin = true;
-                      entry.remoteReachable = true;
-                      entry.remoteMainReachable = true;
-                      entry.autoPublishVerified = true;
-                      entry.publishRequired = false;
-                      entry.reachable = true;
-                      entry.error = void 0;
+                      const postPublish = await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
+                      if (postPublish.state !== "contained") {
+                        entry.autoPublishVerified = false;
+                        const postDetails = truncateValidationOutput(
+                          postPublish.error?.stderr || postPublish.error?.message || String(postPublish.error)
+                        );
+                        if (postPublish.state === "undeterminable") entry.remoteMainUndeterminable = true;
+                        else entry.remoteMainReachable = false;
+                        entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} reported success but post-publish verification did not confirm containment (${postPublish.state}): ${postDetails}`;
+                      } else {
+                        entry.fetchedFromOrigin = true;
+                        entry.remoteReachable = true;
+                        entry.remoteMainReachable = true;
+                        entry.autoPublishVerified = true;
+                        entry.publishRequired = false;
+                        entry.reachable = true;
+                        entry.error = void 0;
+                      }
                     } catch (publishError) {
                       entry.autoPublishSucceeded = false;
                       entry.autoPublishVerified = false;
@@ -83031,12 +83339,12 @@ ${mergeTreeErr?.stderr || ""}`;
           autoPublishPolicySource: options.autoPublishPolicySource
         };
       } catch (e) {
-        const unreachable = entries.filter((entry) => !entry.reachable).map((entry) => ({ ...entry, publishRequired: true }));
+        const unreachable = entries.filter((entry) => !entry.reachable).map((entry) => ({ ...entry, publishRequired: entry.publishRequired !== false }));
         return {
           status: "failed",
           checked: entries.length,
           unreachable,
-          entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: true }),
+          entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
           durationMs: Date.now() - startedAt,
           autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
           autoPublishPolicySource: options.autoPublishPolicySource,
@@ -83642,6 +83950,87 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
         "use strict";
       }
     });
+    async function hasOriginRemote(execFileAsync7, repoRoot, env2) {
+      try {
+        const { stdout } = await execFileAsync7("git", ["remote", "get-url", "origin"], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        return !!stdout.trim();
+      } catch {
+        return false;
+      }
+    }
+    async function probeRefineBaseCas(params) {
+      const { execFileAsync: execFileAsync7, repoRoot, baseBranch, pinnedBaseHead, env: env2 } = params;
+      if (!await hasOriginRemote(execFileAsync7, repoRoot, env2)) {
+        return { state: "no_origin" };
+      }
+      try {
+        await execFileAsync7("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: env2 });
+      } catch (e) {
+        const fetchError = e?.message || String(e);
+        return { state: "undeterminable", reason: `git fetch origin ${baseBranch} failed: ${fetchError}`, fetchError };
+      }
+      let liveBaseHead;
+      try {
+        const { stdout } = await execFileAsync7("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        liveBaseHead = stdout.trim();
+      } catch (e) {
+        return { state: "undeterminable", reason: `git rev-parse origin/${baseBranch} failed: ${e?.message || String(e)}` };
+      }
+      if (!liveBaseHead) {
+        return { state: "undeterminable", reason: `git rev-parse origin/${baseBranch} produced no SHA` };
+      }
+      return { state: liveBaseHead === pinnedBaseHead ? "unmoved" : "moved", liveBaseHead };
+    }
+    function describeRefineBaseCasStage(cas, pinnedBaseHead) {
+      switch (cas.state) {
+        case "no_origin":
+          return { status: "skipped", detail: { pinnedBaseHead, reason: "no_origin_remote" } };
+        case "undeterminable":
+          return { status: "failed", detail: {
+            pinnedBaseHead,
+            retryable: true,
+            undeterminable: true,
+            reason: cas.reason,
+            ...cas.fetchError ? { fetchError: cas.fetchError } : {}
+          } };
+        case "moved":
+          return { status: "failed", detail: { pinnedBaseHead, retryable: true, liveBaseHead: cas.liveBaseHead } };
+        default:
+          return { status: "passed", detail: { pinnedBaseHead, liveBaseHead: cas.liveBaseHead } };
+      }
+    }
+    function buildRefineBaseCasBlockedResult(params) {
+      const { cas, baseBranch, branch, pinnedBaseHead, validationSummary, patchEquivalence, submoduleReachability, refineStages } = params;
+      const undeterminable = cas.state === "undeterminable";
+      return {
+        success: false,
+        code: undeterminable ? "base_cas_undeterminable" : "base_moved",
+        convergenceStatus: "blocked_review",
+        retryable: true,
+        error: undeterminable ? `Could not verify whether base ${baseBranch} is still at the pinned ${pinnedBaseHead.slice(0, 7)} (${cas.reason}); refusing to merge or push onto an unverified base. Restore access to origin and re-run refine.` : `Base ${baseBranch} advanced from ${pinnedBaseHead.slice(0, 7)} to ${(cas.liveBaseHead || "").slice(0, 7)} after this node was validated; re-run refine to rebase onto and re-validate the new base.`,
+        branch,
+        into: baseBranch,
+        pinnedBaseHead,
+        ...undeterminable ? { baseCasUndeterminable: cas.reason } : { liveBaseHead: cas.liveBaseHead },
+        validationSummary,
+        patchEquivalence,
+        submoduleReachability,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch,
+          baseBranch,
+          merged: false,
+          removed: false,
+          status: "blocked_review",
+          ...undeterminable ? { nextStep: "Restore access to origin (the base compare-and-swap could not run), then re-run refine for this node." } : {}
+        }
+      };
+    }
+    var init_mesh_refine_base_cas = __esm2({
+      "src/mesh/mesh-refine-base-cas.ts"() {
+        "use strict";
+      }
+    });
     function resolveRefineMaxConcurrentJobs(env2 = process.env) {
       const raw = env2[REFINE_MAX_CONCURRENT_JOBS_ENV];
       if (raw === void 0 || raw.trim() === "") return DEFAULT_REFINE_MAX_CONCURRENT_JOBS;
@@ -84986,45 +85375,27 @@ ${hintLines.join("\n")}` : "",
     async function runRefineMergeAndFinalizeLocked(self, ctx) {
       const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync7 } = ctx;
       const casStarted = Date.now();
-      let baseMoved = false;
-      let liveBaseHead;
-      try {
-        await execFileAsync7("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
-        const { stdout } = await execFileAsync7("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
-        liveBaseHead = stdout.trim();
-        baseMoved = !!liveBaseHead && liveBaseHead !== baseHead;
-      } catch {
-      }
-      if (baseMoved) {
-        recordMeshRefineStage(refineStages, "base_cas", "failed", casStarted, {
-          pinnedBaseHead: baseHead,
-          liveBaseHead,
-          retryable: true
-        });
-        return { kind: "terminal", result: {
-          success: false,
-          code: "base_moved",
-          convergenceStatus: "blocked_review",
-          retryable: true,
-          error: `Base ${baseBranch} advanced from ${baseHead.slice(0, 7)} to ${(liveBaseHead || "").slice(0, 7)} after this node was validated; re-run refine to rebase onto and re-validate the new base.`,
+      const cas = await probeRefineBaseCas({
+        execFileAsync: execFileAsync7,
+        repoRoot,
+        baseBranch,
+        pinnedBaseHead: baseHead,
+        env: gitChildEnv()
+      });
+      const casStage = describeRefineBaseCasStage(cas, baseHead);
+      recordMeshRefineStage(refineStages, "base_cas", casStage.status, casStarted, casStage.detail);
+      if (cas.state === "undeterminable" || cas.state === "moved") {
+        return { kind: "terminal", result: buildRefineBaseCasBlockedResult({
+          cas,
+          baseBranch,
           branch,
-          into: baseBranch,
           pinnedBaseHead: baseHead,
-          liveBaseHead,
           validationSummary,
           patchEquivalence,
           submoduleReachability,
-          refineStages,
-          finalBranchConvergenceState: {
-            branch,
-            baseBranch,
-            merged: false,
-            removed: false,
-            status: "blocked_review"
-          }
-        } };
+          refineStages
+        }) };
       }
-      recordMeshRefineStage(refineStages, "base_cas", "passed", casStarted, { pinnedBaseHead: baseHead });
       let mergeResult;
       const mergeStarted = Date.now();
       try {
@@ -85971,9 +86342,10 @@ ${e?.stderr || ""}`;
         init_git_locale();
         init_mesh_node_identity();
         init_mesh_refine_gates();
+        init_mesh_refine_base_cas();
         init_mesh_refine_concurrency();
         init_router_refine_resume();
-        RETRYABLE_BASE_MOVEMENT_CODES = /* @__PURE__ */ new Set(["base_moved", "base_locked"]);
+        RETRYABLE_BASE_MOVEMENT_CODES = /* @__PURE__ */ new Set(["base_moved", "base_locked", "base_cas_undeterminable"]);
       }
     });
     var index_exports = {};
@@ -86357,6 +86729,7 @@ ${e?.stderr || ""}`;
       isManagedStatusWorking: () => isManagedStatusWorking,
       isMeshHostOwner: () => isMeshHostOwner,
       isMeshNodeHealthLaunchable: () => isMeshNodeHealthLaunchable,
+      isMeshTestPollution: () => isMeshTestPollution,
       isMissingLiveSessionResult: () => isMissingLiveSessionResult2,
       isOperatingNoteTombstoned: () => isOperatingNoteTombstoned,
       isP2pRelayTransportFailure: () => isP2pRelayTransportFailure,
@@ -86366,6 +86739,8 @@ ${e?.stderr || ""}`;
       isSessionHostLiveRuntime: () => import_session_host_core32.isSessionHostLiveRuntime,
       isSessionHostRecoverySnapshot: () => import_session_host_core32.isSessionHostRecoverySnapshot,
       isSetupComplete: () => isSetupComplete,
+      isSyntheticTestCoordinatorSession: () => isSyntheticTestCoordinatorSession,
+      isSyntheticTestMeshId: () => isSyntheticTestMeshId,
       isTaskReadonly: () => isTaskReadonly,
       isUserFacingChatMessage: () => isUserFacingChatMessage,
       isWeakCompletionEvidence: () => isWeakCompletionEvidence,
@@ -88733,6 +89108,19 @@ ${e?.stderr || ""}`;
       };
     }
     init_mesh_ledger();
+    var SYNTHETIC_MESH_ID_RE = /^mesh_(adopt_|g4dup_|graph_[eg]_)/;
+    var SYNTHETIC_COORDINATOR_SESSIONS = /* @__PURE__ */ new Set(["sess-coord", "sess-A"]);
+    function isSyntheticTestMeshId(meshId) {
+      if (!meshId) return false;
+      return SYNTHETIC_MESH_ID_RE.test(meshId);
+    }
+    function isSyntheticTestCoordinatorSession(sessionId) {
+      if (!sessionId) return false;
+      return SYNTHETIC_COORDINATOR_SESSIONS.has(sessionId);
+    }
+    function isMeshTestPollution(args) {
+      return isSyntheticTestMeshId(args.meshId) || isSyntheticTestCoordinatorSession(args.coordinatorSessionId);
+    }
     var import_fs13 = require("fs");
     var import_path12 = require("path");
     init_config();
@@ -102296,6 +102684,11 @@ ${marker}`,
     var WIN32_SUBMIT_SETTLE_POLL_MS = 120;
     var WIN32_ECHO_PROBE_CHARS = 16;
     var WIN32_ECHO_MAX_WAIT_MS = 2e4;
+    var VERIFIED_SUBMIT_MIN_CHARS = 512;
+    function shouldUseVerifiedSubmit(text, platform10 = process.platform) {
+      if (platform10 === "win32") return true;
+      return text.length >= VERIFIED_SUBMIT_MIN_CHARS;
+    }
     var WIN32_BRACKETED_PASTE_OPEN = "\x1B[200~";
     var WIN32_BRACKETED_PASTE_CLOSE = "\x1B[201~";
     var WIN32_SOFT_NEWLINE = "\x1B[27;2;13~";
@@ -102308,8 +102701,9 @@ ${marker}`,
     function resolveSubmitDelayMs(specBeforeSubmit, text) {
       const lines = countNewlines(text);
       const linesBonus = Math.min(800, lines * 80);
+      const lengthBonus = Math.min(800, Math.floor(text.length / 1e3) * 200);
       const spec = typeof specBeforeSubmit === "number" && specBeforeSubmit > 0 ? specBeforeSubmit : 0;
-      return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus);
+      return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus + lengthBonus);
     }
     var chunkPreservingSurrogates2 = chunkPreservingSurrogates;
     function guessExt(mime) {
@@ -102377,7 +102771,7 @@ ${marker}`,
        *  resets the stall reference) or another full stall window lapses. */
       lastRefocusAt = 0;
       /** Timer driving the win32 verification-based submit resend loop (see
-       *  WIN32_SUBMIT_* and scheduleWin32Submit). Re-arms itself until the FSM
+       *  WIN32_SUBMIT_* and scheduleVerifiedSubmit). Re-arms itself until the FSM
        *  leaves idle (submitted) or the resend budget is spent. */
       win32SubmitTimer = null;
       /** Wall-clock (ms) of the most recent raw PTY output chunk. Advances on every
@@ -102395,6 +102789,12 @@ ${marker}`,
        *  is absorbed by ConPTY the same way a send_message submit CR is, so the confirm
        *  must be resent until the modal actually resolves (status leaves 'approval'). */
       win32ModalConfirmTimer = null;
+      /** SUBMIT-SILENT-FAILURE: set when scheduleVerifiedSubmit spent its whole resend
+       *  budget without the FSM ever leaving 'idle' — i.e. the body is still sitting
+       *  unsent in the composer. Cleared on the next send. Exposed via
+       *  lastSubmitUnconfirmed() so a supervisor can distinguish "agent is thinking"
+       *  from "the prompt was never actually submitted". */
+      submitUnconfirmed = false;
       currentEval = null;
       stateHistory = [];
       prevStateAt = 0;
@@ -103206,13 +103606,26 @@ ${marker}`,
         this.sendInFlight = true;
         this.sendInFlightAt = Date.now();
       }
+      /** SUBMIT-SILENT-FAILURE: true when the most recent send exhausted its submit
+       *  resend budget without the agent ever leaving the composer. A caller seeing
+       *  this should treat an apparent 'generating' status as untrustworthy. */
+      lastSubmitUnconfirmed() {
+        return this.submitUnconfirmed;
+      }
       actuallySendMessage(text) {
         const sm = this.spec.send_message;
+        this.submitUnconfirmed = false;
         const perChar = sm.delay_ms_per_char ?? 0;
         const beforeSubmit = resolveSubmitDelayMs(sm.delay_ms_before_submit, text);
         if (process.platform === "win32") {
           this.writeWin32Body(text);
-          this.scheduleWin32Submit(sm.submit_key, beforeSubmit, text);
+          this.scheduleVerifiedSubmit(sm.submit_key, beforeSubmit, text);
+          return;
+        }
+        if (perChar === 0 && shouldUseVerifiedSubmit(text)) {
+          this.adapter.send_keys(text);
+          this.markBodyWrite();
+          this.scheduleVerifiedSubmit(sm.submit_key, beforeSubmit, text);
           return;
         }
         if (perChar === 0) {
@@ -103239,7 +103652,7 @@ ${marker}`,
       }
       /** Record a win32 body write so the settle-gate counts it as input activity
        *  even before the echo arrives. */
-      markWin32Write() {
+      markBodyWrite() {
         this.lastWin32WriteAt = Date.now();
       }
       /** Most recent win32 input activity — a write we issued OR a PTY output chunk
@@ -103264,7 +103677,7 @@ ${marker}`,
        *   - 'soft_newline': replace each embedded newline with a non-submitting
        *     Shift+Enter (CSI-u) so the body is typed as one multi-line entry.
        * The trailing submit CR is NOT written here — it stays separate and is fired
-       * later by scheduleWin32Submit (concern (A)). The bracketed-paste markers are
+       * later by scheduleVerifiedSubmit (concern (A)). The bracketed-paste markers are
        * written as their own atomic segments (never chunked), so chunking can never
        * split ESC[200~ / ESC[201~ mid-sequence regardless of body length.
        */
@@ -103289,7 +103702,7 @@ ${marker}`,
           ];
         }
         if (segments.length <= 1) {
-          this.markWin32Write();
+          this.markBodyWrite();
           this.adapter.send_keys(segments[0] ?? text);
           return;
         }
@@ -103297,7 +103710,7 @@ ${marker}`,
         const writeNext = () => {
           this.win32WriteTimer = null;
           if (idx >= segments.length) return;
-          this.markWin32Write();
+          this.markBodyWrite();
           this.adapter.send_keys(segments[idx]);
           idx += 1;
           if (idx < segments.length) {
@@ -103327,7 +103740,7 @@ ${marker}`,
        *  idle and stop the instant the agent leaves idle (submitted → generating /
        *  approval). This preserves the win32 lone-CR-swallow handling.
        */
-      scheduleWin32Submit(submitKey, initialDelayMs, body) {
+      scheduleVerifiedSubmit(submitKey, initialDelayMs, body) {
         if (this.win32SubmitTimer) {
           clearTimeout(this.win32SubmitTimer);
           this.win32SubmitTimer = null;
@@ -103346,10 +103759,22 @@ ${marker}`,
         const fire = (attempt) => {
           this.win32SubmitTimer = null;
           this.adapter.send_keys(submitKey);
-          if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+          if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) {
+            if (this.currentStatus() === "idle") {
+              this.submitUnconfirmed = true;
+              LOG2.error(
+                "FsmDriver",
+                `[${this.specTag()}] SUBMIT NOT CONFIRMED after ${WIN32_SUBMIT_MAX_RESENDS} submit-key attempts (len=${body.length}, echoed=${bodyEchoed()}, waited=${Date.now() - startedAt}ms). The message is likely still sitting unsent in the composer \u2014 the agent is NOT working on it.`
+              );
+            }
+            return;
+          }
           this.win32SubmitTimer = setTimeout(() => {
             if (this.currentStatus() !== "idle") {
               this.win32SubmitTimer = null;
+              if (attempt > 0) {
+                LOG2.warn("FsmDriver", `[${this.specTag()}] submit confirmed only after ${attempt + 1} attempts (len=${body.length})`);
+              }
               return;
             }
             fire(attempt + 1);
@@ -103366,6 +103791,10 @@ ${marker}`,
             return;
           }
           if (waited >= WIN32_ECHO_MAX_WAIT_MS) {
+            LOG2.warn(
+              "FsmDriver",
+              `[${this.specTag()}] body never confirmed in composer after ${waited}ms (len=${body.length}) \u2014 firing submit key blind; resend net will verify.`
+            );
             fire(0);
             return;
           }
@@ -103461,7 +103890,7 @@ ${marker}`,
         this.scheduleWin32ModalConfirm(cr);
       }
       /**
-       * win32 modal-confirm CR resend loop. Mirrors scheduleWin32Submit's phase-2
+       * win32 modal-confirm CR resend loop. Mirrors scheduleVerifiedSubmit's phase-2
        * verified resend, but gated on still being IN a modal (status 'approval')
        * rather than still idle: the first CR fires immediately, then resends every
        * WIN32_SUBMIT_RESEND_GAP_MS while the FSM is still showing the modal, up to
@@ -104478,7 +104907,7 @@ ${marker}`,
       if (/^[A-Za-z]:$/.test(parts[0])) return { root: `${parts[0]}/`, segments: parts.slice(1) };
       return { root: parts[0], segments: parts.slice(1) };
     }
-    function expandDirGlob(template) {
+    function expandDirGlobUncached(template) {
       const { root, segments } = splitTemplateRoot(template);
       let dirs = [root];
       for (const seg of segments) {
@@ -104518,6 +104947,36 @@ ${marker}`,
       }
       return dirs;
     }
+    var GLOB_CACHE_TTL_MS = 3e3;
+    var GLOB_CACHE_MAX_ENTRIES = 512;
+    var GLOB_CACHE_PREFIX = "glob:";
+    var globCache = /* @__PURE__ */ new Map();
+    var globCacheHits = 0;
+    var globCacheMisses = 0;
+    function pruneGlobCache(nowMs) {
+      for (const [key2, entry] of globCache) {
+        if (entry.expiresAtMs <= nowMs) globCache.delete(key2);
+      }
+      while (globCache.size >= GLOB_CACHE_MAX_ENTRIES) {
+        const oldest = globCache.keys().next();
+        if (oldest.done) break;
+        globCache.delete(oldest.value);
+      }
+    }
+    function expandDirGlob(template) {
+      const key2 = `${GLOB_CACHE_PREFIX}${template}`;
+      const now = Date.now();
+      const hit = globCache.get(key2);
+      if (hit && hit.expiresAtMs > now) {
+        globCacheHits += 1;
+        return hit.dirs.slice();
+      }
+      globCacheMisses += 1;
+      const dirs = expandDirGlobUncached(template);
+      pruneGlobCache(now);
+      globCache.set(key2, { dirs, expiresAtMs: now + GLOB_CACHE_TTL_MS });
+      return dirs.slice();
+    }
     function walkAllDirs(root, out) {
       let entries;
       try {
@@ -134631,6 +135090,7 @@ data: ${JSON.stringify(msg.data)}
     }
     var import_node_perf_hooks = require("perf_hooks");
     init_logger();
+    init_async_batch_writer();
     var EVENT_LOOP_MONITOR_INTERVAL_ENV = "ADHDEV_EVENT_LOOP_MONITOR_INTERVAL_MS";
     var EVENT_LOOP_LAG_WARN_ENV = "ADHDEV_EVENT_LOOP_LAG_WARN_MS";
     var DEFAULT_EVENT_LOOP_MONITOR_INTERVAL_MS = 1e4;
@@ -134647,8 +135107,12 @@ data: ${JSON.stringify(msg.data)}
       return parseMs(env2[EVENT_LOOP_LAG_WARN_ENV], DEFAULT_EVENT_LOOP_LAG_WARN_MS);
     }
     function defaultLogFn(level, message) {
-      if (level === "warn") LOG2.warn("EventLoop", message);
-      else LOG2.debug("EventLoop", message);
+      if (level === "warn") {
+        LOG2.warn("EventLoop", message);
+        AsyncBatchWriter.flushSync();
+      } else {
+        LOG2.debug("EventLoop", message);
+      }
     }
     function startEventLoopMonitor(opts) {
       const intervalMs = opts?.intervalMs ?? resolveEventLoopMonitorIntervalMs();
@@ -134665,6 +135129,8 @@ data: ${JSON.stringify(msg.data)}
         } };
       }
       let expectedTickAt = null;
+      let lastCpu = null;
+      let lastCpuAt = null;
       const timer = setInterval(() => {
         try {
           const now = Date.now();
@@ -134675,9 +135141,21 @@ data: ${JSON.stringify(msg.data)}
           const meanMs = histogram.mean / 1e6;
           histogram.reset();
           const worstMs = Math.max(driftMs, maxMs);
-          const message = `event-loop lag: drift=${driftMs.toFixed(0)}ms max=${maxMs.toFixed(0)}ms p99=${p99Ms.toFixed(0)}ms mean=${meanMs.toFixed(1)}ms over ${intervalMs}ms window`;
+          const cpuNow = process.cpuUsage();
+          let cpuPct = null;
+          if (lastCpu !== null && lastCpuAt !== null) {
+            const elapsedMs = now - lastCpuAt;
+            if (elapsedMs > 0) {
+              const usedMs = (cpuNow.user - lastCpu.user + (cpuNow.system - lastCpu.system)) / 1e3;
+              cpuPct = usedMs / elapsedMs * 100;
+            }
+          }
+          lastCpu = cpuNow;
+          lastCpuAt = now;
+          const cpuPart = cpuPct === null ? "" : ` selfCpu=${cpuPct.toFixed(0)}%`;
+          const message = `event-loop lag: drift=${driftMs.toFixed(0)}ms max=${maxMs.toFixed(0)}ms p99=${p99Ms.toFixed(0)}ms mean=${meanMs.toFixed(1)}ms${cpuPart} over ${intervalMs}ms window`;
           if (worstMs >= warnMs) {
-            logFn("warn", `${message} \u2014 EXCEEDS ${warnMs}ms: the whole daemon process was frozen/unscheduled (machine saturation), not one slow handler. Expect IPC probe timeouts and reconcile-tick gaps in this window.`);
+            logFn("warn", `${message} \u2014 EXCEEDS ${warnMs}ms. Cause is one of two shapes: high selfCpu \u21D2 this process blocked its own loop (one slow synchronous handler); low selfCpu with high drift \u21D2 the process was unscheduled (machine saturation). Expect IPC probe timeouts and reconcile-tick gaps in this window.`);
           } else {
             logFn("debug", message);
           }