@adhdev/daemon-core 0.9.28 → 0.9.30

package/dist/index.mjs

@@ -65,6 +65,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 {
@@ -85,6 +108,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),
@@ -230,6 +254,7 @@ var init_config = __esm({
       machineSecret: null,
       registeredMachineId: void 0,
       providerSettings: {},
+      machineProviders: {},
       ideSettings: {},
       providerSourceMode: "normal",
       terminalSizingMode: "measured"
@@ -12753,6 +12778,8 @@ init_provider_cli_adapter();
 import * as os12 from "os";
 import * as path12 from "path";
 import * as crypto4 from "crypto";
+import { existsSync as existsSync10 } from "fs";
+import { execFileSync } from "child_process";
 import chalk from "chalk";
 init_config();
 
@@ -14826,6 +14853,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 existsSync10(expandExecutable(trimmed));
+  }
+  try {
+    execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 var chalkModule = chalk;
 var chalkApi = typeof chalkModule.yellow === "function" ? chalkModule : chalkModule.default || null;
 function colorize(color, text) {
@@ -15091,29 +15139,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)
       });
@@ -16054,15 +16106,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() } : {}
         });
       }
@@ -16191,9 +16246,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");
@@ -16207,6 +16263,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,
@@ -16214,18 +16395,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) {
@@ -16246,8 +16462,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
@@ -16394,6 +16616,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;
   }
   /**
@@ -16716,20 +16945,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;
   }
@@ -16737,7 +16979,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;
@@ -16748,14 +16991,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}`);
@@ -16816,6 +17070,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",
@@ -16834,6 +17097,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 = {
@@ -17646,7 +17918,11 @@ function buildAvailableProviders(providerLoader) {
     icon: provider.icon || "\u{1F4BB}",
     category: provider.category,
     ...provider.installed !== void 0 ? { installed: provider.installed } : {},
-    ...provider.detectedPath !== void 0 ? { detectedPath: provider.detectedPath } : {}
+    ...provider.detectedPath !== void 0 ? { detectedPath: provider.detectedPath } : {},
+    ...provider.enabled !== void 0 ? { enabled: provider.enabled } : {},
+    ...provider.machineStatus !== void 0 ? { machineStatus: provider.machineStatus } : {},
+    ...provider.lastDetection !== void 0 ? { lastDetection: provider.lastDetection } : {},
+    ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {}
   }));
 }
 function buildMachineInfo(profile = "full") {
@@ -17902,7 +18178,7 @@ function buildStatusSnapshot(options) {
 }
 
 // src/commands/upgrade-helper.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { spawn as spawn3 } from "child_process";
 import * as fs8 from "fs";
 import * as os17 from "os";
@@ -18004,7 +18280,7 @@ function getNpmExecOptions() {
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      execFileSync("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      execFileSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -18042,7 +18318,7 @@ function stopSessionHostProcesses(appName) {
   }
   if (process.platform !== "win32") {
     try {
-      const raw = execFileSync("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      const raw = execFileSync2("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)) {
@@ -18063,9 +18339,9 @@ function removeDaemonPidFile() {
 function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   const npmExecOpts = getNpmExecOptions();
   const prefixArgs = surface.installPrefix ? ["--prefix", surface.installPrefix] : [];
-  const npmRoot = execFileSync(surface.npmExecutable, ["root", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmRoot = execFileSync2(surface.npmExecutable, ["root", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
   if (!npmRoot) return;
-  const npmPrefix = surface.installPrefix || execFileSync(surface.npmExecutable, ["prefix", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmPrefix = surface.installPrefix || execFileSync2(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]);
@@ -18128,7 +18404,7 @@ async function runDaemonUpgradeHelper(payload) {
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = execFileSync(
+  const installOutput = execFileSync2(
     installCommand.command,
     installCommand.args,
     {
@@ -18685,6 +18961,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);
@@ -18730,13 +19033,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 || "-"}`);
@@ -26605,10 +26911,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);
       }