@adhdev/daemon-core 0.9.27 → 0.9.29

package/dist/index.js

@@ -66,6 +66,29 @@ function asOptionalString(value) {
 function asBoolean(value, fallback) {
   return typeof value === "boolean" ? value : fallback;
 }
+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 {
@@ -86,6 +109,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),
@@ -235,6 +259,7 @@ var init_config = __esm({
       machineSecret: null,
       registeredMachineId: void 0,
       providerSettings: {},
+      machineProviders: {},
       ideSettings: {},
       providerSourceMode: "normal",
       terminalSizingMode: "measured"
@@ -12905,6 +12930,8 @@ var DaemonCommandHandler = class {
 var os12 = __toESM(require("os"));
 var path12 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
+var import_fs5 = require("fs");
+var import_child_process6 = require("child_process");
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
 init_config();
@@ -14974,6 +15001,27 @@ function shouldRestoreHostedRuntime(record, managerTag) {
 }
 
 // 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(os12.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;
+  }
+}
 var chalkModule = import_chalk.default;
 var chalkApi = typeof chalkModule.yellow === "function" ? chalkModule : chalkModule.default || null;
 function colorize(color, text) {
@@ -15239,29 +15287,33 @@ var DaemonCliManager = class {
     if (!trimmed) throw new Error("working directory required");
     const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os12.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)
       });
@@ -15731,7 +15783,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
 };
 
 // src/launch.ts
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 var net = __toESM(require("net"));
 var os14 = __toESM(require("os"));
 var path14 = __toESM(require("path"));
@@ -16202,15 +16254,18 @@ var ProviderLoader = class _ProviderLoader {
   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() } : {}
         });
       }
@@ -16339,9 +16394,10 @@ var ProviderLoader = class _ProviderLoader {
     return [...this.providers.values()].filter((p) => p.category === "ide" && p.cdpPorts).map((p) => p.type);
   }
   getSpawnCommand(type, fallback) {
-    const override = this.getOptionalStringSetting(type, "executablePath");
-    if (override) return override;
-    return fallback || this.providers.get(type)?.spawn?.command || type;
+    const providerType = this.resolveAlias(type);
+    const machineConfig = this.getMachineProviderConfig(providerType);
+    if (machineConfig.executable) return machineConfig.executable;
+    return fallback || this.providers.get(providerType)?.spawn?.command || providerType;
   }
   getIdeCliCommand(type, fallback) {
     const override = this.getOptionalStringSetting(type, "cliPathOverride");
@@ -16355,6 +16411,131 @@ var ProviderLoader = class _ProviderLoader {
     const osPaths = this.providers.get(type)?.paths?.[process.platform];
     return Array.isArray(osPaths) ? [...osPaths] : [];
   }
+  isMachineProviderEnabled(type) {
+    const providerType = this.resolveAlias(type);
+    const config = this.readConfig();
+    return config?.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 config = this.readConfig();
+    if (!config) return false;
+    try {
+      if (!config.machineProviders) config.machineProviders = {};
+      const current = config.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;
+      }
+      config.machineProviders[providerType] = next;
+      if (next.enabled !== true) {
+        this.providerAvailability.set(providerType, { installed: false, detectedPath: null });
+      }
+      this.writeConfig(config);
+      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, fallback = []) {
+    const machineConfig = this.getMachineProviderConfig(type);
+    if (machineConfig.args) return [...machineConfig.args];
+    return [...fallback];
+  }
+  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,
@@ -16362,18 +16543,53 @@ var ProviderLoader = class _ProviderLoader {
     });
   }
   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) {
@@ -16394,8 +16610,14 @@ var ProviderLoader = class _ProviderLoader {
   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
@@ -16542,6 +16764,13 @@ var ProviderLoader = class _ProviderLoader {
         }
       }
     }
