@adhdev/daemon-core 0.9.82-rc.332 → 0.9.82-rc.334

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "2466d8b001000d509eb9058a0c51ec6f383741ed" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "2466d8b0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.332" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-20T01:55:54.421Z" : void 0);
+  const commit = readInjected(true ? "9e5ae5d2814077a6bf9e982b17066ca2051da97b" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "9e5ae5d2" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.334" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-20T03:55:49.426Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -587,10 +587,10 @@ async function getGitRepoStatus(workspace, options = {}) {
   } catch (error) {
     const gitError = error instanceof GitCommandError ? error : new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error });
     if (isTransientGitFailure(gitError)) {
-      const cached2 = lastKnownGoodStatus.get(workspace);
-      if (cached2) {
+      const cached3 = lastKnownGoodStatus.get(workspace);
+      if (cached3) {
         return {
-          ...cached2,
+          ...cached3,
           lastCheckedAt,
           upstreamStatus: "unavailable",
           error: gitError.stderr || gitError.message,
@@ -713,9 +713,9 @@ function resolveChangeImpactConfigForRepo(repoRoot, options) {
     return { config: null, sourceKey: "no-repo-root" };
   }
   const loaded = loadChangeImpactConfig(repoRoot);
-  const cached2 = changeImpactConfigCache.get(repoRoot);
-  if (cached2 && cached2.sourceKey === loaded.sourceKey) {
-    return { config: cached2.config, sourceKey: loaded.sourceKey };
+  const cached3 = changeImpactConfigCache.get(repoRoot);
+  if (cached3 && cached3.sourceKey === loaded.sourceKey) {
+    return { config: cached3.config, sourceKey: loaded.sourceKey };
   }
   const config = loaded.sourceType === "repo_file" ? loaded.config ?? null : null;
   changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config });
@@ -2541,6 +2541,47 @@ Follow these recovery rules:
   }
 });
 
