adhdev 0.9.28 → 0.9.29

package/dist/index.js

@@ -70,6 +70,29 @@ function asOptionalString(value) {
 function asBoolean(value, fallback2) {
   return typeof value === "boolean" ? value : fallback2;
 }
+function normalizeMachineProviders(value) {
+  if (!isPlainObject(value)) return {};
+  const result = {};
+  for (const [providerType, raw] of Object.entries(value)) {
+    if (!isPlainObject(raw)) continue;
+    const entry = {};
+    if (raw.enabled === true) entry.enabled = true;
+    if (typeof raw.executable === "string" && raw.executable.trim()) {
+      entry.executable = raw.executable.trim();
+    }
+    if (Array.isArray(raw.args)) {
+      entry.args = raw.args.filter((arg) => typeof arg === "string");
+    }
+    if (isPlainObject(raw.lastDetection)) {
+      entry.lastDetection = raw.lastDetection;
+    }
+    if (isPlainObject(raw.lastVerification)) {
+      entry.lastVerification = raw.lastVerification;
+    }
+    result[providerType] = entry;
+  }
+  return result;
+}
 function normalizeConfig(raw) {
   const parsed = isPlainObject(raw) ? raw : {};
   return {
@@ -90,6 +113,7 @@ function normalizeConfig(raw) {
     machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
     registeredMachineId: asOptionalString(parsed.registeredMachineId),
     providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
+    machineProviders: normalizeMachineProviders(parsed.machineProviders),
     ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
     providerSourceMode: resolveProviderSourceMode(parsed.providerSourceMode, parsed.disableUpstream),
     providerDir: asOptionalString(parsed.providerDir),
@@ -239,6 +263,7 @@ var init_config = __esm({
       machineSecret: null,
       registeredMachineId: void 0,
       providerSettings: {},
+      machineProviders: {},
       ideSettings: {},
       providerSourceMode: "normal",
       terminalSizingMode: "measured"
@@ -32114,6 +32139,27 @@ var init_hosted_runtime_restore = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/commands/cli-manager.ts
+function isExplicitCommand(command) {
+  const trimmed = command.trim();
+  return path12.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+}
+function expandExecutable(command) {
+  const trimmed = command.trim();
+  return trimmed.startsWith("~") ? path12.join(os14.homedir(), trimmed.slice(1)) : trimmed;
+}
+function commandExists(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+  if (isExplicitCommand(trimmed)) {
+    return (0, import_fs5.existsSync)(expandExecutable(trimmed));
+  }
+  try {
+    (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function colorize(color, text) {
   const fn = chalkApi?.[color];
   return typeof fn === "function" ? fn(text) : text;
@@ -32233,13 +32279,15 @@ function resolveCliSessionBinding(provider, normalizedType, cliArgs, requestedRe
     launchMode: "new"
   };
 }
-var os14, path12, crypto4, chalkModule, chalkApi, DaemonCliManager;
+var os14, path12, crypto4, import_fs5, import_child_process6, chalkModule, chalkApi, DaemonCliManager;
 var init_cli_manager = __esm({
   "../../oss/packages/daemon-core/src/commands/cli-manager.ts"() {
     "use strict";
     os14 = __toESM(require("os"));
     path12 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
+    import_fs5 = require("fs");
+    import_child_process6 = require("child_process");
     init_source();
     init_provider_cli_adapter();
     init_cli_detector();
@@ -32401,29 +32449,33 @@ var init_cli_manager = __esm({
         if (!trimmed) throw new Error("working directory required");
         const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os14.homedir()) : path12.resolve(trimmed);
         const normalizedType = this.providerLoader.resolveAlias(cliType);
-        const provider = this.providerLoader.getByAlias(cliType);
+        const rawProvider = this.providerLoader.getByAlias(cliType);
+        const provider = rawProvider ? this.providerLoader.resolve(normalizedType) || rawProvider : void 0;
+        if (provider && (provider.category === "cli" || provider.category === "acp") && !this.providerLoader.isMachineProviderEnabled(normalizedType)) {
+          const displayName = provider.displayName || provider.name || normalizedType;
+          throw new Error(
+            `${displayName} is disabled on this machine.
+Enable and detect this provider from the Machine Providers page before starting a runtime.`
+          );
+        }
         const key = crypto4.randomUUID();
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         if (provider && provider.category === "acp") {
           const instanceManager2 = this.deps.getInstanceManager();
           if (!instanceManager2) throw new Error("InstanceManager not available");
-          const spawnCmd = provider.spawn?.command;
-          if (spawnCmd) {
-            try {
-              const { execSync: execSync7 } = require("child_process");
-              execSync7(`which ${spawnCmd}`, { stdio: "ignore" });
-            } catch {
-              const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
-              throw new Error(
-                `${provider.displayName || provider.name} is not installed.
-Command '${spawnCmd}' not found in PATH.
+          const resolvedProvider = this.providerLoader.resolve(normalizedType) || provider;
+          const spawnCmd = resolvedProvider.spawn?.command;
+          if (spawnCmd && !commandExists(spawnCmd)) {
+            const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
+            throw new Error(
+              `${provider.displayName || provider.name} is not installed.
+Command '${spawnCmd}' not found.
 
 ${installInfo}`
-              );
-            }
+            );
           }
           console.log(colorize("cyan", `  \u{1F50C} Starting ACP agent: ${provider.name} (${provider.type}) in ${resolvedDir}`));
-          const acpInstance = new AcpProviderInstance(provider, resolvedDir, cliArgs);
+          const acpInstance = new AcpProviderInstance(resolvedProvider, resolvedDir, cliArgs);
           await instanceManager2.addInstance(key, acpInstance, {
             settings: this.providerLoader.getSettings(normalizedType)
           });
@@ -35120,15 +35172,18 @@ var init_provider_loader = __esm({
       getCliDetectionList() {
         const result = [];
         for (const p of this.providers.values()) {
-          if ((p.category === "cli" || p.category === "acp") && p.spawn?.command) {
+          if ((p.category === "cli" || p.category === "acp") && p.spawn?.command && this.isMachineProviderEnabled(p.type)) {
             const versionCommand = this.getPlatformVersionCommand(p.versionCommand);
             const command = this.getSpawnCommand(p.type, p.spawn.command);
+            const args = this.getSpawnArgs(p.type, p.spawn.args || []);
             result.push({
               id: p.type,
               displayName: p.displayName || p.name,
               icon: p.icon || "\u{1F527}",
               command,
+              ...args.length > 0 ? { args } : {},
               category: p.category,
+              enabled: true,
               ...typeof versionCommand === "string" && versionCommand.trim() ? { versionCommand: versionCommand.trim() } : {}
             });
           }
@@ -35257,9 +35312,10 @@ var init_provider_loader = __esm({
         return [...this.providers.values()].filter((p) => p.category === "ide" && p.cdpPorts).map((p) => p.type);
       }
       getSpawnCommand(type, fallback2) {
-        const override = this.getOptionalStringSetting(type, "executablePath");
-        if (override) return override;
-        return fallback2 || this.providers.get(type)?.spawn?.command || type;
+        const providerType = this.resolveAlias(type);
+        const machineConfig = this.getMachineProviderConfig(providerType);
+        if (machineConfig.executable) return machineConfig.executable;
+        return fallback2 || this.providers.get(providerType)?.spawn?.command || providerType;
       }
       getIdeCliCommand(type, fallback2) {
         const override = this.getOptionalStringSetting(type, "cliPathOverride");
@@ -35273,6 +35329,131 @@ var init_provider_loader = __esm({
         const osPaths = this.providers.get(type)?.paths?.[process.platform];
         return Array.isArray(osPaths) ? [...osPaths] : [];
       }
+      isMachineProviderEnabled(type) {
+        const providerType = this.resolveAlias(type);
+        const config2 = this.readConfig();
+        return config2?.machineProviders?.[providerType]?.enabled === true;
+      }
+      getMachineProviderConfig(type) {
+        const providerType = this.resolveAlias(type);
+        const raw = this.readConfig()?.machineProviders?.[providerType];
+        if (!raw || typeof raw !== "object") return {};
+        const executable = typeof raw.executable === "string" && raw.executable.trim() ? raw.executable.trim() : void 0;
+        return {
+          ...raw.enabled === true ? { enabled: true } : {},
+          ...executable ? { executable } : {},
+          ...Array.isArray(raw.args) ? { args: raw.args.filter((arg) => typeof arg === "string") } : {},
+          ...raw.lastDetection && typeof raw.lastDetection === "object" ? { lastDetection: raw.lastDetection } : {},
+          ...raw.lastVerification && typeof raw.lastVerification === "object" ? { lastVerification: raw.lastVerification } : {}
+        };
+      }
+      setMachineProviderConfig(type, patch) {
+        const providerType = this.resolveAlias(type);
+        if (!this.providers.has(providerType)) return false;
+        const config2 = this.readConfig();
+        if (!config2) return false;
+        try {
+          if (!config2.machineProviders) config2.machineProviders = {};
+          const current = config2.machineProviders[providerType] || {};
+          const next = { ...current };
+          const enabledChanged = "enabled" in patch && current.enabled !== (patch.enabled === true);
+          const executableChanged = "executable" in patch;
+          const argsChanged = "args" in patch;
+          if ("enabled" in patch) next.enabled = patch.enabled === true;
+          if ("executable" in patch) {
+            const executable = typeof patch.executable === "string" ? patch.executable.trim() : "";
+            if (executable) next.executable = executable;
+            else delete next.executable;
+          }
+          if ("args" in patch) {
+            if (Array.isArray(patch.args)) next.args = patch.args.filter((arg) => typeof arg === "string");
+            else delete next.args;
+          }
+          if (enabledChanged || executableChanged || argsChanged) {
+            delete next.lastDetection;
+            delete next.lastVerification;
+          }
+          if ("lastDetection" in patch) {
+            if (patch.lastDetection) next.lastDetection = patch.lastDetection;
+            else delete next.lastDetection;
+          }
+          if ("lastVerification" in patch) {
+            if (patch.lastVerification) next.lastVerification = patch.lastVerification;
+            else delete next.lastVerification;
+          }
+          config2.machineProviders[providerType] = next;
+          if (next.enabled !== true) {
+            this.providerAvailability.set(providerType, { installed: false, detectedPath: null });
+          }
+          this.writeConfig(config2);
+          this.log(`Machine provider config updated: ${providerType}`);
+          return true;
+        } catch (e) {
+          this.log(`Failed to save machine provider config: ${e.message}`);
+          return false;
+        }
+      }
+      setMachineProviderEnabled(type, enabled) {
+        return this.setMachineProviderConfig(type, { enabled });
+      }
+      getMachineProviderStatus(type) {
+        const providerType = this.resolveAlias(type);
+        if (!this.isMachineProviderEnabled(providerType)) return "disabled";
+        const availability = this.providerAvailability.get(providerType);
+        if (!availability) return "enabled_unchecked";
+        return availability.installed ? "detected" : "not_detected";
+      }
+      getSpawnArgs(type, fallback2 = []) {
+        const machineConfig = this.getMachineProviderConfig(type);
+        if (machineConfig.args) return [...machineConfig.args];
+        return [...fallback2];
+      }
+      parseArgsSetting(value) {
+        const args = [];
+        let current = "";
+        let quote = null;
+        let escaping = false;
+        for (const ch of value.trim()) {
+          if (escaping) {
+            current += ch;
+            escaping = false;
+            continue;
+          }
+          if (ch === "\\") {
+            escaping = true;
+            continue;
+          }
+          if (quote === "single") {
+            if (ch === "'") quote = null;
+            else current += ch;
+            continue;
+          }
+          if (quote === "double") {
+            if (ch === '"') quote = null;
+            else current += ch;
+            continue;
+          }
+          if (ch === "'") {
+            quote = "single";
+            continue;
+          }
+          if (ch === '"') {
+            quote = "double";
+            continue;
+          }
+          if (/\s/.test(ch)) {
+            if (current) {
+              args.push(current);
+              current = "";
+            }
+            continue;
+          }
+          current += ch;
+        }
+        if (escaping) current += "\\";
+        if (current) args.push(current);
+        return args;
+      }
       setProviderAvailability(type, state) {
         this.providerAvailability.set(type, {
           installed: !!state.installed,
@@ -35280,18 +35461,53 @@ var init_provider_loader = __esm({
         });
       }
       setCliDetectionResults(results, replace = true) {
+        const resultByType = /* @__PURE__ */ new Map();
+        for (const result of results) {
+          resultByType.set(this.resolveAlias(result.id), result);
+        }
         if (replace) {
           for (const provider of this.providers.values()) {
             if (provider.category === "cli" || provider.category === "acp") {
-              this.providerAvailability.set(provider.type, { installed: false, detectedPath: null });
+              const result = resultByType.get(provider.type);
+              const installed = !!result?.installed;
+              const detectedPath = result?.path || null;
+              this.providerAvailability.set(provider.type, { installed, detectedPath });
+              if (this.isMachineProviderEnabled(provider.type)) {
+                this.setMachineProviderConfig(provider.type, {
+                  lastDetection: {
+                    ok: installed,
+                    stage: "detection",
+                    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                    command: this.getSpawnCommand(provider.type, provider.spawn?.command),
+                    path: detectedPath,
+                    message: installed ? "Provider command detected" : "Provider command was not detected"
+                  }
+                });
+              }
             }
           }
+          return;
         }
         for (const result of results) {
-          this.setProviderAvailability(result.id, {
+          const providerType = this.resolveAlias(result.id);
+          const provider = this.providers.get(providerType);
+          const detectedPath = result.path || null;
+          this.setProviderAvailability(providerType, {
             installed: !!result.installed,
-            detectedPath: result.path || null
+            detectedPath
           });
+          if (provider && (provider.category === "cli" || provider.category === "acp") && this.isMachineProviderEnabled(providerType)) {
+            this.setMachineProviderConfig(providerType, {
+              lastDetection: {
+                ok: !!result.installed,
+                stage: "detection",
+                checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                command: this.getSpawnCommand(providerType, provider.spawn?.command),
+                path: detectedPath,
+                message: result.installed ? "Provider command detected" : "Provider command was not detected"
+              }
+            });
+          }
         }
       }
       setIdeDetectionResults(results, replace = true) {
@@ -35312,8 +35528,14 @@ var init_provider_loader = __esm({
       getAvailableProviderInfos() {
         return this.getAll().map((provider) => {
           const availability = this.providerAvailability.get(provider.type);
+          const enabled = this.isMachineProviderEnabled(provider.type);
+          const machineConfig = this.getMachineProviderConfig(provider.type);
           return {
             ...provider,
+            enabled,
+            machineStatus: this.getMachineProviderStatus(provider.type),
+            ...machineConfig.lastDetection ? { lastDetection: machineConfig.lastDetection } : {},
+            ...machineConfig.lastVerification ? { lastVerification: machineConfig.lastVerification } : {},
             ...availability ? {
               installed: availability.installed,
               detectedPath: availability.detectedPath
@@ -35460,6 +35682,13 @@ var init_provider_loader = __esm({
             }
           }
         }
+        if ((resolved.category === "cli" || resolved.category === "acp") && resolved.spawn?.command) {
+          resolved.spawn = {
+            ...resolved.spawn,
+            command: this.getSpawnCommand(type, resolved.spawn.command),
+            args: this.getSpawnArgs(type, resolved.spawn.args || [])
+          };
+        }
         return resolved;
       }
       /**
@@ -35782,20 +36011,33 @@ var init_provider_loader = __esm({
       * Resolved setting value for a provider (default + user override)
       */
       getSettingValue(type, key) {
-        const schemaDef = this.getSettingsSchema(type)[key];
+        const providerType = this.resolveAlias(type);
+        const machineConfig = this.getMachineProviderConfig(providerType);
+        if (key === "enabled") {
+          return machineConfig.enabled === true;
+        }
+        if (key === "executablePath") {
+          return machineConfig.executable || "";
+        }
+        if (key === "executableArgs") {
+          const args = machineConfig.args;
+          return args ? args.map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ") : "";
+        }
+        const schemaDef = this.getSettingsSchema(providerType)[key];
         const defaultVal = schemaDef ? key === "autoApprove" && schemaDef.type === "boolean" ? true : schemaDef.default : void 0;
         const config2 = this.readConfig();
-        const userVal = config2?.providerSettings?.[type]?.[key];
+        const userVal = config2?.providerSettings?.[providerType]?.[key];
         return userVal !== void 0 ? userVal : defaultVal;
       }
       /**
       * All resolved settings for a provider (default + user override)
       */
       getSettings(type) {
-        const settings = this.getSettingsSchema(type);
+        const providerType = this.resolveAlias(type);
+        const settings = this.getSettingsSchema(providerType);
         const result = {};
         for (const [key] of Object.entries(settings)) {
-          result[key] = this.getSettingValue(type, key);
+          result[key] = this.getSettingValue(providerType, key);
         }
         return result;
       }
@@ -35803,7 +36045,8 @@ var init_provider_loader = __esm({
       * Save provider setting value (writes to config.json)
       */
       setSetting(type, key, value) {
-        const schemaDef = this.getSettingsSchema(type)[key];
+        const providerType = this.resolveAlias(type);
+        const schemaDef = this.getSettingsSchema(providerType)[key];
         if (!schemaDef) return false;
         if (!schemaDef.public) return false;
         if (schemaDef.type === "boolean" && typeof value !== "boolean") return false;
@@ -35814,14 +36057,25 @@ var init_provider_loader = __esm({
           if (schemaDef.max !== void 0 && value > schemaDef.max) return false;
         }
         if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
+        if (key === "enabled") {
+          return this.setMachineProviderEnabled(providerType, value);
+        }
+        if (key === "executablePath") {
+          return this.setMachineProviderConfig(providerType, { executable: value });
+        }
+        if (key === "executableArgs") {
+          return this.setMachineProviderConfig(providerType, {
+            args: value.trim() ? this.parseArgsSetting(value) : void 0
+          });
+        }
         const config2 = this.readConfig();
         if (!config2) return false;
         try {
           if (!config2.providerSettings) config2.providerSettings = {};
-          if (!config2.providerSettings[type]) config2.providerSettings[type] = {};
-          config2.providerSettings[type][key] = value;
+          if (!config2.providerSettings[providerType]) config2.providerSettings[providerType] = {};
+          config2.providerSettings[providerType][key] = value;
           this.writeConfig(config2);
-          this.log(`Setting updated: ${type}.${key} = ${JSON.stringify(value)}`);
+          this.log(`Setting updated: ${providerType}.${key} = ${JSON.stringify(value)}`);
           return true;
         } catch (e) {
           this.log(`Failed to save setting: ${e.message}`);
@@ -35882,6 +36136,15 @@ var init_provider_loader = __esm({
       }
       getSyntheticSettings(type, provider) {
         const result = {};
+        if (provider.category === "cli" || provider.category === "acp") {
+          result.enabled = {
+            type: "boolean",
+            default: false,
+            public: true,
+            label: "Enabled on this machine",
+            description: "Opt in before ADHDev detects, launches, or verifies this provider on this machine."
+          };
+        }
         if (!provider.settings?.autoApprove) {
           result.autoApprove = {
             type: "boolean",
@@ -35900,6 +36163,15 @@ var init_provider_loader = __esm({
             description: "Optional absolute path for this provider binary. Leave blank to use the default PATH lookup."
           };
         }
+        if ((provider.category === "cli" || provider.category === "acp") && provider.spawn?.command && !provider.settings?.executableArgs) {
+          result.executableArgs = {
+            type: "string",
+            default: "",
+            public: true,
+            label: "Executable arguments",
+            description: "Optional replacement for provider default command arguments. Leave blank to use the provider default."
+          };
+        }
         if (provider.category === "ide") {
           if (provider.cli && !provider.settings?.cliPathOverride) {
             result.cliPathOverride = {
@@ -36219,32 +36491,32 @@ async function killIdeProcess(ideId) {
   try {
     if (plat === "darwin" && appName) {
       try {
-        (0, import_child_process6.execSync)(`osascript -e 'tell application "${escapeForAppleScript(appName)}" to quit' 2>/dev/null`, {
+        (0, import_child_process7.execSync)(`osascript -e 'tell application "${escapeForAppleScript(appName)}" to quit' 2>/dev/null`, {
           timeout: 5e3
         });
       } catch {
         try {
-          (0, import_child_process6.execSync)(`pkill -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
+          (0, import_child_process7.execSync)(`pkill -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
         } catch {
         }
       }
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
-          (0, import_child_process6.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
+          (0, import_child_process7.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
         } catch {
         }
       }
       try {
         const exeName = winProcesses[0].replace(".exe", "");
-        (0, import_child_process6.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
+        (0, import_child_process7.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
           timeout: 1e4
         });
       } catch {
       }
     } else {
       try {
-        (0, import_child_process6.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
+        (0, import_child_process7.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
       } catch {
       }
     }
@@ -36254,13 +36526,13 @@ async function killIdeProcess(ideId) {
     }
     if (plat === "darwin" && appName) {
       try {
-        (0, import_child_process6.execSync)(`pkill -9 -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
+        (0, import_child_process7.execSync)(`pkill -9 -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
       } catch {
       }
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
-          (0, import_child_process6.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
+          (0, import_child_process7.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
         } catch {
         }
       }
@@ -36278,13 +36550,13 @@ function isIdeRunning(ideId) {
       const appName = getMacAppIdentifiers()[ideId];
       if (!appName) return false;
       try {
-        const result = (0, import_child_process6.execSync)(`pgrep -x "${appName}" 2>/dev/null`, {
+        const result = (0, import_child_process7.execSync)(`pgrep -x "${appName}" 2>/dev/null`, {
           encoding: "utf-8",
           timeout: 3e3
         });
         return result.trim().length > 0;
       } catch {
-        const result = (0, import_child_process6.execSync)(
+        const result = (0, import_child_process7.execSync)(
           `osascript -e 'tell application "System Events" to count (every process whose name is "${escapeForAppleScript(appName)}")'`,
           {
             encoding: "utf-8",
@@ -36299,14 +36571,14 @@ function isIdeRunning(ideId) {
       if (!winProcesses) return false;
       for (const proc of winProcesses) {
         try {
-          const result = (0, import_child_process6.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
+          const result = (0, import_child_process7.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
           if (result.includes(proc)) return true;
         } catch {
         }
       }
       try {
         const exeName = winProcesses[0].replace(".exe", "");
-        const result = (0, import_child_process6.execSync)(
+        const result = (0, import_child_process7.execSync)(
           `powershell -Command "(Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue).Count"`,
           { encoding: "utf-8", timeout: 5e3 }
         );
@@ -36315,7 +36587,7 @@ function isIdeRunning(ideId) {
       }
       return false;
     } else {
-      const result = (0, import_child_process6.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
+      const result = (0, import_child_process7.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
       return result.trim().length > 0;
     }
   } catch {
@@ -36328,7 +36600,7 @@ function detectCurrentWorkspace(ideId) {
     try {
       const appName = getMacAppIdentifiers()[ideId];
       if (!appName) return void 0;
-      const result = (0, import_child_process6.execSync)(
+      const result = (0, import_child_process7.execSync)(
         `lsof -c "${appName}" 2>/dev/null | grep cwd | head -1 | awk '{print $NF}'`,
         { encoding: "utf-8", timeout: 3e3 }
       );
@@ -36480,10 +36752,10 @@ async function launchMacOS(ide, port, workspace, newWindow) {
   const canUseAppLauncher = !!appName;
   const useAppLauncher = preferredMethod === "app" ? canUseAppLauncher : preferredMethod === "cli" ? false : !canUseCli && canUseAppLauncher;
   if (!useAppLauncher && ide.cliCommand) {
-    (0, import_child_process6.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process7.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
   } else if (appName) {
     const openArgs = ["-a", appName, "--args", ...args];
-    (0, import_child_process6.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process7.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
   } else {
     throw new Error(`No app identifier or CLI for ${ide.displayName}`);
   }
@@ -36509,16 +36781,16 @@ async function launchLinux(ide, port, workspace, newWindow) {
   const args = ["--remote-debugging-port=" + port];
   if (newWindow) args.push("--new-window");
   if (workspace) args.push(workspace);
-  (0, import_child_process6.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
+  (0, import_child_process7.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
 }
 function getAvailableIdeIds() {
   return getProviderLoader().getAvailableIdeTypes();
 }
-var import_child_process6, net2, os16, path14, _providerLoader;
+var import_child_process7, net2, os16, path14, _providerLoader;
 var init_launch = __esm({
   "../../oss/packages/daemon-core/src/launch.ts"() {
     "use strict";
-    import_child_process6 = require("child_process");
+    import_child_process7 = require("child_process");
     net2 = __toESM(require("net"));
     os16 = __toESM(require("os"));
     path14 = __toESM(require("path"));
@@ -37090,7 +37362,7 @@ function getNpmExecOptions() {
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      (0, import_child_process7.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      (0, import_child_process8.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -37128,7 +37400,7 @@ function stopSessionHostProcesses(appName) {
   }
   if (process.platform !== "win32") {
     try {
-      const raw = (0, import_child_process7.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      const raw = (0, import_child_process8.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
       for (const line of raw.split("\n")) {
         const pid = Number.parseInt(line.trim(), 10);
         if (Number.isFinite(pid)) {
@@ -37149,9 +37421,9 @@ function removeDaemonPidFile() {
 function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   const npmExecOpts = getNpmExecOptions();
   const prefixArgs = surface.installPrefix ? ["--prefix", surface.installPrefix] : [];
-  const npmRoot = (0, import_child_process7.execFileSync)(surface.npmExecutable, ["root", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmRoot = (0, import_child_process8.execFileSync)(surface.npmExecutable, ["root", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
   if (!npmRoot) return;
-  const npmPrefix = surface.installPrefix || (0, import_child_process7.execFileSync)(surface.npmExecutable, ["prefix", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmPrefix = surface.installPrefix || (0, import_child_process8.execFileSync)(surface.npmExecutable, ["prefix", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
   const binDir = process.platform === "win32" ? npmPrefix : path16.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
@@ -37184,7 +37456,7 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
 }
 function spawnDetachedDaemonUpgradeHelper(payload) {
   const env3 = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
-  const child = (0, import_child_process8.spawn)(process.execPath, process.argv.slice(1), {
+  const child = (0, import_child_process9.spawn)(process.execPath, process.argv.slice(1), {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -37214,7 +37486,7 @@ async function runDaemonUpgradeHelper(payload) {
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = (0, import_child_process7.execFileSync)(
+  const installOutput = (0, import_child_process8.execFileSync)(
     installCommand.command,
     installCommand.args,
     {
@@ -37236,7 +37508,7 @@ async function runDaemonUpgradeHelper(payload) {
     const env3 = { ...process.env };
     delete env3[UPGRADE_HELPER_ENV];
     appendUpgradeLog(`Restarting daemon with args: ${restartArgv.join(" ")}`);
-    const child = (0, import_child_process8.spawn)(process.execPath, restartArgv, {
+    const child = (0, import_child_process9.spawn)(process.execPath, restartArgv, {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -37261,12 +37533,12 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
     process.exit(1);
   }
 }
-var import_child_process7, import_child_process8, fs8, os19, path16, UPGRADE_HELPER_ENV;
+var import_child_process8, import_child_process9, fs8, os19, path16, UPGRADE_HELPER_ENV;
 var init_upgrade_helper = __esm({
   "../../oss/packages/daemon-core/src/commands/upgrade-helper.ts"() {
     "use strict";
-    import_child_process7 = require("child_process");
     import_child_process8 = require("child_process");
+    import_child_process9 = require("child_process");
     fs8 = __toESM(require("fs"));
     os19 = __toESM(require("os"));
     path16 = __toESM(require("path"));
@@ -37371,6 +37643,7 @@ var init_router = __esm({
     init_saved_sessions();
     init_chat_history();
     init_ide_detector();
+    init_cli_detector();
     init_logger();
     init_command_log();
     init_logger();
@@ -37807,6 +38080,33 @@ var init_router = __esm({
             }
             return { ...result };
           }
+          // ─── Detect providers ───
+          case "detect_provider": {
+            const providerType = typeof args?.providerType === "string" ? args.providerType.trim() : "";
+            if (!providerType) return { success: false, error: "providerType is required" };
+            const normalizedType = this.deps.providerLoader.resolveAlias(providerType);
+            const provider = this.deps.providerLoader.getByAlias(providerType);
+            if (!provider) return { success: false, error: `Provider not found: ${providerType}` };
+            if (provider.category !== "cli" && provider.category !== "acp") {
+              return { success: false, error: `Provider detection is only supported for CLI/ACP providers: ${providerType}` };
+            }
+            if (!this.deps.providerLoader.isMachineProviderEnabled(normalizedType)) {
+              return { success: false, error: `Provider is disabled on this machine: ${providerType}` };
+            }
+            const detected = await detectCLI(normalizedType, this.deps.providerLoader, { includeVersion: false });
+            this.deps.providerLoader.setCliDetectionResults([{
+              id: normalizedType,
+              installed: !!detected,
+              path: detected?.path
+            }], false);
+            this.deps.onStatusChange?.();
+            return {
+              success: true,
+              providerType: normalizedType,
+              detected: !!detected,
+              path: detected?.path || null
+            };
+          }
           // ─── Detect IDEs ───
           case "detect_ides": {
             const results = await detectIDEs(this.deps.providerLoader);
@@ -37852,13 +38152,16 @@ var init_router = __esm({
               this.deps.cdpManagers
             );
             const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
-            const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : "";
+            const requestedCompletionMarker = typeof args?.completionMarker === "string" ? args.completionMarker.trim() : "";
+            const completionMarker = requestedCompletionMarker || (targetSession ? getSessionCompletionMarker(targetSession) : "");
+            const requestedProviderSessionId = typeof args?.providerSessionId === "string" ? args.providerSessionId.trim() : "";
+            const providerSessionId = requestedProviderSessionId || targetSession?.providerSessionId;
             const next = markSessionSeen(
               currentState,
               sessionId,
               typeof args?.seenAt === "number" ? args.seenAt : Date.now(),
               completionMarker,
-              targetSession?.providerSessionId
+              providerSessionId
             );
             if (READ_DEBUG_ENABLED2) {
               LOG.info("RecentRead", `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || "")} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || "-"}`);
@@ -39651,7 +39954,7 @@ var init_provider_instance_manager = __esm({
 // ../../oss/packages/daemon-core/src/providers/version-archive.ts
 function runCommand(cmd, timeout = 1e4) {
   try {
-    return (0, import_child_process9.execSync)(cmd, {
+    return (0, import_child_process10.execSync)(cmd, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -39773,14 +40076,14 @@ async function detectAllVersions(loader, archive) {
   }
   return results;
 }
-var fs10, path17, os20, import_child_process9, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
+var fs10, path17, os20, import_child_process10, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
 var init_version_archive = __esm({
   "../../oss/packages/daemon-core/src/providers/version-archive.ts"() {
     "use strict";
     fs10 = __toESM(require("fs"));
     path17 = __toESM(require("path"));
     os20 = __toESM(require("os"));
-    import_child_process9 = require("child_process");
+    import_child_process10 = require("child_process");
     import_os3 = require("os");
     ARCHIVE_PATH = path17.join(os20.homedir(), ".adhdev", "version-history.json");
     MAX_ENTRIES_PER_PROVIDER = 20;
@@ -45560,7 +45863,7 @@ var init_startup_restore_policy = __esm({
 function isExtensionInstalled(ide, marketplaceId) {
   if (!ide.cliCommand) return false;
   try {
-    const result = (0, import_child_process10.execSync)(`"${ide.cliCommand}" --list-extensions`, {
+    const result = (0, import_child_process11.execSync)(`"${ide.cliCommand}" --list-extensions`, {
       encoding: "utf-8",
       timeout: 15e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -45601,7 +45904,7 @@ async function installExtension(ide, extension) {
         fs24.writeFileSync(vsixPath, buffer);
         return new Promise((resolve16) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
-          (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
+          (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
             resolve16({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
@@ -45617,7 +45920,7 @@ async function installExtension(ide, extension) {
   }
   return new Promise((resolve16) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
+    (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
       if (error48) {
         resolve16({
           extensionId: extension.id,
@@ -45654,17 +45957,17 @@ function launchIDE(ide, workspacePath) {
   if (!ide.cliCommand) return false;
   try {
     const args = workspacePath ? `"${workspacePath}"` : "";
-    (0, import_child_process10.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+    (0, import_child_process11.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
     return true;
   } catch {
     return false;
   }
 }
-var import_child_process10, EXTENSION_CATALOG;
+var import_child_process11, EXTENSION_CATALOG;
 var init_installer = __esm({
   "../../oss/packages/daemon-core/src/installer.ts"() {
     "use strict";
-    import_child_process10 = require("child_process");
+    import_child_process11 = require("child_process");
     EXTENSION_CATALOG = [
       // AI Agent extensions
       {
@@ -45867,10 +46170,11 @@ async function initDaemonComponents(config2) {
     if (!providerType || targetCategory === "cli" || targetCategory === "acp") {
       if (providerType && targetProvider) {
         const detected = await detectCLI(targetProvider.type, providerLoader, { includeVersion: false });
-        providerLoader.setProviderAvailability(targetProvider.type, {
+        providerLoader.setCliDetectionResults([{
+          id: targetProvider.type,
           installed: !!detected,
-          detectedPath: detected?.path || null
-        });
+          path: detected?.path
+        }], false);
       } else {
         providerLoader.setCliDetectionResults(await detectCLIs(providerLoader, { includeVersion: false }), true);
       }
@@ -54689,7 +54993,7 @@ function getSessionHostPidFile() {
 function killPid2(pid) {
   try {
     if (process.platform === "win32") {
-      (0, import_child_process11.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      (0, import_child_process12.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -54701,7 +55005,7 @@ function killPid2(pid) {
 function getWindowsProcessCommandLine(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
-    const psOut = (0, import_child_process11.execFileSync)("powershell.exe", [
+    const psOut = (0, import_child_process12.execFileSync)("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-ExecutionPolicy",
@@ -54714,7 +55018,7 @@ function getWindowsProcessCommandLine(pid) {
   } catch {
   }
   try {
-    const wmicOut = (0, import_child_process11.execFileSync)("wmic", [
+    const wmicOut = (0, import_child_process12.execFileSync)("wmic", [
       "process",
       "where",
       pidFilter,
@@ -54750,7 +55054,7 @@ function stopSessionHost() {
   let stopped = stopManagedSessionHostProcess();
   if (process.platform === "win32") {
     try {
-      const raw = (0, import_child_process11.execFileSync)("tasklist", ["/FO", "CSV", "/NH", "/FI", "IMAGENAME eq node.exe"], {
+      const raw = (0, import_child_process12.execFileSync)("tasklist", ["/FO", "CSV", "/NH", "/FI", "IMAGENAME eq node.exe"], {
         encoding: "utf8",
         timeout: 5e3,
         stdio: ["ignore", "pipe", "ignore"],
@@ -54770,7 +55074,7 @@ function stopSessionHost() {
     }
   } else {
     try {
-      const raw = (0, import_child_process11.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      const raw = (0, import_child_process12.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
       for (const line of raw.split("\n")) {
         const pid = Number.parseInt(line.trim(), 10);
         if (Number.isFinite(pid) && pid !== process.pid && pid !== process.ppid) {
@@ -54804,7 +55108,7 @@ async function ensureSessionHostReady2() {
     const logDir = path25.join(os24.homedir(), ".adhdev", "logs");
     fs17.mkdirSync(logDir, { recursive: true });
     const logFd = fs17.openSync(path25.join(logDir, "session-host.log"), "a");
-    const child = (0, import_child_process11.spawn)(process.execPath, [entry], {
+    const child = (0, import_child_process12.spawn)(process.execPath, [entry], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       windowsHide: true,
@@ -54838,11 +55142,11 @@ async function ensureSessionHostReady2() {
 async function listHostedCliRuntimes2(endpoint) {
   return listHostedCliRuntimes(endpoint);
 }
-var import_child_process11, fs17, os24, path25, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
+var import_child_process12, fs17, os24, path25, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
 var init_session_host = __esm({
   "src/session-host.ts"() {
     "use strict";
-    import_child_process11 = require("child_process");
+    import_child_process12 = require("child_process");
     fs17 = __toESM(require("fs"));
     os24 = __toESM(require("os"));
     path25 = __toESM(require("path"));
@@ -55537,18 +55841,18 @@ function resolvePackageVersion(options) {
   ];
   for (const p of possiblePaths) {
     try {
-      const data = JSON.parse((0, import_fs5.readFileSync)(p, "utf-8"));
+      const data = JSON.parse((0, import_fs6.readFileSync)(p, "utf-8"));
       if (data.version) return data.version;
     } catch {
     }
   }
   return injectedVersion;
 }
-var import_fs5, import_path3;
+var import_fs6, import_path3;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    import_fs5 = require("fs");
+    import_fs6 = require("fs");
     import_path3 = require("path");
   }
 });
@@ -55587,7 +55891,7 @@ function removeDaemonPid(ref = {}) {
 function isDaemonRunning(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync4 } = require("child_process");
+    const { execFileSync: execFileSync5 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -55597,7 +55901,7 @@ function isDaemonRunning(ref = {}) {
             req.on('error', () => process.stdout.write('0'));
             req.on('timeout', () => { req.destroy(); process.stdout.write('0'); });
         `;
-    const result = execFileSync4(process.execPath, ["-e", probe], {
+    const result = execFileSync5(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -55623,9 +55927,9 @@ function isDaemonRunning(ref = {}) {
 function isAdhdevProcess(pid) {
   try {
     if (process.platform === "win32") {
-      const { execFileSync: execFileSync4 } = require("child_process");
+      const { execFileSync: execFileSync5 } = require("child_process");
       try {
-        const psOut = execFileSync4("powershell.exe", [
+        const psOut = execFileSync5("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -55638,8 +55942,8 @@ function isAdhdevProcess(pid) {
         return true;
       }
     } else {
-      const { execFileSync: execFileSync4 } = require("child_process");
-      const cmdline = execFileSync4("ps", ["-o", "command=", "-p", String(pid)], {
+      const { execFileSync: execFileSync5 } = require("child_process");
+      const cmdline = execFileSync5("ps", ["-o", "command=", "-p", String(pid)], {
         encoding: "utf-8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -55653,7 +55957,7 @@ function isAdhdevProcess(pid) {
 function getDaemonHealthPid(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync4 } = require("child_process");
+    const { execFileSync: execFileSync5 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -55671,7 +55975,7 @@ function getDaemonHealthPid(ref = {}) {
             req.on('error', () => {});
             req.on('timeout', () => { req.destroy(); });
         `;
-    const result = execFileSync4(process.execPath, ["-e", probe], {
+    const result = execFileSync5(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -55738,7 +56042,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.28" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.29" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -56537,12 +56841,13 @@ ${err?.stack || ""}`);
                 return { success: false, error: "CLI session runtime unavailable", code: "CLI_RUNTIME_UNAVAILABLE", interactionId };
               }
               if (!this.sessionHostEndpoint) return { success: false, error: "Session host unavailable", interactionId };
+              const sinceSeq = typeof normalizedData.sinceSeq === "number" ? normalizedData.sinceSeq : void 0;
               const client = new SessionHostClient({ endpoint: this.sessionHostEndpoint });
               try {
                 await client.connect();
                 const snapshot = await client.request({
                   type: "get_snapshot",
-                  payload: { sessionId }
+                  payload: { sessionId, sinceSeq }
                 });
                 if (!snapshot.success || !snapshot.result) {
                   return { success: false, error: snapshot.error || "Runtime snapshot unavailable", interactionId };
@@ -71473,7 +71778,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join29(s) {
+        value: function join30(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -85532,13 +85837,13 @@ function splitStringBySpace(str) {
   }
   return pieces;
 }
-var import_chardet, import_child_process12, import_fs6, import_node_path2, import_node_os4, import_node_crypto, import_iconv_lite, ExternalEditor;
+var import_chardet, import_child_process13, import_fs7, import_node_path2, import_node_os4, import_node_crypto, import_iconv_lite, ExternalEditor;
 var init_esm2 = __esm({
   "../../node_modules/@inquirer/external-editor/dist/esm/index.js"() {
     "use strict";
     import_chardet = __toESM(require_lib2(), 1);
-    import_child_process12 = require("child_process");
-    import_fs6 = require("fs");
+    import_child_process13 = require("child_process");
+    import_fs7 = require("fs");
     import_node_path2 = __toESM(require("path"), 1);
     import_node_os4 = __toESM(require("os"), 1);
     import_node_crypto = require("crypto");
@@ -85614,14 +85919,14 @@ var init_esm2 = __esm({
           if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
             opt.mode = this.fileOptions.mode;
           }
-          (0, import_fs6.writeFileSync)(this.tempFile, this.text, opt);
+          (0, import_fs7.writeFileSync)(this.tempFile, this.text, opt);
         } catch (createFileError) {
           throw new CreateFileError(createFileError);
         }
       }
       readTemporaryFile() {
         try {
-          const tempFileBuffer = (0, import_fs6.readFileSync)(this.tempFile);
+          const tempFileBuffer = (0, import_fs7.readFileSync)(this.tempFile);
           if (tempFileBuffer.length === 0) {
             this.text = "";
           } else {
@@ -85637,14 +85942,14 @@ var init_esm2 = __esm({
       }
       removeTemporaryFile() {
         try {
-          (0, import_fs6.unlinkSync)(this.tempFile);
+          (0, import_fs7.unlinkSync)(this.tempFile);
         } catch (removeFileError) {
           throw new RemoveFileError(removeFileError);
         }
       }
       launchEditor() {
         try {
-          const editorProcess = (0, import_child_process12.spawnSync)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+          const editorProcess = (0, import_child_process13.spawnSync)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
           this.lastExitStatus = editorProcess.status ?? 0;
         } catch (launchError) {
           throw new LaunchEditorError(launchError);
@@ -85652,7 +85957,7 @@ var init_esm2 = __esm({
       }
       launchEditorAsync(callback) {
         try {
-          const editorProcess = (0, import_child_process12.spawn)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+          const editorProcess = (0, import_child_process13.spawn)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
           editorProcess.on("exit", (code) => {
             this.lastExitStatus = code;
             setImmediate(callback);
@@ -87930,9 +88235,9 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execFileSync: execFileSync4 } = await import("child_process");
+    const { execFileSync: execFileSync5 } = await import("child_process");
     const currentVersion = resolvePackageVersion();
-    const latestVersion = readLatestPublishedCliVersion(execFileSync4);
+    const latestVersion = readLatestPublishedCliVersion(execFileSync5);
     if (!latestVersion) return;
     if (!currentVersion || !latestVersion || currentVersion === latestVersion) return;
     console.log(source_default2.yellow(`  Update available: ${currentVersion} \u2192 ${latestVersion}`));
@@ -87949,7 +88254,7 @@ async function checkForUpdate() {
     const spinner = (await Promise.resolve().then(() => (init_ora(), ora_exports))).default("Updating adhdev CLI...").start();
     try {
       const installCommand = buildPinnedGlobalInstallCommand({ packageName: "adhdev", targetVersion: "latest" });
-      execFileSync4(installCommand.command, installCommand.args, {
+      execFileSync5(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]