+    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;
   }
   /**
@@ -16864,20 +17093,33 @@ var ProviderLoader = class _ProviderLoader {
   * 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 config = this.readConfig();
-    const userVal = config?.providerSettings?.[type]?.[key];
+    const userVal = config?.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;
   }
@@ -16885,7 +17127,8 @@ var ProviderLoader = class _ProviderLoader {
   * 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;
@@ -16896,14 +17139,25 @@ var ProviderLoader = class _ProviderLoader {
       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 config = this.readConfig();
     if (!config) return false;
     try {
       if (!config.providerSettings) config.providerSettings = {};
-      if (!config.providerSettings[type]) config.providerSettings[type] = {};
-      config.providerSettings[type][key] = value;
+      if (!config.providerSettings[providerType]) config.providerSettings[providerType] = {};
+      config.providerSettings[providerType][key] = value;
       this.writeConfig(config);
-      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}`);
@@ -16964,6 +17218,15 @@ var ProviderLoader = class _ProviderLoader {
   }
   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",
@@ -16982,6 +17245,15 @@ var ProviderLoader = class _ProviderLoader {
         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 = {
@@ -17300,32 +17572,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 {
       }
     }
@@ -17335,13 +17607,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 {
         }
       }
@@ -17359,13 +17631,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",
@@ -17380,14 +17652,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 }
         );
@@ -17396,7 +17668,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 {
@@ -17409,7 +17681,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 }
       );
@@ -17561,10 +17833,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}`);
   }
@@ -17590,7 +17862,7 @@ 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();
@@ -18050,8 +18322,8 @@ function buildStatusSnapshot(options) {
 }
 
 // src/commands/upgrade-helper.ts
-var import_child_process7 = require("child_process");
 var import_child_process8 = require("child_process");
+var import_child_process9 = require("child_process");
 var fs8 = __toESM(require("fs"));
 var os17 = __toESM(require("os"));
 var path16 = __toESM(require("path"));
@@ -18152,7 +18424,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");
     }
@@ -18190,7 +18462,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)) {
@@ -18211,9 +18483,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]);
@@ -18246,7 +18518,7 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
 }
 function spawnDetachedDaemonUpgradeHelper(payload) {
   const env = { ...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,
@@ -18276,7 +18548,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,
     {
@@ -18298,7 +18570,7 @@ async function runDaemonUpgradeHelper(payload) {
     const env = { ...process.env };
     delete env[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,
@@ -18833,6 +19105,33 @@ var DaemonCommandRouter = class {
         }
         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);
@@ -18878,13 +19177,16 @@ var DaemonCommandRouter = class {
           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 || "-"}`);
@@ -20605,7 +20907,7 @@ init_chat_message_normalization();
 var fs10 = __toESM(require("fs"));
 var path17 = __toESM(require("path"));
 var os18 = __toESM(require("os"));
-var import_child_process9 = require("child_process");
+var import_child_process10 = require("child_process");
 var import_os3 = require("os");
 var ARCHIVE_PATH = path17.join(os18.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
@@ -20662,7 +20964,7 @@ var VersionArchive = class {
 };
 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"]
@@ -26448,7 +26750,7 @@ function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
 }
 
 // src/installer.ts
-var import_child_process10 = require("child_process");
+var import_child_process11 = require("child_process");
 var EXTENSION_CATALOG = [
   // AI Agent extensions
   {
@@ -26538,7 +26840,7 @@ var EXTENSION_CATALOG = [
 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"]
@@ -26579,7 +26881,7 @@ async function installExtension(ide, extension) {
         fs15.writeFileSync(vsixPath, buffer);
         return new Promise((resolve12) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
-          (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
+          (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
             resolve12({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
@@ -26595,7 +26897,7 @@ async function installExtension(ide, extension) {
   }
   return new Promise((resolve12) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
+    (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
         resolve12({
           extensionId: extension.id,
@@ -26632,7 +26934,7 @@ 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;
@@ -26748,10 +27050,11 @@ async function initDaemonComponents(config) {
     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);
       }