+// src/system/load-better-sqlite3.ts
+function loadBetterSqlite3() {
+  if (cached2) return cached2;
+  const errors = [];
+  if (typeof require === "function") {
+    try {
+      cached2 = require("better-sqlite3");
+      return cached2;
+    } catch (e) {
+      errors.push(e);
+    }
+  }
+  try {
+    const metaUrl = typeof import_meta?.url === "string" ? import_meta.url : void 0;
+    if (metaUrl) {
+      cached2 = (0, import_module.createRequire)(metaUrl)("better-sqlite3");
+      return cached2;
+    }
+  } catch (e) {
+    errors.push(e);
+  }
+  try {
+    cached2 = (0, import_module.createRequire)(`${process.cwd()}/__adhdev_better_sqlite3_loader__.js`)(
+      "better-sqlite3"
+    );
+    return cached2;
+  } catch (e) {
+    errors.push(e);
+  }
+  const detail = errors.map((e) => e instanceof Error ? e.message : String(e)).join("; ");
+  throw new Error(`Failed to load better-sqlite3: ${detail}`);
+}
+var import_module, import_meta, cached2;
+var init_load_better_sqlite3 = __esm({
+  "src/system/load-better-sqlite3.ts"() {
+    "use strict";
+    import_module = require("module");
+    import_meta = {};
+  }
+});
+
 // src/mesh/mesh-ledger.ts
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
@@ -2970,8 +3011,8 @@ function readLedgerFromStore(meshId) {
 }
 function getCachedRawEntries(meshId) {
   const now = Date.now();
-  const cached2 = ledgerReadCache.get(meshId);
-  if (cached2 && now - cached2.cachedAt < LEDGER_CACHE_TTL_MS) return cached2.entries;
+  const cached3 = ledgerReadCache.get(meshId);
+  if (cached3 && now - cached3.cachedAt < LEDGER_CACHE_TTL_MS) return cached3.entries;
   let entries;
   try {
     entries = readLedgerFromStore(meshId);
@@ -3219,6 +3260,297 @@ var init_mesh_ledger = __esm({
   }
 });
 
+// src/logging/async-batch-writer.ts
+var fs3, AsyncBatchWriter;
+var init_async_batch_writer = __esm({
+  "src/logging/async-batch-writer.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    AsyncBatchWriter = class {
+      // Maps filePath -> string buffer
+      static buffers = /* @__PURE__ */ new Map();
+      static writePromises = /* @__PURE__ */ new Map();
+      static flushTimer = null;
+      /**
+       * Queues data to be written to a file asynchronously in a batch.
+       */
+      static write(filePath, data) {
+        let buf = this.buffers.get(filePath);
+        if (!buf) {
+          buf = [];
+          this.buffers.set(filePath, buf);
+        }
+        buf.push(data);
+        if (!this.flushTimer) {
+          this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flushAll();
+          }, 50);
+        }
+      }
+      static async flushAll() {
+        const entries = Array.from(this.buffers.entries());
+        this.buffers.clear();
+        for (const [filePath, buffer] of entries) {
+          const dataToWrite = buffer.join("");
+          const doWrite = async () => {
+            try {
+              const prevPromise = this.writePromises.get(filePath);
+              if (prevPromise) await prevPromise;
+              await fs3.promises.appendFile(filePath, dataToWrite, { encoding: "utf-8", mode: 384 });
+            } catch {
+            }
+          };
+          const writePromise = doWrite();
+          this.writePromises.set(filePath, writePromise);
+          writePromise.finally(() => {
+            if (this.writePromises.get(filePath) === writePromise) {
+              this.writePromises.delete(filePath);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/logging/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  LOG: () => LOG,
+  LOG_DIR_PATH: () => LOG_DIR_PATH,
+  LOG_PATH: () => LOG_PATH,
+  daemonLog: () => daemonLog,
+  getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
+  getDaemonLogDir: () => getDaemonLogDir,
+  getLogBufferSize: () => getLogBufferSize,
+  getLogLevel: () => getLogLevel,
+  getLogPath: () => getLogPath,
+  getRecentLogs: () => getRecentLogs,
+  installGlobalInterceptor: () => installGlobalInterceptor,
+  setLogLevel: () => setLogLevel
+});
+function setLogLevel(level) {
+  currentLevel = level;
+  daemonLog("Logger", `Log level set to: ${level}`, "info");
+}
+function getLogLevel() {
+  return currentLevel;
+}
+function getDateStr() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function getDaemonLogDir() {
+  return LOG_DIR;
+}
+function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
+  return path9.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+}
+function checkDateRotation() {
+  const today = getDateStr();
+  if (today !== currentDate) {
+    currentDate = today;
+    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
+    cleanOldLogs();
+  }
+}
+function cleanOldLogs() {
+  try {
+    const files = fs4.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+    for (const file of files) {
+      const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
+      if (dateMatch && dateMatch[1] < cutoffStr) {
+        try {
+          fs4.unlinkSync(path9.join(LOG_DIR, file));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function rotateSizeIfNeeded() {
+  try {
+    const stat2 = fs4.statSync(currentLogFile);
+    if (stat2.size > MAX_LOG_SIZE) {
+      const backup = currentLogFile.replace(".log", ".1.log");
+      try {
+        fs4.unlinkSync(backup);
+      } catch {
+      }
+      fs4.renameSync(currentLogFile, backup);
+    }
+  } catch {
+  }
+}
+function writeToFile(line) {
+  try {
+    if (++writeCount % 1e3 === 0) {
+      checkDateRotation();
+      rotateSizeIfNeeded();
+    }
+    AsyncBatchWriter.write(currentLogFile, line + "\n");
+  } catch {
+  }
+}
+function getRecentLogs(count = 50, minLevel = "info") {
+  const minNum = LEVEL_NUM[minLevel];
+  const filtered = ringBuffer.filter((e) => LEVEL_NUM[e.level] >= minNum);
+  return filtered.slice(-count);
+}
+function getLogBufferSize() {
+  return ringBuffer.length;
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function fullTs() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function daemonLog(category, msg, level = "info") {
+  const shouldOutput = LEVEL_NUM[level] >= LEVEL_NUM[currentLevel];
+  const label = LEVEL_LABEL[level];
+  const line = `[${ts()}] [${label}] [${category}] ${msg}`;
+  if (!shouldOutput) return;
+  writeToFile(line);
+  ringBuffer.push({ ts: Date.now(), level, category, message: msg });
+  if (ringBuffer.length > RING_BUFFER_SIZE) {
+    ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+  }
+  origConsoleLog(line);
+}
+function installGlobalInterceptor() {
+  if (interceptorInstalled) return;
+  interceptorInstalled = true;
+  const stripAnsi4 = (str) => str.replace(/\x1B\[[0-9;]*m/g, "");
+  const isDaemonLogLine = (msg) => /\[(DBG|INF|WRN|ERR)\]/.test(msg);
+  console.log = (...args) => {
+    origConsoleLog(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      if (isDaemonLogLine(clean)) return;
+      const line = clean.startsWith("[20") ? clean : `[${fullTs()}] ${clean}`;
+      writeToFile(line);
+      const catMatch = clean.match(/\[([^\]]+)\]/);
+      ringBuffer.push({
+        ts: Date.now(),
+        level: "info",
+        category: catMatch?.[1] || "System",
+        message: clean
+      });
+      if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+      }
+    } catch {
+    }
+  };
+  console.error = (...args) => {
+    origConsoleError(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      if (isDaemonLogLine(clean)) return;
+      const line = `[${fullTs()}] [ERROR] ${clean}`;
+      writeToFile(line);
+      ringBuffer.push({ ts: Date.now(), level: "error", category: "System", message: clean });
+      if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+      }
+    } catch {
+    }
+  };
+  console.warn = (...args) => {
+    origConsoleWarn(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      if (isDaemonLogLine(clean)) return;
+      const line = `[${fullTs()}] [WARN] ${clean}`;
+      writeToFile(line);
+      ringBuffer.push({ ts: Date.now(), level: "warn", category: "System", message: clean });
+      if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+      }
+    } catch {
+    }
+  };
+  writeToFile(`
+=== ADHDev Daemon started at ${fullTs()} ===`);
+  writeToFile(`Log file: ${currentLogFile}`);
+  writeToFile(`Log level: ${currentLevel}`);
+}
+function getLogPath() {
+  return currentLogFile;
+}
+var fs4, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
+var init_logger = __esm({
+  "src/logging/logger.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    os3 = __toESM(require("os"));
+    init_async_batch_writer();
+    LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
+    LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
+    currentLevel = "info";
+    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os3.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os3.homedir(), "Library", "Logs", "adhdev") : path9.join(os3.homedir(), ".local", "share", "adhdev", "logs");
+    MAX_LOG_SIZE = 5 * 1024 * 1024;
+    MAX_LOG_DAYS = 7;
+    try {
+      fs4.mkdirSync(LOG_DIR, { recursive: true });
+    } catch {
+    }
+    currentDate = getDateStr();
+    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
+    cleanOldLogs();
+    try {
+      const oldLog = path9.join(LOG_DIR, "daemon.log");
+      if (fs4.existsSync(oldLog)) {
+        const stat2 = fs4.statSync(oldLog);
+        const oldDate = stat2.mtime.toISOString().slice(0, 10);
+        fs4.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
+      }
+      const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
+      if (fs4.existsSync(oldLogBackup)) {
+        fs4.unlinkSync(oldLogBackup);
+      }
+    } catch {
+    }
+    writeCount = 0;
+    RING_BUFFER_SIZE = 200;
+    ringBuffer = [];
+    origConsoleLog = console.log.bind(console);
+    origConsoleError = console.error.bind(console);
+    origConsoleWarn = console.warn.bind(console);
+    LOG = {
+      debug: (category, msg) => daemonLog(category, msg, "debug"),
+      info: (category, msg) => daemonLog(category, msg, "info"),
+      warn: (category, msg) => daemonLog(category, msg, "warn"),
+      error: (category, msg) => daemonLog(category, msg, "error"),
+      /**
+       * Create a scoped logger for a specific component.
+       * Category is baked in so callers only pass the message.
+       */
+      forComponent(category) {
+        return {
+          debug: (msg) => daemonLog(category, msg, "debug"),
+          info: (msg) => daemonLog(category, msg, "info"),
+          warn: (msg) => daemonLog(category, msg, "warn"),
+          error: (msg) => daemonLog(category, msg, "error"),
+          asLogFn: (level = "info") => (msg) => daemonLog(category, msg, level)
+        };
+      }
+    };
+    interceptorInstalled = false;
+    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_DIR_PATH = LOG_DIR;
+  }
+});
+
 // src/mesh/mesh-work-queue.ts
 var mesh_work_queue_exports = {};
 __export(mesh_work_queue_exports, {
@@ -3683,11 +4015,18 @@ function requeueTask(meshId, taskId, opts) {
 }
 function updateSessionTaskStatus(meshId, sessionId, status, opts) {
   return withQueueLock(meshId, () => {
+    const store = MeshRuntimeStore.getInstance();
     const occurredAtIso = opts?.occurredAt ? new Date(opts.occurredAt).toISOString() : void 0;
-    const entry = MeshRuntimeStore.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
-    if (!entry) return null;
+    const entry = store.findAssignedBySession(meshId, sessionId, occurredAtIso, opts?.taskId);
+    if (!entry) {
+      const assignedRows = store.getActiveAssignmentDetails(meshId).filter((r) => r.sessionId === sessionId);
+      if (assignedRows.length > 0) {
+        LOG.warn("MeshQueue", `No assigned queue row matched completion for mesh ${meshId} session ${sessionId} (taskId=${opts?.taskId ?? "none"}, occurredAt=${occurredAtIso ?? "none"}); ${assignedRows.length} assigned row(s) exist: ${assignedRows.map((r) => r.id).join(",")}`);
+      }
+      return null;
+    }
     entry.status = status;
-    MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+    store.updateQueueEntry(entry);
     if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, entry.id);
     return entry;
   });
@@ -3796,6 +4135,7 @@ var init_mesh_work_queue = __esm({
     init_repo_mesh_types();
     init_mesh_runtime_store();
     init_mesh_config();
+    init_logger();
     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"];
@@ -3854,8 +4194,7 @@ var init_mesh_work_queue = __esm({
 // src/mesh/mesh-runtime-store.ts
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
-  const runtimeRequire = typeof require === "function" ? require : (0, import_module.createRequire)(import_meta.url);
-  DatabaseCtor = runtimeRequire("better-sqlite3");
+  DatabaseCtor = loadBetterSqlite3();
   return DatabaseCtor;
 }
 function safeMeshId(meshId) {
@@ -3882,16 +4221,15 @@ function meshRuntimeStorePath() {
   }
   return nextPath;
 }
-var import_fs5, import_path5, import_module, import_meta, DatabaseCtor, MeshRuntimeStore;
+var import_fs5, import_path5, DatabaseCtor, MeshRuntimeStore;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
     import_fs5 = require("fs");
     import_path5 = require("path");
-    import_module = require("module");
+    init_load_better_sqlite3();
     init_mesh_ledger();
     init_mesh_work_queue();
-    import_meta = {};
     MeshRuntimeStore = class _MeshRuntimeStore {
       static instance;
       db;
@@ -4456,12 +4794,51 @@ var init_mesh_runtime_store = __esm({
           return { id, nodeId: r.assigned_node_id ?? void 0, sessionId: r.assigned_session_id ?? void 0, message };
         });
       }
-      findAssignedBySession(meshId, sessionId, occurredAtIso) {
+      /**
+       * Resolve the `assigned` queue row a completion event belongs to.
+       *
+       * Clock-skew safety (C2): a completion event's `occurredAtIso` carries the
+       * REMOTE WORKER's clock, while `updated_at` carries the COORDINATOR's clock
+       * (set at assignment and re-bumped on every mutation). For a remote node,
+       * coordinator-clock > worker-clock skew used to make an `updated_at <= occurredAt`
+       * filter return nothing, stranding the finished task as `assigned` forever.
+       *
+       * We therefore NEVER filter completion-matching on the mutable `updated_at`:
+       *  1. If `taskId` is given, match the exact `assigned` row by id (no time filter).
+       *  2. Otherwise a session holds at most one `assigned` task — match it without a
+       *     time filter. If several exist (shouldn't normally), disambiguate by the
+       *     IMMUTABLE `dispatchTimestamp`: latest `dispatchTimestamp <= occurredAt`,
+       *     and if skew makes ALL of them later than `occurredAt`, fall back to the
+       *     most-recent `dispatchTimestamp` rather than returning null.
+       */
+      findAssignedBySession(meshId, sessionId, occurredAtIso, taskId) {
         this.ensureLegacyQueueMigrated(meshId);
-        const sql = occurredAtIso ? `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' AND updated_at <= ? ORDER BY updated_at DESC LIMIT 1` : `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' ORDER BY updated_at DESC LIMIT 1`;
-        const args = occurredAtIso ? [meshId, sessionId, occurredAtIso] : [meshId, sessionId];
-        const row = this.db.prepare(sql).get(...args);
-        return row ? JSON.parse(row.payload) : null;
+        if (taskId) {
+          const row = this.db.prepare(
+            `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' AND id = ? LIMIT 1`
+          ).get(meshId, sessionId, taskId);
+          if (row) return JSON.parse(row.payload);
+        }
+        const rows = this.db.prepare(
+          `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned'`
+        ).all(meshId, sessionId);
+        if (rows.length === 0) return null;
+        const entries = rows.map((r) => {
+          try {
+            return JSON.parse(r.payload);
+          } catch {
+            return null;
+          }
+        }).filter((e) => e !== null);
+        if (entries.length === 0) return null;
+        if (entries.length === 1) return entries[0];
+        const orderKey = (e) => e.dispatchTimestamp ?? e.updatedAt ?? "";
+        const byDispatchDesc = [...entries].sort((a, b) => orderKey(b).localeCompare(orderKey(a)));
+        if (occurredAtIso) {
+          const atOrBefore = byDispatchDesc.find((e) => orderKey(e) <= occurredAtIso);
+          if (atOrBefore) return atOrBefore;
+        }
+        return byDispatchDesc[0];
       }
       toRow(entry) {
         return {
@@ -5717,297 +6094,6 @@ var init_mesh_review_inbox = __esm({
   }
 });
 
-// src/logging/async-batch-writer.ts
-var fs3, AsyncBatchWriter;
-var init_async_batch_writer = __esm({
-  "src/logging/async-batch-writer.ts"() {
-    "use strict";
-    fs3 = __toESM(require("fs"));
-    AsyncBatchWriter = class {
-      // Maps filePath -> string buffer
-      static buffers = /* @__PURE__ */ new Map();
-      static writePromises = /* @__PURE__ */ new Map();
-      static flushTimer = null;
-      /**
-       * Queues data to be written to a file asynchronously in a batch.
-       */
-      static write(filePath, data) {
-        let buf = this.buffers.get(filePath);
-        if (!buf) {
-          buf = [];
-          this.buffers.set(filePath, buf);
-        }
-        buf.push(data);
-        if (!this.flushTimer) {
-          this.flushTimer = setTimeout(() => {
-            this.flushTimer = null;
-            this.flushAll();
-          }, 50);
-        }
-      }
-      static async flushAll() {
-        const entries = Array.from(this.buffers.entries());
-        this.buffers.clear();
-        for (const [filePath, buffer] of entries) {
-          const dataToWrite = buffer.join("");
-          const doWrite = async () => {
-            try {
-              const prevPromise = this.writePromises.get(filePath);
-              if (prevPromise) await prevPromise;
-              await fs3.promises.appendFile(filePath, dataToWrite, { encoding: "utf-8", mode: 384 });
-            } catch {
-            }
-          };
-          const writePromise = doWrite();
-          this.writePromises.set(filePath, writePromise);
-          writePromise.finally(() => {
-            if (this.writePromises.get(filePath) === writePromise) {
-              this.writePromises.delete(filePath);
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/logging/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  LOG: () => LOG,
-  LOG_DIR_PATH: () => LOG_DIR_PATH,
-  LOG_PATH: () => LOG_PATH,
-  daemonLog: () => daemonLog,
-  getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
-  getDaemonLogDir: () => getDaemonLogDir,
-  getLogBufferSize: () => getLogBufferSize,
-  getLogLevel: () => getLogLevel,
-  getLogPath: () => getLogPath,
-  getRecentLogs: () => getRecentLogs,
-  installGlobalInterceptor: () => installGlobalInterceptor,
-  setLogLevel: () => setLogLevel
-});
-function setLogLevel(level) {
-  currentLevel = level;
-  daemonLog("Logger", `Log level set to: ${level}`, "info");
-}
-function getLogLevel() {
-  return currentLevel;
-}
-function getDateStr() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-function getDaemonLogDir() {
-  return LOG_DIR;
-}
-function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path9.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
-}
-function checkDateRotation() {
-  const today = getDateStr();
-  if (today !== currentDate) {
-    currentDate = today;
-    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
-    cleanOldLogs();
-  }
-}
-function cleanOldLogs() {
-  try {
-    const files = fs4.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
-    const cutoff = /* @__PURE__ */ new Date();
-    cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
-    const cutoffStr = cutoff.toISOString().slice(0, 10);
-    for (const file of files) {
-      const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
-      if (dateMatch && dateMatch[1] < cutoffStr) {
-        try {
-          fs4.unlinkSync(path9.join(LOG_DIR, file));
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-}
-function rotateSizeIfNeeded() {
-  try {
-    const stat2 = fs4.statSync(currentLogFile);
-    if (stat2.size > MAX_LOG_SIZE) {
-      const backup = currentLogFile.replace(".log", ".1.log");
-      try {
-        fs4.unlinkSync(backup);
-      } catch {
-      }
-      fs4.renameSync(currentLogFile, backup);
-    }
-  } catch {
-  }
-}
-function writeToFile(line) {
-  try {
-    if (++writeCount % 1e3 === 0) {
-      checkDateRotation();
-      rotateSizeIfNeeded();
-    }
-    AsyncBatchWriter.write(currentLogFile, line + "\n");
-  } catch {
-  }
-}
-function getRecentLogs(count = 50, minLevel = "info") {
-  const minNum = LEVEL_NUM[minLevel];
-  const filtered = ringBuffer.filter((e) => LEVEL_NUM[e.level] >= minNum);
-  return filtered.slice(-count);
-}
-function getLogBufferSize() {
-  return ringBuffer.length;
-}
-function ts() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-}
-function fullTs() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function daemonLog(category, msg, level = "info") {
-  const shouldOutput = LEVEL_NUM[level] >= LEVEL_NUM[currentLevel];
-  const label = LEVEL_LABEL[level];
-  const line = `[${ts()}] [${label}] [${category}] ${msg}`;
-  if (!shouldOutput) return;
-  writeToFile(line);
-  ringBuffer.push({ ts: Date.now(), level, category, message: msg });
-  if (ringBuffer.length > RING_BUFFER_SIZE) {
-    ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-  }
-  origConsoleLog(line);
-}
-function installGlobalInterceptor() {
-  if (interceptorInstalled) return;
-  interceptorInstalled = true;
-  const stripAnsi4 = (str) => str.replace(/\x1B\[[0-9;]*m/g, "");
-  const isDaemonLogLine = (msg) => /\[(DBG|INF|WRN|ERR)\]/.test(msg);
-  console.log = (...args) => {
-    origConsoleLog(...args);
-    try {
-      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-      const clean = stripAnsi4(msg);
-      if (isDaemonLogLine(clean)) return;
-      const line = clean.startsWith("[20") ? clean : `[${fullTs()}] ${clean}`;
-      writeToFile(line);
-      const catMatch = clean.match(/\[([^\]]+)\]/);
-      ringBuffer.push({
-        ts: Date.now(),
-        level: "info",
-        category: catMatch?.[1] || "System",
-        message: clean
-      });
-      if (ringBuffer.length > RING_BUFFER_SIZE) {
-        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-      }
-    } catch {
-    }
-  };
-  console.error = (...args) => {
-    origConsoleError(...args);
-    try {
-      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-      const clean = stripAnsi4(msg);
-      if (isDaemonLogLine(clean)) return;
-      const line = `[${fullTs()}] [ERROR] ${clean}`;
-      writeToFile(line);
-      ringBuffer.push({ ts: Date.now(), level: "error", category: "System", message: clean });
-      if (ringBuffer.length > RING_BUFFER_SIZE) {
-        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-      }
-    } catch {
-    }
-  };
-  console.warn = (...args) => {
-    origConsoleWarn(...args);
-    try {
-      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-      const clean = stripAnsi4(msg);
-      if (isDaemonLogLine(clean)) return;
-      const line = `[${fullTs()}] [WARN] ${clean}`;
-      writeToFile(line);
-      ringBuffer.push({ ts: Date.now(), level: "warn", category: "System", message: clean });
-      if (ringBuffer.length > RING_BUFFER_SIZE) {
-        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-      }
-    } catch {
-    }
-  };
-  writeToFile(`
-=== ADHDev Daemon started at ${fullTs()} ===`);
-  writeToFile(`Log file: ${currentLogFile}`);
-  writeToFile(`Log level: ${currentLevel}`);
-}
-function getLogPath() {
-  return currentLogFile;
-}
-var fs4, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
-var init_logger = __esm({
-  "src/logging/logger.ts"() {
-    "use strict";
-    fs4 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
-    os3 = __toESM(require("os"));
-    init_async_batch_writer();
-    LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
-    LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
-    currentLevel = "info";
-    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os3.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os3.homedir(), "Library", "Logs", "adhdev") : path9.join(os3.homedir(), ".local", "share", "adhdev", "logs");
-    MAX_LOG_SIZE = 5 * 1024 * 1024;
-    MAX_LOG_DAYS = 7;
-    try {
-      fs4.mkdirSync(LOG_DIR, { recursive: true });
-    } catch {
-    }
-    currentDate = getDateStr();
-    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
-    cleanOldLogs();
-    try {
-      const oldLog = path9.join(LOG_DIR, "daemon.log");
-      if (fs4.existsSync(oldLog)) {
-        const stat2 = fs4.statSync(oldLog);
-        const oldDate = stat2.mtime.toISOString().slice(0, 10);
-        fs4.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
-      }
-      const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
-      if (fs4.existsSync(oldLogBackup)) {
-        fs4.unlinkSync(oldLogBackup);
-      }
-    } catch {
-    }
-    writeCount = 0;
-    RING_BUFFER_SIZE = 200;
-    ringBuffer = [];
-    origConsoleLog = console.log.bind(console);
-    origConsoleError = console.error.bind(console);
-    origConsoleWarn = console.warn.bind(console);
-    LOG = {
-      debug: (category, msg) => daemonLog(category, msg, "debug"),
-      info: (category, msg) => daemonLog(category, msg, "info"),
-      warn: (category, msg) => daemonLog(category, msg, "warn"),
-      error: (category, msg) => daemonLog(category, msg, "error"),
-      /**
-       * Create a scoped logger for a specific component.
-       * Category is baked in so callers only pass the message.
-       */
-      forComponent(category) {
-        return {
-          debug: (msg) => daemonLog(category, msg, "debug"),
-          info: (msg) => daemonLog(category, msg, "info"),
-          warn: (msg) => daemonLog(category, msg, "warn"),
-          error: (msg) => daemonLog(category, msg, "error"),
-          asLogFn: (level = "info") => (msg) => daemonLog(category, msg, level)
-        };
-      }
-    };
-    interceptorInstalled = false;
-    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
-    LOG_DIR_PATH = LOG_DIR;
-  }
-});
-
 // src/commands/mesh-coordinator.ts
 var mesh_coordinator_exports = {};
 __export(mesh_coordinator_exports, {
@@ -6409,6 +6495,59 @@ var init_mesh_coordinator = __esm({
   }
 });
 
+// src/cli-adapters/resolve-executable.ts
+function resolveWin32GlobalBin(trimmed) {
+  if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\")) {
+    return null;
+  }
+  const extraDirs = [];
+  if (process.env.APPDATA) extraDirs.push(path10.join(process.env.APPDATA, "npm"));
+  try {
+    extraDirs.push(path10.dirname(process.execPath));
+  } catch {
+  }
+  for (const dir of extraDirs) {
+    if (!dir) continue;
+    for (const ext of WIN_EXEC_EXT) {
+      const full = path10.join(dir, trimmed + ext);
+      if ((0, import_fs8.existsSync)(full)) return full;
+    }
+  }
+  return null;
+}
+function resolveWin32Executable(command) {
+  if (process.platform !== "win32") return command;
+  const trimmed = (command || "").trim();
+  if (!trimmed) return command;
+  if (path10.isAbsolute(trimmed) && (0, import_fs8.existsSync)(trimmed)) return trimmed;
+  try {
+    const out = (0, import_child_process.execFileSync)("where", [trimmed], {
+      encoding: "utf8",
+      windowsHide: true
+    }).trim();
+    if (out) {
+      const matches = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+      const direct = matches.find((m) => DIRECT_EXEC_EXT.has(path10.extname(m).toLowerCase()));
+      return direct || matches[0] || command;
+    }
+  } catch {
+  }
+  const globalBin = resolveWin32GlobalBin(trimmed);
+  if (globalBin) return globalBin;
+  return command;
+}
+var import_child_process, import_fs8, path10, DIRECT_EXEC_EXT, WIN_EXEC_EXT;
+var init_resolve_executable = __esm({
+  "src/cli-adapters/resolve-executable.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_fs8 = require("fs");
+    path10 = __toESM(require("path"));
+    DIRECT_EXEC_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
+    WIN_EXEC_EXT = [".exe", ".com", ".cmd", ".bat"];
+  }
+});
+
 // src/mesh/mesh-fast-forward.ts
 async function fastForwardMeshNode(args) {
   const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
@@ -7932,9 +8071,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path42 of paths) {
-    if (!(0, import_fs9.existsSync)(path42)) continue;
+    if (!(0, import_fs10.existsSync)(path42)) continue;
     try {
-      const raw = (0, import_fs9.readFileSync)(path42, "utf-8");
+      const raw = (0, import_fs10.readFileSync)(path42, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -8009,11 +8148,11 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path42) {
   try {
-    if (!(0, import_fs9.existsSync)(path42)) return;
-    if ((0, import_fs9.statSync)(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = (0, import_fs9.readFileSync)(path42, "utf-8").split("\n").filter(Boolean);
+    if (!(0, import_fs10.existsSync)(path42)) return;
+    if ((0, import_fs10.statSync)(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = (0, import_fs10.readFileSync)(path42, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
-    (0, import_fs9.writeFileSync)(path42, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    (0, import_fs10.writeFileSync)(path42, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -8042,7 +8181,7 @@ function queuePendingMeshCoordinatorEvent(event) {
     }
     const path42 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
     trimPendingEventsIfNeeded(path42);
-    (0, import_fs9.appendFileSync)(path42, JSON.stringify(event) + "\n", "utf-8");
+    (0, import_fs10.appendFileSync)(path42, JSON.stringify(event) + "\n", "utf-8");
     return true;
   } catch (e) {
     LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -8052,20 +8191,20 @@ function queuePendingMeshCoordinatorEvent(event) {
 function atomicDrainFile(path42) {
   const tmpPath = `${path42}.draining`;
   try {
-    (0, import_fs9.renameSync)(path42, tmpPath);
+    (0, import_fs10.renameSync)(path42, tmpPath);
   } catch {
     return null;
   }
   try {
-    const content = (0, import_fs9.readFileSync)(tmpPath, "utf-8");
+    const content = (0, import_fs10.readFileSync)(tmpPath, "utf-8");
     try {
-      (0, import_fs9.unlinkSync)(tmpPath);
+      (0, import_fs10.unlinkSync)(tmpPath);
     } catch {
     }
     return content;
   } catch {
     try {
-      (0, import_fs9.unlinkSync)(tmpPath);
+      (0, import_fs10.unlinkSync)(tmpPath);
     } catch {
     }
     return null;
@@ -8074,16 +8213,16 @@ function atomicDrainFile(path42) {
 function selectiveDrainFile(path42, predicate) {
   const tmpPath = `${path42}.draining`;
   try {
-    (0, import_fs9.renameSync)(path42, tmpPath);
+    (0, import_fs10.renameSync)(path42, tmpPath);
   } catch {
     return [];
   }
   let content;
   try {
-    content = (0, import_fs9.readFileSync)(tmpPath, "utf-8");
+    content = (0, import_fs10.readFileSync)(tmpPath, "utf-8");
   } catch {
     try {
-      (0, import_fs9.unlinkSync)(tmpPath);
+      (0, import_fs10.unlinkSync)(tmpPath);
     } catch {
     }
     return [];
@@ -8106,12 +8245,12 @@ function selectiveDrainFile(path42, predicate) {
   }
   try {
     if (keptLines.length > 0) {
-      (0, import_fs9.writeFileSync)(path42, keptLines.join("\n") + "\n", "utf-8");
+      (0, import_fs10.writeFileSync)(path42, keptLines.join("\n") + "\n", "utf-8");
     }
-    (0, import_fs9.unlinkSync)(tmpPath);
+    (0, import_fs10.unlinkSync)(tmpPath);
   } catch {
     try {
-      if ((0, import_fs9.existsSync)(tmpPath) && !(0, import_fs9.existsSync)(path42)) (0, import_fs9.renameSync)(tmpPath, path42);
+      if ((0, import_fs10.existsSync)(tmpPath) && !(0, import_fs10.existsSync)(path42)) (0, import_fs10.renameSync)(tmpPath, path42);
     } catch {
     }
     return [];
@@ -8205,17 +8344,17 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path42 of paths) {
-    if ((0, import_fs9.existsSync)(path42)) try {
-      (0, import_fs9.unlinkSync)(path42);
+    if ((0, import_fs10.existsSync)(path42)) try {
+      (0, import_fs10.unlinkSync)(path42);
     } catch {
     }
   }
 }
-var import_fs9, import_path9, import_crypto7, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs10, import_path9, import_crypto7, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
-    import_fs9 = require("fs");
+    import_fs10 = require("fs");
     import_path9 = require("path");
     import_crypto7 = require("crypto");
     init_logger();
@@ -8710,24 +8849,24 @@ function buildCliScreenSnapshot(text) {
 function findBinary(name) {
   const trimmed = String(name || "").trim();
   if (!trimmed) return trimmed;
-  const expanded = trimmed.startsWith("~") ? path10.join(os5.homedir(), trimmed.slice(1)) : trimmed;
-  if (path10.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
-    return path10.isAbsolute(expanded) ? expanded : path10.resolve(expanded);
+  const expanded = trimmed.startsWith("~") ? path11.join(os5.homedir(), trimmed.slice(1)) : trimmed;
+  if (path11.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
+    return path11.isAbsolute(expanded) ? expanded : path11.resolve(expanded);
   }
   const isWin = os5.platform() === "win32";
-  const paths = (process.env.PATH || "").split(path10.delimiter);
+  const paths = (process.env.PATH || "").split(path11.delimiter);
   const extraDirs = [];
   if (isWin) {
-    if (process.env.APPDATA) extraDirs.push(path10.join(process.env.APPDATA, "npm"));
+    if (process.env.APPDATA) extraDirs.push(path11.join(process.env.APPDATA, "npm"));
     try {
-      extraDirs.push(path10.dirname(process.execPath));
+      extraDirs.push(path11.dirname(process.execPath));
     } catch {
     }
   } else {
-    extraDirs.push(path10.join(os5.homedir(), ".npm-global", "bin"));
+    extraDirs.push(path11.join(os5.homedir(), ".npm-global", "bin"));
     extraDirs.push("/usr/local/bin", "/opt/homebrew/bin");
     try {
-      extraDirs.push(path10.dirname(process.execPath));
+      extraDirs.push(path11.dirname(process.execPath));
     } catch {
     }
   }
@@ -8736,7 +8875,7 @@ function findBinary(name) {
   for (const p of searchDirs) {
     if (!p) continue;
     for (const ext of exes) {
-      const fullPath = path10.join(p, trimmed + ext);
+      const fullPath = path11.join(p, trimmed + ext);
       try {
         const fs32 = require("fs");
         if (fs32.existsSync(fullPath)) {
@@ -8752,7 +8891,7 @@ function findBinary(name) {
   return isWin ? `${trimmed}.cmd` : trimmed;
 }
 function isScriptBinary(binaryPath) {
-  if (!path10.isAbsolute(binaryPath)) return false;
+  if (!path11.isAbsolute(binaryPath)) return false;
   try {
     const fs32 = require("fs");
     const resolved = fs32.realpathSync(binaryPath);
@@ -8768,7 +8907,7 @@ function isScriptBinary(binaryPath) {
   }
 }
 function looksLikeMachOOrElf(filePath) {
-  if (!path10.isAbsolute(filePath)) return false;
+  if (!path11.isAbsolute(filePath)) return false;
   try {
     const fs32 = require("fs");
     const resolved = fs32.realpathSync(filePath);
@@ -8857,12 +8996,12 @@ function normalizeCliProviderForRuntime(raw) {
     }
   };
 }
-var os5, path10, TerminalTranscriptAccumulator, buildCliSpawnEnv;
+var os5, path11, TerminalTranscriptAccumulator, buildCliSpawnEnv;
 var init_provider_cli_shared = __esm({
   "src/cli-adapters/provider-cli-shared.ts"() {
     "use strict";
     os5 = __toESM(require("os"));
-    path10 = __toESM(require("path"));
+    path11 = __toESM(require("path"));
     init_spawn_env();
     TerminalTranscriptAccumulator = class {
       lines = [[]];
@@ -9036,19 +9175,19 @@ function shellQuote(value) {
 function expandHome(value) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("~")) return trimmed;
-  return path11.join(os6.homedir(), trimmed.slice(1));
+  return path12.join(os6.homedir(), trimmed.slice(1));
 }
 function isExplicitCommandPath(command) {
   const trimmed = command.trim();
-  return path11.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+  return path12.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
 }
 function resolveCommandPath(command) {
   const trimmed = command.trim();
   if (!trimmed) return null;
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
-    const candidate = path11.isAbsolute(expanded) ? expanded : path11.resolve(expanded);
-    return (0, import_fs10.existsSync)(candidate) ? candidate : null;
+    const candidate = path12.isAbsolute(expanded) ? expanded : path12.resolve(expanded);
+    return (0, import_fs11.existsSync)(candidate) ? candidate : null;
   }
   return null;
 }
@@ -9058,12 +9197,12 @@ async function resolveDetectionPath(command, whichCmd) {
   const whichResult = await execAsync(`${whichCmd} ${shellQuote(command)}`);
   if (whichResult) return whichResult.split("\n")[0];
   const resolved = findBinary(command);
-  if (path11.isAbsolute(resolved) && (0, import_fs10.existsSync)(resolved)) return resolved;
+  if (path12.isAbsolute(resolved) && (0, import_fs11.existsSync)(resolved)) return resolved;
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
   return new Promise((resolve24) => {
-    const child = (0, import_child_process.exec)(cmd, {
+    const child = (0, import_child_process2.exec)(cmd, {
       encoding: "utf-8",
       timeout: timeoutMs,
       ...process.platform === "win32" ? { windowsHide: true } : {}
@@ -9153,14 +9292,14 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process, os6, path11, import_fs10;
+var import_child_process2, os6, path12, import_fs11;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
-    import_child_process = require("child_process");
+    import_child_process2 = require("child_process");
     os6 = __toESM(require("os"));
-    path11 = __toESM(require("path"));
-    import_fs10 = require("fs");
+    path12 = __toESM(require("path"));
+    import_fs11 = require("fs");
     init_provider_cli_shared();
   }
 });
@@ -9418,8 +9557,8 @@ function resolveCoordinatorDrainDaemonIds(components) {
 }
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
-  const cached2 = meshByWorkspaceCache.get(workspace);
-  if (cached2 && now - cached2.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached2.mesh;
+  const cached3 = meshByWorkspaceCache.get(workspace);
+  if (cached3 && now - cached3.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached3.mesh;
   const mesh = getMeshByRepo(workspace);
   meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
   return mesh;
@@ -10195,7 +10334,7 @@ async function maybeAutoFastForwardIdleNode(components, args) {
   const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
   const workspace = readNonEmptyString2(node?.workspace);
   if (!workspace) return;
-  if (!(0, import_fs11.existsSync)(workspace)) return;
+  if (!(0, import_fs12.existsSync)(workspace)) return;
   const policy = resolveAutoFastForwardPolicy(mesh);
   if (!policy.enabled) return;
   if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
@@ -10394,8 +10533,10 @@ function injectMeshSystemMessage(components, args) {
     }
   }
   function markSessionTerminal(sessionId, outcome, occurredAtMs) {
+    const eventTaskId = readNonEmptyString2(args.metadataEvent.taskId) || void 0;
     const task = updateSessionTaskStatus(args.meshId, sessionId, outcome, {
-      occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : void 0
+      occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : void 0,
+      taskId: eventTaskId
     });
     updateDirectDispatchStatus(args.meshId, sessionId, outcome);
     markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);
@@ -10806,11 +10947,11 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs11, REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
+var import_fs12, REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
 var init_mesh_events_coordinator = __esm({
   "src/mesh/mesh-events-coordinator.ts"() {
     "use strict";
-    import_fs11 = require("fs");
+    import_fs12 = require("fs");
     init_config();
     init_mesh_config();
     init_cli_detector();
@@ -12692,16 +12833,16 @@ __export(external_sources_exports, {
   sourcesProviding: () => sourcesProviding
 });
 function adhdevDir() {
-  return path17.join(os11.homedir(), ".adhdev");
+  return path18.join(os11.homedir(), ".adhdev");
 }
 function externalRoot() {
-  return path17.join(adhdevDir(), "external");
+  return path18.join(adhdevDir(), "external");
 }
 function sourcesFilePath() {
-  return path17.join(adhdevDir(), SOURCES_FILENAME);
+  return path18.join(adhdevDir(), SOURCES_FILENAME);
 }
 function activeFilePath() {
-  return path17.join(adhdevDir(), ACTIVE_FILENAME);
+  return path18.join(adhdevDir(), ACTIVE_FILENAME);
 }
 function ensureAdhdevDir() {
   const d = adhdevDir();
@@ -12768,7 +12909,7 @@ function inventoryExternalSources() {
   for (const sourceEntry of entries) {
     if (!sourceEntry.isDirectory()) continue;
     const sourceName = sourceEntry.name;
-    const sourceDir = path17.join(root, sourceName);
+    const sourceDir = path18.join(root, sourceName);
     const providers = {};
     let categoryEntries;
     try {
@@ -12779,7 +12920,7 @@ function inventoryExternalSources() {
     for (const categoryEntry of categoryEntries) {
       if (!categoryEntry.isDirectory()) continue;
       const category = categoryEntry.name;
-      const categoryDir = path17.join(sourceDir, category);
+      const categoryDir = path18.join(sourceDir, category);
       let typeEntries;
       try {
         typeEntries = fs9.readdirSync(categoryDir, { withFileTypes: true });
@@ -12789,9 +12930,9 @@ function inventoryExternalSources() {
       const types = [];
       for (const typeEntry of typeEntries) {
         if (!typeEntry.isDirectory()) continue;
-        const typeDir = path17.join(categoryDir, typeEntry.name);
-        const hasV1 = fs9.existsSync(path17.join(typeDir, "provider.v1.json"));
-        const hasV0 = fs9.existsSync(path17.join(typeDir, "provider.json"));
+        const typeDir = path18.join(categoryDir, typeEntry.name);
+        const hasV1 = fs9.existsSync(path18.join(typeDir, "provider.v1.json"));
+        const hasV0 = fs9.existsSync(path18.join(typeDir, "provider.json"));
         if (hasV1 || hasV0) types.push(typeEntry.name);
       }
       if (types.length > 0) providers[category] = types;
@@ -12814,13 +12955,13 @@ function resolveActiveSource(category, type, activeFile) {
   }
   return { source: candidates[0], ambiguous: true, candidates };
 }
-var fs9, os11, path17, SOURCES_FILENAME, ACTIVE_FILENAME;
+var fs9, os11, path18, SOURCES_FILENAME, ACTIVE_FILENAME;
 var init_external_sources = __esm({
   "src/providers/external-sources.ts"() {
     "use strict";
     fs9 = __toESM(require("fs"));
     os11 = __toESM(require("os"));
-    path17 = __toESM(require("path"));
+    path18 = __toESM(require("path"));
     SOURCES_FILENAME = "providers-sources.json";
     ACTIVE_FILENAME = "providers-active.json";
   }
@@ -12998,59 +13139,6 @@ var init_terminal_screen = __esm({
   }
 });
 
-// src/cli-adapters/resolve-executable.ts
-function resolveWin32GlobalBin(trimmed) {
-  if (path18.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\")) {
-    return null;
-  }
-  const extraDirs = [];
-  if (process.env.APPDATA) extraDirs.push(path18.join(process.env.APPDATA, "npm"));
-  try {
-    extraDirs.push(path18.dirname(process.execPath));
-  } catch {
-  }
-  for (const dir of extraDirs) {
-    if (!dir) continue;
-    for (const ext of WIN_EXEC_EXT) {
-      const full = path18.join(dir, trimmed + ext);
-      if ((0, import_fs14.existsSync)(full)) return full;
-    }
-  }
-  return null;
-}
-function resolveWin32Executable(command) {
-  if (process.platform !== "win32") return command;
-  const trimmed = (command || "").trim();
-  if (!trimmed) return command;
-  if (path18.isAbsolute(trimmed) && (0, import_fs14.existsSync)(trimmed)) return trimmed;
-  try {
-    const out = (0, import_child_process4.execFileSync)("where", [trimmed], {
-      encoding: "utf8",
-      windowsHide: true
-    }).trim();
-    if (out) {
-      const matches = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-      const direct = matches.find((m) => DIRECT_EXEC_EXT.has(path18.extname(m).toLowerCase()));
-      return direct || matches[0] || command;
-    }
-  } catch {
-  }
-  const globalBin = resolveWin32GlobalBin(trimmed);
-  if (globalBin) return globalBin;
-  return command;
-}
-var import_child_process4, import_fs14, path18, DIRECT_EXEC_EXT, WIN_EXEC_EXT;
-var init_resolve_executable = __esm({
-  "src/cli-adapters/resolve-executable.ts"() {
-    "use strict";
-    import_child_process4 = require("child_process");
-    import_fs14 = require("fs");
-    path18 = __toESM(require("path"));
-    DIRECT_EXEC_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
-    WIN_EXEC_EXT = [".exe", ".com", ".cmd", ".bat"];
-  }
-});
-
 // src/cli-adapters/pty-transport.ts
 var pty_transport_exports = {};
 __export(pty_transport_exports, {
@@ -15265,10 +15353,10 @@ ${lastSnapshot}`;
         return this.accumulatedRawBuffer.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
       }
       getFreshParsedStatusCache() {
-        const cached2 = this.parsedStatusCache;
+        const cached3 = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-        if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.engine.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBufferKey === accumulatedRawBufferKey && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.engine.currentStatus && cached2.activeModal === this.engine.activeModal && cached2.cliName === this.cliName) {
-          return cached2.result;
+        if (cached3 && cached3.responseBuffer === this.responseBuffer && cached3.currentTurnScope === this.engine.currentTurnScope && cached3.recentOutputBuffer === this.recentOutputBuffer && cached3.accumulatedBuffer === this.accumulatedBuffer && cached3.accumulatedRawBufferKey === accumulatedRawBufferKey && cached3.screenText === this.lastScreenText && cached3.currentStatus === this.engine.currentStatus && cached3.activeModal === this.engine.activeModal && cached3.cliName === this.cliName) {
+          return cached3.result;
         }
         return null;
       }
@@ -15730,10 +15818,10 @@ ${lastSnapshot}`;
       getScriptParsedStatus() {
         const screenText = this.readTerminalScreenText();
         const parseScreenText = this.getParseScreenText(screenText);
-        const cached2 = this.parsedStatusCache;
+        const cached3 = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-        if (!this.providerOwnsTranscript() && cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.engine.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBufferKey === accumulatedRawBufferKey && cached2.screenText === parseScreenText && cached2.currentStatus === this.engine.currentStatus && cached2.activeModal === this.engine.activeModal && cached2.cliName === this.cliName) {
-          return cached2.result;
+        if (!this.providerOwnsTranscript() && cached3 && cached3.responseBuffer === this.responseBuffer && cached3.currentTurnScope === this.engine.currentTurnScope && cached3.recentOutputBuffer === this.recentOutputBuffer && cached3.accumulatedBuffer === this.accumulatedBuffer && cached3.accumulatedRawBufferKey === accumulatedRawBufferKey && cached3.screenText === parseScreenText && cached3.currentStatus === this.engine.currentStatus && cached3.activeModal === this.engine.activeModal && cached3.cliName === this.cliName) {
+          return cached3.result;
         }
         const parsed = this.runParseSession();
         if (!parsed || !Array.isArray(parsed.messages)) {
@@ -19754,13 +19842,20 @@ var MESH_REFINE_CONFIG_SCHEMA = {
 function isMeshConfigRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
+var SHELL_METACHAR_RE = /[;&|<>`$\n\r'"]/;
+var SAFE_TOKEN_RE = /^[A-Za-z0-9_@./:=+-]+$/;
+var SAFE_WIN32_EXEC_TOKEN_RE = /^[A-Za-z0-9_@./:=+\\-]+$/;
 function tokenizeCommandString(command) {
   const trimmed = command.trim();
   if (!trimmed) return null;
-  if (/[;&|<>`$\\\n\r'\"]/.test(trimmed)) return null;
+  if (SHELL_METACHAR_RE.test(trimmed)) return null;
   const tokens = trimmed.split(/\s+/).filter(Boolean);
   if (!tokens.length) return null;
-  if (tokens.some((token) => !/^[A-Za-z0-9_@./:=+-]+$/.test(token))) return null;
+  const isWin32 = process.platform === "win32";
+  for (let i = 0; i < tokens.length; i++) {
+    const re = isWin32 && i === 0 ? SAFE_WIN32_EXEC_TOKEN_RE : SAFE_TOKEN_RE;
+    if (!re.test(tokens[i])) return null;
+  }
   return tokens;
 }
 function validateCategory(value) {
@@ -19970,12 +20065,13 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
 }
 
 // src/mesh/worktree-bootstrap-config.ts
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 var import_path8 = require("path");
 var import_node_child_process3 = require("child_process");
 var import_node_crypto2 = require("crypto");
 var import_node_util3 = require("util");
 var yaml3 = __toESM(require("js-yaml"));
+init_resolve_executable();
 var MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS = [
   ".adhdev/worktree_bootstrap.json",
   ".adhdev/worktree_bootstrap.yaml",
@@ -20063,9 +20159,9 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
   }
   for (const relative5 of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
     const configPath = (0, import_path8.join)(workspace, relative5);
-    if (!(0, import_fs8.existsSync)(configPath)) continue;
+    if (!(0, import_fs9.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText3(configPath, (0, import_fs8.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText3(configPath, (0, import_fs9.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshWorktreeBootstrapConfig(parsed, relative5);
       if (!validation.valid) return { source: relative5, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative5, sourceType: "repo_file", path: configPath };
@@ -20080,7 +20176,7 @@ function computeStaleInputsDigest(workspace, staleInputs) {
   for (const relative5 of staleInputs ?? []) {
     const filePath = (0, import_path8.join)(workspace, relative5);
     try {
-      digest[relative5] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs8.readFileSync)(filePath)).digest("hex");
+      digest[relative5] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs9.readFileSync)(filePath)).digest("hex");
     } catch {
       digest[relative5] = "absent";
     }
@@ -20150,10 +20246,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs8.existsSync)((0, import_path8.join)(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs9.existsSync)((0, import_path8.join)(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs8.existsSync)((0, import_path8.join)(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs9.existsSync)((0, import_path8.join)(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -20164,8 +20260,9 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     const cwd = command.cwd ? (0, import_path8.resolve)(workspace, command.cwd) : workspace;
     const startedAt = Date.now();
     state.lastCommand = command.displayCommand;
+    const resolvedCommand = resolveWin32Executable(command.command);
     try {
-      const result = await execFileAsync4(command.command, command.args, {
+      const result = await execFileAsync4(resolvedCommand, command.args, {
         cwd,
         encoding: "utf8",
         timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS2,
@@ -20400,7 +20497,7 @@ var P2pRelayFailureError = class extends Error {
 };
 
 // src/config/state-store.ts
-var import_fs12 = require("fs");
+var import_fs13 = require("fs");
 var import_path10 = require("path");
 init_config();
 var DEFAULT_STATE = {
@@ -20451,11 +20548,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs12.existsSync)(statePath)) {
+  if (!(0, import_fs13.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs12.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs13.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -20464,28 +20561,28 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs12.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs13.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
 }
 
 // src/detection/ide-detector.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_fs13 = require("fs");
+var import_fs14 = require("fs");
 var import_os2 = require("os");
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 
 // src/detection/win32-ide-version.ts
 var fs5 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 function manifestCandidates(exeDir) {
   return [
-    path12.join(exeDir, "resources", "app", "product.json"),
-    path12.join(exeDir, "resources", "app", "package.json"),
+    path13.join(exeDir, "resources", "app", "product.json"),
+    path13.join(exeDir, "resources", "app", "package.json"),
     // Some packagings keep product.json one level up.
-    path12.join(exeDir, "product.json")
+    path13.join(exeDir, "product.json")
   ];
 }
 function parseVersionFromManifest(raw) {
@@ -20503,9 +20600,9 @@ function readWin32IdeVersionFromDisk(exePath) {
   if (!exePath) return null;
   let exeDir;
   try {
-    exeDir = fs5.statSync(exePath).isDirectory() ? exePath : path12.dirname(exePath);
+    exeDir = fs5.statSync(exePath).isDirectory() ? exePath : path13.dirname(exePath);
   } catch {
-    exeDir = path12.dirname(exePath);
+    exeDir = path13.dirname(exePath);
   }
   for (const candidate of manifestCandidates(exeDir)) {
     try {
@@ -20519,7 +20616,7 @@ function readWin32IdeVersionFromDisk(exePath) {
 }
 function isKnownWin32GuiExe(binPath, win32ProcessNames) {
   if (!binPath) return false;
-  const base = path12.win32.basename(binPath).toLowerCase();
+  const base = path13.win32.basename(binPath).toLowerCase();
   if (!base.endsWith(".exe")) return false;
   for (const names of Object.values(win32ProcessNames)) {
     for (const name of names) {
@@ -20532,7 +20629,7 @@ function isKnownWin32GuiExe(binPath, win32ProcessNames) {
 }
 
 // src/detection/ide-detector.ts
-var execAsync2 = (0, import_util.promisify)(import_child_process2.exec);
+var execAsync2 = (0, import_util.promisify)(import_child_process3.exec);
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -20551,10 +20648,10 @@ function getMergedDefinitions() {
 function findCliCommand(command) {
   const trimmed = String(command || "").trim();
   if (!trimmed) return null;
-  if (path13.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
-    const candidate = trimmed.startsWith("~") ? path13.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
-    const resolved = path13.isAbsolute(candidate) ? candidate : path13.resolve(candidate);
-    return (0, import_fs13.existsSync)(resolved) ? resolved : null;
+  if (path14.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+    const candidate = trimmed.startsWith("~") ? path14.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
+    const resolved = path14.isAbsolute(candidate) ? candidate : path14.resolve(candidate);
+    return (0, import_fs14.existsSync)(resolved) ? resolved : null;
   }
   const isWin = (0, import_os2.platform)() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -20562,10 +20659,10 @@ function findCliCommand(command) {
   for (const p of paths) {
     if (!p) continue;
     for (const ext of exes) {
-      const fullPath = path13.join(p, trimmed + ext);
+      const fullPath = path14.join(p, trimmed + ext);
       try {
-        if ((0, import_fs13.existsSync)(fullPath)) {
-          const stat2 = (0, import_fs13.statSync)(fullPath);
+        if ((0, import_fs14.existsSync)(fullPath)) {
+          const stat2 = (0, import_fs14.statSync)(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -20579,13 +20676,13 @@ function findCliCommand(command) {
 function checkPathExists(paths) {
   const home = (0, import_os2.homedir)();
   for (const p of paths) {
-    const normalized = p.startsWith("~") ? path13.join(home, p.slice(1)) : p;
+    const normalized = p.startsWith("~") ? path14.join(home, p.slice(1)) : p;
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs13.existsSync)(resolved)) return resolved;
+      if ((0, import_fs14.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs13.existsSync)(normalized)) return normalized;
+      if ((0, import_fs14.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -20599,7 +20696,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os30 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs13.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs14.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os30 === "win32") {
       const { dirname: dirname17 } = await import("path");
@@ -20612,7 +20709,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs13.existsSync)(c)) {
+        if ((0, import_fs14.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -20639,9 +20736,9 @@ init_cli_detector();
 
 // src/system/host-memory.ts
 var os7 = __toESM(require("os"));
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_util2 = require("util");
-var execAsync3 = (0, import_util2.promisify)(import_child_process3.exec);
+var execAsync3 = (0, import_util2.promisify)(import_child_process4.exec);
 var cachedDarwinAvail = null;
 var darwinMemoryInterval = null;
 async function updateDarwinMemoryCache() {
@@ -22470,10 +22567,10 @@ ${cleanBody}`;
 
 // src/config/chat-history.ts
 var fs6 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 var os8 = __toESM(require("os"));
 init_chat_message_normalization();
-var HISTORY_DIR = path14.join(os8.homedir(), ".adhdev", "history");
+var HISTORY_DIR = path15.join(os8.homedir(), ".adhdev", "history");
 var RETAIN_DAYS = 30;
 var SAVED_HISTORY_INDEX_VERSION = 1;
 var SAVED_HISTORY_INDEX_FILE = ".saved-history-index.json";
@@ -22489,11 +22586,11 @@ var savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
 var BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
 var boundedTailReadCache = /* @__PURE__ */ new Map();
 function readBoundedTailCache(key, signature) {
-  const cached2 = boundedTailReadCache.get(key);
-  if (!cached2 || cached2.signature !== signature) return null;
+  const cached3 = boundedTailReadCache.get(key);
+  if (!cached3 || cached3.signature !== signature) return null;
   boundedTailReadCache.delete(key);
-  boundedTailReadCache.set(key, cached2);
-  return cached2.result;
+  boundedTailReadCache.set(key, cached3);
+  return cached3.result;
 }
 function writeBoundedTailCache(key, signature, result) {
   boundedTailReadCache.delete(key);
@@ -22659,7 +22756,7 @@ function extractSavedHistorySessionIdFromFile(file) {
 function buildSavedHistoryFileSignatureMap(dir, files) {
   return new Map(files.map((file) => {
     try {
-      const stat2 = fs6.statSync(path14.join(dir, file));
+      const stat2 = fs6.statSync(path15.join(dir, file));
       return [file, `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`];
     } catch {
       return [file, `${file}:missing`];
@@ -22670,7 +22767,7 @@ function buildSavedHistoryCacheSignature(files, fileSignatures) {
   return files.map((file) => fileSignatures.get(file) || `${file}:missing`).join("|");
 }
 function getSavedHistoryIndexFilePath(dir) {
-  return path14.join(dir, SAVED_HISTORY_INDEX_FILE);
+  return path15.join(dir, SAVED_HISTORY_INDEX_FILE);
 }
 function getSavedHistoryIndexLockPath(dir) {
   return `${getSavedHistoryIndexFilePath(dir)}${SAVED_HISTORY_INDEX_LOCK_SUFFIX}`;
@@ -22772,7 +22869,7 @@ function savePersistedSavedHistoryIndex(dir, entries) {
     }
     for (const file of Array.from(currentEntries.keys())) {
       if (incomingFiles.has(file)) continue;
-      if (!fs6.existsSync(path14.join(dir, file))) {
+      if (!fs6.existsSync(path15.join(dir, file))) {
         currentEntries.delete(file);
       }
     }
@@ -22798,7 +22895,7 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
     const indexStat = fs6.statSync(getSavedHistoryIndexFilePath(dir));
     const files = listHistoryFiles(dir);
     for (const file of files) {
-      const stat2 = fs6.statSync(path14.join(dir, file));
+      const stat2 = fs6.statSync(path15.join(dir, file));
       if (stat2.mtimeMs > indexStat.mtimeMs) return true;
     }
     return false;
@@ -22808,14 +22905,14 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
 }
 function buildSavedHistoryFileSignature(dir, file) {
   try {
-    const stat2 = fs6.statSync(path14.join(dir, file));
+    const stat2 = fs6.statSync(path15.join(dir, file));
     return `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
   } catch {
     return `${file}:missing`;
   }
 }
 function persistSavedHistoryFileSummaryEntry(agentType, dir, file, updater) {
-  const filePath = path14.join(dir, file);
+  const filePath = path15.join(dir, file);
   const result = withLockedPersistedSavedHistoryIndex(dir, (entries) => {
     const currentEntry = entries.get(file) || null;
     const nextSummary = updater(currentEntry?.summary || null);
@@ -22888,7 +22985,7 @@ function updateSavedHistoryIndexForAppendedMessages(agentType, dir, file, histor
 function computeSavedHistoryFileSummary(dir, file) {
   const historySessionId = extractSavedHistorySessionIdFromFile(file);
   if (!historySessionId) return null;
-  const filePath = path14.join(dir, file);
+  const filePath = path15.join(dir, file);
   const content = fs6.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   let messageCount = 0;
@@ -22975,11 +23072,11 @@ function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatur
   const summaryBySessionId = /* @__PURE__ */ new Map();
   const nextPersistedEntries = /* @__PURE__ */ new Map();
   for (const file of files.slice().sort()) {
-    const filePath = path14.join(dir, file);
+    const filePath = path15.join(dir, file);
     const signature = fileSignatures.get(file) || `${file}:missing`;
-    const cached2 = savedHistoryFileSummaryCache.get(filePath);
+    const cached3 = savedHistoryFileSummaryCache.get(filePath);
     const persisted = persistedEntries.get(file);
-    const reusableEntry = cached2?.signature === signature ? cached2 : persisted?.signature === signature ? persisted : null;
+    const reusableEntry = cached3?.signature === signature ? cached3 : persisted?.signature === signature ? persisted : null;
     const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(dir, file);
     const nextEntry = reusableEntry || {
       signature,
@@ -23095,12 +23192,12 @@ var ChatHistoryWriter = class {
         });
       }
       if (newMessages.length === 0) return;
-      const dir = path14.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path15.join(HISTORY_DIR, this.sanitize(agentType));
       fs6.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
       const fileName = `${filePrefix}${date}.jsonl`;
-      const filePath = path14.join(dir, fileName);
+      const filePath = path15.join(dir, fileName);
       const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
       fs6.appendFileSync(filePath, lines, "utf-8");
       updateSavedHistoryIndexForAppendedMessages(agentType, dir, fileName, effectiveHistoryKey, newMessages);
@@ -23191,11 +23288,11 @@ var ChatHistoryWriter = class {
     const ws = String(workspace || "").trim();
     if (!id || !ws) return;
     try {
-      const dir = path14.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path15.join(HISTORY_DIR, this.sanitize(agentType));
       fs6.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const fileName = `${this.sanitize(id)}_${date}.jsonl`;
-      const filePath = path14.join(dir, fileName);
+      const filePath = path15.join(dir, fileName);
       const record = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         receivedAt: Date.now(),
@@ -23241,14 +23338,14 @@ var ChatHistoryWriter = class {
         this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
         this.lastSeenCounts.delete(fromDedupKey);
       }
-      const dir = path14.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path15.join(HISTORY_DIR, this.sanitize(agentType));
       if (!fs6.existsSync(dir)) return;
       const fromPrefix = `${this.sanitize(fromId)}_`;
       const toPrefix = `${this.sanitize(toId)}_`;
       const files = fs6.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith(".jsonl"));
       for (const file of files) {
-        const sourcePath = path14.join(dir, file);
-        const targetPath = path14.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
+        const sourcePath = path15.join(dir, file);
+        const targetPath = path15.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
         const sourceLines = fs6.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
         const rewritten = sourceLines.map((line) => {
           try {
@@ -23282,13 +23379,13 @@ var ChatHistoryWriter = class {
     const sessionId = String(historySessionId || "").trim();
     if (!sessionId) return;
     try {
-      const dir = path14.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path15.join(HISTORY_DIR, this.sanitize(agentType));
       if (!fs6.existsSync(dir)) return;
       const prefix = `${this.sanitize(sessionId)}_`;
       const files = fs6.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
       const seen = /* @__PURE__ */ new Set();
       for (const file of files) {
-        const filePath = path14.join(dir, file);
+        const filePath = path15.join(dir, file);
         const lines = fs6.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
         const next = [];
         for (const line of lines) {
@@ -23342,11 +23439,11 @@ var ChatHistoryWriter = class {
       const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
       const agentDirs = fs6.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
       for (const dir of agentDirs) {
-        const dirPath = path14.join(HISTORY_DIR, dir.name);
+        const dirPath = path15.join(HISTORY_DIR, dir.name);
         const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
         let removedAny = false;
         for (const file of files) {
-          const filePath = path14.join(dirPath, file);
+          const filePath = path15.join(dirPath, file);
           const stat2 = fs6.statSync(filePath);
           if (stat2.mtimeMs < cutoff) {
             fs6.unlinkSync(filePath);
@@ -23475,16 +23572,16 @@ function readFileTailLines(filePath, needed) {
     incrementalTailCache.delete(filePath);
     return { lines: [], coversWholeFile: true };
   }
-  const cached2 = incrementalTailCache.get(filePath);
-  if (cached2) {
-    if (cached2.size === size && cached2.mtimeMs === mtimeMs) {
+  const cached3 = incrementalTailCache.get(filePath);
+  if (cached3) {
+    if (cached3.size === size && cached3.mtimeMs === mtimeMs) {
       incrementalTailCache.delete(filePath);
-      incrementalTailCache.set(filePath, cached2);
-      if (cached2.coversWholeFile || cached2.lines.length >= needed) {
-        return { lines: cached2.lines, coversWholeFile: cached2.coversWholeFile };
+      incrementalTailCache.set(filePath, cached3);
+      if (cached3.coversWholeFile || cached3.lines.length >= needed) {
+        return { lines: cached3.lines, coversWholeFile: cached3.coversWholeFile };
       }
-    } else if (size > cached2.size) {
-      const incremental = tryIncrementalTailGrowth(filePath, cached2, size, mtimeMs, needed);
+    } else if (size > cached3.size) {
+      const incremental = tryIncrementalTailGrowth(filePath, cached3, size, mtimeMs, needed);
       if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
     }
     incrementalTailCache.delete(filePath);
@@ -23510,22 +23607,22 @@ function readFileTailLines(filePath, needed) {
   storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
   return { lines: result.lines, coversWholeFile: result.coversWholeFile };
 }
-function tryIncrementalTailGrowth(filePath, cached2, size, mtimeMs, needed) {
+function tryIncrementalTailGrowth(filePath, cached3, size, mtimeMs, needed) {
   const fd = fs6.openSync(filePath, "r");
   try {
-    if (cached2.size > 0) {
+    if (cached3.size > 0) {
       const boundary = Buffer.alloc(1);
-      fs6.readSync(fd, boundary, 0, 1, cached2.size - 1);
+      fs6.readSync(fd, boundary, 0, 1, cached3.size - 1);
       if (boundary[0] !== 10) return null;
     }
-    const appendedLength = size - cached2.size;
+    const appendedLength = size - cached3.size;
     const appended = Buffer.alloc(appendedLength);
-    fs6.readSync(fd, appended, 0, appendedLength, cached2.size);
+    fs6.readSync(fd, appended, 0, appendedLength, cached3.size);
     const newLines = appended.toString("utf-8").split("\n");
     if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
-    const merged = cached2.lines.concat(newLines);
+    const merged = cached3.lines.concat(newLines);
     const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
-    const coversWholeFile = cached2.coversWholeFile && trimmed.length === merged.length;
+    const coversWholeFile = cached3.coversWholeFile && trimmed.length === merged.length;
     storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
     if (coversWholeFile || trimmed.length >= needed) {
       return { lines: trimmed, coversWholeFile };
@@ -23549,7 +23646,7 @@ function readBoundedTailRecords(agentType, dir, files, needed) {
   const seen = /* @__PURE__ */ new Set();
   let readAllFiles = true;
   for (let f = 0; f < files.length; f++) {
-    const filePath = path14.join(dir, files[f]);
+    const filePath = path15.join(dir, files[f]);
     const remaining = Math.max(0, needed - collected.length);
     const perFileNeeded = Math.min(needed, remaining + BOUNDED_TAIL_SLACK);
     const { lines, coversWholeFile } = readFileTailLines(filePath, perFileNeeded);
@@ -23582,7 +23679,7 @@ function readBoundedTailRecords(agentType, dir, files, needed) {
 function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, excludeRecentCount = 0, historyBehavior) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path14.join(HISTORY_DIR, sanitized);
+    const dir = path15.join(HISTORY_DIR, sanitized);
     if (!fs6.existsSync(dir)) return { messages: [], hasMore: false };
     const files = listHistoryFiles(dir, historySessionId);
     const bounded = isBoundedTailRequest(limit, offset, excludeRecentCount);
@@ -23590,8 +23687,8 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
       const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
       const cacheKey = `${sanitized}\0${historySessionId || ""}\0${offset}\0${limit}\0${excludeRecentCount}\0${historyBehavior?.collapseConsecutiveAssistantTurns ? "1" : "0"}`;
       const signature = buildSavedHistoryCacheSignature(files, fileSignatures);
-      const cached2 = readBoundedTailCache(cacheKey, signature);
-      if (cached2) return cached2;
+      const cached3 = readBoundedTailCache(cacheKey, signature);
+      if (cached3) return cached3;
       const numericLimit = Math.max(1, Number(limit));
       const numericOffset = Math.max(0, Number(offset));
       const numericExclude = Math.max(0, Number(excludeRecentCount));
@@ -23605,7 +23702,7 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
     const allMessages = [];
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
-      const filePath = path14.join(dir, file);
+      const filePath = path15.join(dir, file);
       const content = fs6.readFileSync(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       for (let i = 0; i < lines.length; i++) {
@@ -23629,28 +23726,28 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
 function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path14.join(HISTORY_DIR, sanitized);
+    const dir = path15.join(HISTORY_DIR, sanitized);
     if (!fs6.existsSync(dir)) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
     }
-    const cached2 = savedHistorySessionCache.get(sanitized);
+    const cached3 = savedHistorySessionCache.get(sanitized);
     const offset = Math.max(0, options.offset || 0);
     const limit = Math.max(1, options.limit || 30);
     const indexSignature = buildSavedHistoryIndexFileSignature(dir);
     let cacheWasInvalidated = false;
-    if (cached2) {
-      const cacheLooksPersisted = cached2.signature.startsWith("index:");
-      const cacheStillValid = cacheLooksPersisted ? cached2.signature === indexSignature : (() => {
+    if (cached3) {
+      const cacheLooksPersisted = cached3.signature.startsWith("index:");
+      const cacheStillValid = cacheLooksPersisted ? cached3.signature === indexSignature : (() => {
         const files2 = listHistoryFiles(dir);
         const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
-        return cached2.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+        return cached3.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
       })();
       if (cacheStillValid) {
-        const sliced2 = cached2.summaries.slice(offset, offset + limit);
+        const sliced2 = cached3.summaries.slice(offset, offset + limit);
         return {
           sessions: sliced2,
-          hasMore: cached2.summaries.length > offset + limit
+          hasMore: cached3.summaries.length > offset + limit
         };
       }
       cacheWasInvalidated = true;
@@ -23690,11 +23787,11 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
 }
 function readExistingSessionStartRecord(agentType, historySessionId) {
   try {
-    const dir = path14.join(HISTORY_DIR, agentType);
+    const dir = path15.join(HISTORY_DIR, agentType);
     if (!fs6.existsSync(dir)) return null;
     const files = listHistoryFiles(dir, historySessionId).sort();
     for (const file of files) {
-      const lines = fs6.readFileSync(path14.join(dir, file), "utf-8").split("\n").filter(Boolean);
+      const lines = fs6.readFileSync(path15.join(dir, file), "utf-8").split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
@@ -23714,16 +23811,16 @@ function readExistingSessionStartRecord(agentType, historySessionId) {
 function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
   if (records.length === 0) return false;
   try {
-    const dir = path14.join(HISTORY_DIR, agentType);
+    const dir = path15.join(HISTORY_DIR, agentType);
     fs6.mkdirSync(dir, { recursive: true });
     const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
     for (const file of fs6.readdirSync(dir)) {
       if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
-        fs6.unlinkSync(path14.join(dir, file));
+        fs6.unlinkSync(path15.join(dir, file));
       }
     }
     const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
-    const filePath = path14.join(dir, `${prefix}${targetDate}.jsonl`);
+    const filePath = path15.join(dir, `${prefix}${targetDate}.jsonl`);
     fs6.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
 `, "utf-8");
     invalidatePersistedSavedHistoryIndex(agentType, dir);
@@ -26328,7 +26425,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 // src/commands/chat-commands.ts
 var fs7 = __toESM(require("fs"));
 var os9 = __toESM(require("os"));
-var path15 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var import_node_crypto3 = require("crypto");
 init_contracts();
 init_logger();
@@ -27379,7 +27476,7 @@ function readExactRuntimeMirrorMessages(args) {
 function normalizeComparableWorkspace(value) {
   const text = typeof value === "string" ? value.trim() : "";
   if (!text) return "";
-  return path15.resolve(text);
+  return path16.resolve(text);
 }
 function isCurrentRuntimePtySafelyAttributed(args) {
   if (args.adapter.cliType !== "codex-cli") return false;
@@ -27864,7 +27961,7 @@ function buildDebugBundleText(bundle) {
 }
 function getChatDebugBundleDir() {
   const override = typeof process.env.ADHDEV_DEBUG_BUNDLE_DIR === "string" ? process.env.ADHDEV_DEBUG_BUNDLE_DIR.trim() : "";
-  return override || path15.join(os9.homedir(), ".adhdev", "debug-bundles", "chat");
+  return override || path16.join(os9.homedir(), ".adhdev", "debug-bundles", "chat");
 }
 function safeBundleIdSegment(value, fallback) {
   const normalized = String(value || fallback).trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
@@ -27921,7 +28018,7 @@ function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
   const bundleId = createChatDebugBundleId(targetSessionId);
   const dir = getChatDebugBundleDir();
   fs7.mkdirSync(dir, { recursive: true });
-  const savedPath = path15.join(dir, `${bundleId}.json`);
+  const savedPath = path16.join(dir, `${bundleId}.json`);
   const json = `${JSON.stringify(bundle, null, 2)}
 `;
   fs7.writeFileSync(savedPath, json, { encoding: "utf8", mode: 384 });
@@ -29485,7 +29582,7 @@ async function handleResolveAction(h, args) {
 
 // src/commands/cdp-commands.ts
 var fs8 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var os10 = __toESM(require("os"));
 var KEY_TO_VK = {
   Backspace: 8,
@@ -29742,25 +29839,25 @@ function resolveSafePath(requestedPath) {
   const inputPath = rawPath || ".";
   const home = os10.homedir();
   if (inputPath.startsWith("~")) {
-    return path16.resolve(path16.join(home, inputPath.slice(1)));
+    return path17.resolve(path17.join(home, inputPath.slice(1)));
   }
   if (process.platform === "win32") {
     const normalized = normalizeWindowsRequestedPath(inputPath);
-    if (path16.win32.isAbsolute(normalized)) {
-      return path16.win32.normalize(normalized);
+    if (path17.win32.isAbsolute(normalized)) {
+      return path17.win32.normalize(normalized);
     }
-    return path16.win32.resolve(normalized);
+    return path17.win32.resolve(normalized);
   }
-  if (path16.isAbsolute(inputPath)) {
-    return path16.normalize(inputPath);
+  if (path17.isAbsolute(inputPath)) {
+    return path17.normalize(inputPath);
   }
-  return path16.resolve(inputPath);
+  return path17.resolve(inputPath);
 }
 function listDirectoryEntriesSafe(dirPath) {
   const entries = fs8.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path16.join(dirPath, entry.name);
+    const entryPath = path17.join(dirPath, entry.name);
     try {
       if (entry.isDirectory()) {
         files.push({ name: entry.name, type: "directory" });
@@ -29814,7 +29911,7 @@ async function handleFileRead(h, args) {
 async function handleFileWrite(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    fs8.mkdirSync(path16.dirname(filePath), { recursive: true });
+    fs8.mkdirSync(path17.dirname(filePath), { recursive: true });
     fs8.writeFileSync(filePath, args?.content || "", "utf-8");
     return { success: true, path: filePath };
   } catch (e) {
@@ -32598,6 +32695,7 @@ var fs13 = __toESM(require("fs"));
 var os17 = __toESM(require("os"));
 var path22 = __toESM(require("path"));
 init_logger();
+init_load_better_sqlite3();
 var UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
 function executeNativeHistory(cfg, input) {
   if (!cfg?.source) return null;
@@ -32722,7 +32820,7 @@ function executeSqlite(src, input) {
   if (!resolved || !fs13.existsSync(resolved)) return null;
   let Database;
   try {
-    Database = require("better-sqlite3");
+    Database = loadBetterSqlite3();
   } catch {
     return null;
   }
@@ -39546,6 +39644,7 @@ function readSession3(sessionPath, sessionId, workspace) {
 var fs20 = __toESM(require("fs"));
 var path30 = __toESM(require("path"));
 var os21 = __toESM(require("os"));
+init_load_better_sqlite3();
 var HERMES_STATE_DB = path30.join(os21.homedir(), ".hermes", "state.db");
 var HERMES_LEGACY_SESSIONS_DIR = path30.join(os21.homedir(), ".hermes", "sessions");
 function statMtimeMs4(p) {
@@ -39558,7 +39657,7 @@ function statMtimeMs4(p) {
 function openDb() {
   if (!fs20.existsSync(HERMES_STATE_DB)) return null;
   try {
-    const Database = require("better-sqlite3");
+    const Database = loadBetterSqlite3();
     return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
   } catch {
     return null;
@@ -40933,8 +41032,8 @@ var ProviderLoader = class _ProviderLoader {
       return null;
     }
     registerProviderScriptRootSafely(path33.dirname(path33.dirname(providerDir)));
-    const cached2 = this.scriptsCache.get(dir);
-    if (cached2) return cached2;
+    const cached3 = this.scriptsCache.get(dir);
+    if (cached3) return cached3;
     const scriptsJs = path33.join(dir, "scripts.js");
     if (fs22.existsSync(scriptsJs)) {
       try {
@@ -43620,6 +43719,7 @@ var import_os3 = require("os");
 var import_path12 = require("path");
 var fs26 = __toESM(require("fs"));
 var import_node_child_process6 = require("child_process");
+init_resolve_executable();
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
   stable: "https://api.adhf.dev",
@@ -44013,13 +44113,13 @@ function sanitizeInlineMesh(inlineMesh) {
     nodes
   };
 }
-function reconcileInlineMeshCache(cached2, incoming) {
-  if (!cached2 || typeof cached2 !== "object" || Array.isArray(cached2)) return incoming;
-  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached2;
-  const cachedNodes = Array.isArray(cached2.nodes) ? cached2.nodes : [];
+function reconcileInlineMeshCache(cached3, incoming) {
+  if (!cached3 || typeof cached3 !== "object" || Array.isArray(cached3)) return incoming;
+  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached3;
+  const cachedNodes = Array.isArray(cached3.nodes) ? cached3.nodes : [];
   const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
-  if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...incoming };
-  const cachedUpdatedAt = Date.parse(readStringValue(cached2.updatedAt, cached2.updated_at) || "");
+  if (!cachedNodes.length || !incomingNodes.length) return { ...cached3, ...incoming };
+  const cachedUpdatedAt = Date.parse(readStringValue(cached3.updatedAt, cached3.updated_at) || "");
   const incomingUpdatedAt = Date.parse(readStringValue(incoming.updatedAt, incoming.updated_at) || "");
   const preserveCachedMembership = Number.isFinite(cachedUpdatedAt) && (!Number.isFinite(incomingUpdatedAt) || cachedUpdatedAt > incomingUpdatedAt);
   const cachedById = /* @__PURE__ */ new Map();
@@ -44048,7 +44148,7 @@ function reconcileInlineMeshCache(cached2, incoming) {
     }
   }
   return {
-    ...cached2,
+    ...cached3,
     ...incoming,
     nodes
   };
@@ -44381,9 +44481,9 @@ var MeshGitProbeCache = class {
    */
   async probe(daemonId, workspace, probe) {
     const key = this.key(daemonId, workspace);
-    const cached2 = this.recent.get(key);
-    if (cached2 && this.now() - cached2.at < this.reuseMs) {
-      return cached2.value;
+    const cached3 = this.recent.get(key);
+    if (cached3 && this.now() - cached3.at < this.reuseMs) {
+      return cached3.value;
     }
     const existing = this.inflight.get(key);
     if (existing) return existing;
@@ -44718,6 +44818,18 @@ function truncateValidationOutput(value) {
   return `${text.slice(0, REFINE_VALIDATION_SUMMARY_CHARS)}
 [truncated ${text.length - REFINE_VALIDATION_SUMMARY_CHARS} chars]`;
 }
+function isSpawnResolutionError(error) {
+  if (!error) return false;
+  if (error.code === "ENOENT" && typeof error.syscall === "string" && error.syscall.startsWith("spawn")) return true;
+  return error.code === "ENOENT" && (error.syscall === void 0 || String(error.syscall).startsWith("spawn"));
+}
+function describeSpawnError(error, command, spawnResolutionFailed) {
+  if (spawnResolutionFailed) {
+    const hint = process.platform === "win32" ? " On Windows, npm-family commands (npm/npx/tsc/vitest) are .cmd shims that the bare-command spawn search does not resolve; configure an absolute path or ensure the command is on PATH." : "";
+    return `Could not resolve executable "${command}" (spawn ENOENT).${hint}`;
+  }
+  return String(error?.message || error);
+}
 function recordMeshRefineStage(stages, stage, status, startedAt, details) {
   stages.push({
     stage,
@@ -45619,8 +45731,9 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       const startedAt = Date.now();
       const cwd = candidate.cwd ? (0, import_path12.resolve)(workspace, candidate.cwd) : workspace;
       const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
+      const resolvedCommand = resolveWin32Executable(candidate.command);
       try {
-        const result = await execFileAsync4(candidate.command, candidate.args, {
+        const result = await execFileAsync4(resolvedCommand, candidate.args, {
           cwd,
           encoding: "utf8",
           timeout,
@@ -45629,16 +45742,17 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
         });
         summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
       } catch (error) {
+        const spawnResolutionFailed = isSpawnResolutionError(error);
         summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, error, false, {
           exitCode: typeof error?.code === "number" ? error.code : null,
           signal: typeof error?.signal === "string" ? error.signal : null,
           timedOut: error?.killed === true || /timed out/i.test(String(error?.message || "")),
-          failureKind: "dependency_bootstrap_failed"
+          ...spawnResolutionFailed ? { failureKind: "spawn_resolution_failed", resolvedCommand } : { failureKind: "dependency_bootstrap_failed" }
         }));
-        summary.bootstrap = { stage: "failed", error: String(error?.message || error) };
+        summary.bootstrap = { stage: "failed", error: describeSpawnError(error, candidate.command, spawnResolutionFailed) };
         summary.status = "failed";
-        summary.failureKind = "dependency_bootstrap_failed";
-        summary.failureCode = "dependency_bootstrap_failed";
+        summary.failureKind = spawnResolutionFailed ? "spawn_resolution_failed" : "dependency_bootstrap_failed";
+        summary.failureCode = spawnResolutionFailed ? "spawn_resolution_failed" : "dependency_bootstrap_failed";
         return summary;
       }
     }
@@ -45661,8 +45775,9 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       summary.failureCode = "missing_dependencies";
       return summary;
     }
+    const resolvedCommand = resolveWin32Executable(candidate.command);
     try {
-      const result = await execFileAsync4(candidate.command, candidate.args, {
+      const result = await execFileAsync4(resolvedCommand, candidate.args, {
         cwd,
         encoding: "utf8",
         timeout,
@@ -45671,16 +45786,21 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       });
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
     } catch (error) {
+      const spawnResolutionFailed = isSpawnResolutionError(error);
       const stderr = truncateValidationOutput(error?.stderr || error?.message);
-      const missingDependencyFailure = /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
+      const missingDependencyFailure = !spawnResolutionFailed && /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, error, false, {
         exitCode: typeof error?.code === "number" ? error.code : null,
         signal: typeof error?.signal === "string" ? error.signal : null,
         timedOut: error?.killed === true || /timed out/i.test(String(error?.message || "")),
-        ...missingDependencyFailure ? { failureKind: "missing_dependencies" } : {}
+        ...spawnResolutionFailed ? { failureKind: "spawn_resolution_failed", resolvedCommand } : missingDependencyFailure ? { failureKind: "missing_dependencies" } : {}
       }));
       summary.status = "failed";
-      if (missingDependencyFailure) {
+      if (spawnResolutionFailed) {
+        summary.failureKind = "spawn_resolution_failed";
+        summary.failureCode = "spawn_resolution_failed";
+        summary.spawnResolutionError = describeSpawnError(error, candidate.command, true);
+      } else if (missingDependencyFailure) {
         summary.failureKind = "missing_dependencies";
         summary.failureCode = "missing_dependencies";
       }
@@ -46031,13 +46151,13 @@ var DaemonCommandRouter = class {
     };
   }
   getCachedAggregateMeshStatus(meshId, mesh, options) {
-    const cached2 = this.aggregateMeshStatusCache.get(meshId);
-    if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
-    if (cached2.queueRevision !== getMeshQueueRevision(meshId)) return null;
-    let snapshot = this.cloneJsonValue(cached2.snapshot);
+    const cached3 = this.aggregateMeshStatusCache.get(meshId);
+    if (!cached3?.snapshot || cached3.snapshot.success !== true || !Array.isArray(cached3.snapshot.nodes)) return null;
+    if (cached3.queueRevision !== getMeshQueueRevision(meshId)) return null;
+    let snapshot = this.cloneJsonValue(cached3.snapshot);
     snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
     if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
-    const ageMs = Math.max(0, Date.now() - cached2.builtAt);
+    const ageMs = Math.max(0, Date.now() - cached3.builtAt);
     const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
     snapshot.sourceOfTruth = {
       ...sourceOfTruth,
@@ -46048,7 +46168,7 @@ var DaemonCommandRouter = class {
         source: "memory",
         refreshReason: "memory_cache_hit",
         ageMs,
-        cachedAt: new Date(cached2.builtAt).toISOString(),
+        cachedAt: new Date(cached3.builtAt).toISOString(),
         returnedAt: (/* @__PURE__ */ new Date()).toISOString()
       }
     };
@@ -46095,9 +46215,9 @@ var DaemonCommandRouter = class {
       meshId,
       sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh))
     );
-    const cached2 = this.inlineMeshCache.get(meshId);
-    if (cached2) {
-      const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
+    const cached3 = this.inlineMeshCache.get(meshId);
+    if (cached3) {
+      const merged = reconcileInlineMeshCache(cached3, sanitizedInlineMesh);
       this.inlineMeshCache.set(meshId, merged);
       return merged;
     }
@@ -46107,17 +46227,17 @@ var DaemonCommandRouter = class {
   async getMeshForCommand(meshId, inlineMesh, options) {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
-      const cached3 = this.getCachedInlineMesh(meshId);
-      if (cached3) {
+      const cached4 = this.getCachedInlineMesh(meshId);
+      if (cached4) {
         if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
           const merged = reconcileInlineMeshCache(
-            cached3,
+            cached4,
             this.applyInlineMeshNodeTombstones(meshId, inlineMesh)
           );
           this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
           return { mesh: merged, inline: true, source: "inline_cache" };
         }
-        return { mesh: cached3, inline: true, source: "inline_cache" };
+        return { mesh: cached4, inline: true, source: "inline_cache" };
       }
       if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
         this.warmInlineMeshCache(meshId, inlineMesh);
@@ -46130,8 +46250,8 @@ var DaemonCommandRouter = class {
       if (mesh) return { mesh, inline: false, source: "local_config" };
     } catch {
     }
-    const cached2 = this.getCachedInlineMesh(meshId);
-    if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
+    const cached3 = this.getCachedInlineMesh(meshId);
+    if (cached3) return { mesh: cached3, inline: true, source: "inline_cache" };
     const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
     return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
   }
@@ -46941,7 +47061,7 @@ var DaemonCommandRouter = class {
       if (validationSummary.status === "failed") {
         const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.success === false) : void 0;
         const buildValidationFailedError = () => {
-          const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
+          const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : validationSummary.failureCode === "spawn_resolution_failed" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
           if (!firstFailedCmd) return base;
           const cmdName = typeof firstFailedCmd.displayCommand === "string" ? firstFailedCmd.displayCommand : typeof firstFailedCmd.command === "string" ? [firstFailedCmd.command, ...Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : []].join(" ").trim() : typeof firstFailedCmd.cmd === "string" ? firstFailedCmd.cmd : "";
           const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s) => typeof s === "string" && s.length > 0).join("\n");
@@ -47561,8 +47681,8 @@ ${hintLines.join("\n")}` : "",
     const repoRootBaseRef = /* @__PURE__ */ new Map();
     const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
     const resolveBaseRef = async (repoRoot) => {
-      const cached2 = repoRootBaseRef.get(repoRoot);
-      if (cached2) return cached2;
+      const cached3 = repoRootBaseRef.get(repoRoot);
+      if (cached3) return cached3;
       let baseBranch = "main";
       try {
         const { stdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });