@adhdev/daemon-core 0.8.27 → 0.8.29

package/src/detection/cli-detector.ts

@@ -9,6 +9,8 @@
 
 import { exec } from 'child_process';
 import * as os from 'os';
+import * as path from 'path';
+import { existsSync } from 'fs';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 
 export interface CLIInfo {
@@ -28,6 +30,33 @@ function parseVersion(raw: string): string {
     return match ? match[1] : raw.split('\n')[0].slice(0, 100);
 }
 
+function shellQuote(value: string): string {
+    if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(value)) return value;
+    return `"${value.replace(/(["\\$`])/g, '\\$1')}"`;
+}
+
+function expandHome(value: string): string {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('~')) return trimmed;
+    return path.join(os.homedir(), trimmed.slice(1));
+}
+
+function isExplicitCommandPath(command: string): boolean {
+    const trimmed = command.trim();
+    return path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\') || trimmed.startsWith('~');
+}
+
+function resolveCommandPath(command: string): string | null {
+    const trimmed = command.trim();
+    if (!trimmed) return null;
+    if (isExplicitCommandPath(trimmed)) {
+        const expanded = expandHome(trimmed);
+        const candidate = path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+        return existsSync(candidate) ? candidate : null;
+    }
+    return null;
+}
+
 /** Run a shell command with timeout, returning stdout or null on failure */
 function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
     return new Promise((resolve) => {
@@ -47,9 +76,13 @@ function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
  * Detect all CLI/ACP agents (parallel)
  * @param providerLoader ProviderLoader instance (dynamic list creation)
  */
-export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIInfo[]> {
+export async function detectCLIs(
+    providerLoader?: ProviderLoader,
+    options?: { includeVersion?: boolean },
+): Promise<CLIInfo[]> {
     const platform = os.platform();
     const whichCmd = platform === 'win32' ? 'where' : 'which';
+    const includeVersion = options?.includeVersion !== false;
 
     // Provider-based dynamic list creation, fallback is empty array
     const cliList = providerLoader
@@ -60,28 +93,31 @@ export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIIn
     const results = await Promise.all(
         cliList.map(async (cli): Promise<CLIInfo> => {
             try {
-                const pathResult = await execAsync(`${whichCmd} ${cli.command}`);
+                const explicitPath = resolveCommandPath(cli.command);
+                const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(cli.command)}`);
                 if (!pathResult) return { ...cli, installed: false };
 
-                const firstPath = pathResult.split('\n')[0];
+                const firstPath = explicitPath || pathResult.split('\n')[0];
 
                 // Get version (parallel with other checks)
                 let version: string | undefined;
-                try {
+                if (includeVersion) {
                     const versionCommands = [
+                        `"${firstPath}" --version`,
+                        `"${firstPath}" -V`,
+                        `"${firstPath}" -v`,
                         cli.versionCommand,
-                        `${cli.command} --version`,
-                        `${cli.command} -V`,
-                        `${cli.command} -v`,
                     ].filter((v): v is string => !!v);
-                    for (const versionCommand of versionCommands) {
-                        const versionResult = await execAsync(versionCommand, 3000);
-                        if (versionResult) {
-                            version = parseVersion(versionResult);
-                            break;
+                    try {
+                        for (const versionCommand of versionCommands) {
+                            const versionResult = await execAsync(versionCommand, 3000);
+                            if (versionResult) {
+                                version = parseVersion(versionResult);
+                                break;
+                            }
                         }
-                    }
-                } catch { }
+                    } catch { }
+                }
 
                 return { ...cli, installed: true, version, path: firstPath };
             } catch {
@@ -94,7 +130,11 @@ export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIIn
 }
 
 /** Detect specific CLI — only probes the one requested provider */
-export async function detectCLI(cliId: string, providerLoader?: ProviderLoader): Promise<CLIInfo | null> {
+export async function detectCLI(
+    cliId: string,
+    providerLoader?: ProviderLoader,
+    options?: { includeVersion?: boolean },
+): Promise<CLIInfo | null> {
     const resolvedId = providerLoader ? providerLoader.resolveAlias(cliId) : cliId;
 
     if (providerLoader) {
@@ -104,25 +144,28 @@ export async function detectCLI(cliId: string, providerLoader?: ProviderLoader):
             const platform = os.platform();
             const whichCmd = platform === 'win32' ? 'where' : 'which';
             try {
-                const pathResult = await execAsync(`${whichCmd} ${target.command}`);
+                const explicitPath = resolveCommandPath(target.command);
+                const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
                 if (!pathResult) return null;
-                const firstPath = pathResult.split('\n')[0];
+                const firstPath = explicitPath || pathResult.split('\n')[0];
                 let version: string | undefined;
-                try {
+                if (options?.includeVersion !== false) {
                     const versionCommands = [
+                        `"${firstPath}" --version`,
+                        `"${firstPath}" -V`,
+                        `"${firstPath}" -v`,
                         target.versionCommand,
-                        `${target.command} --version`,
-                        `${target.command} -V`,
-                        `${target.command} -v`,
                     ].filter((v): v is string => !!v);
-                    for (const versionCommand of versionCommands) {
-                        const versionResult = await execAsync(versionCommand, 3000);
-                        if (versionResult) {
-                            version = parseVersion(versionResult);
-                            break;
+                    try {
+                        for (const versionCommand of versionCommands) {
+                            const versionResult = await execAsync(versionCommand, 3000);
+                            if (versionResult) {
+                                version = parseVersion(versionResult);
+                                break;
+                            }
                         }
-                    }
-                } catch { }
+                    } catch { }
+                }
                 return { ...target, installed: true, version, path: firstPath };
             } catch {
                 return null;
@@ -131,6 +174,6 @@ export async function detectCLI(cliId: string, providerLoader?: ProviderLoader):
     }
 
     // Fallback: full scan for unknown provider IDs
-    const all = await detectCLIs(providerLoader);
+    const all = await detectCLIs(providerLoader, options);
     return all.find((c) => c.id === resolvedId && c.installed) || null;
 }

package/src/detection/ide-detector.ts

@@ -10,6 +10,8 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { platform, homedir } from 'os';
+import * as path from 'path';
+import type { ProviderLoader } from '../providers/provider-loader.js';
 
 // ─── Types ──────────────────────────────────────
 
@@ -62,9 +64,18 @@ function getMergedDefinitions(): IDEDefinition[] {
 }
 
 function findCliCommand(command: string): string | null {
+    const trimmed = String(command || '').trim();
+    if (!trimmed) return null;
+    if (path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\') || trimmed.startsWith('~')) {
+        const candidate = trimmed.startsWith('~')
+            ? path.join(homedir(), trimmed.slice(1))
+            : trimmed;
+        const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(candidate);
+        return existsSync(resolved) ? resolved : null;
+    }
     try {
         const result = execSync(
-            platform() === 'win32' ? `where ${command}` : `which ${command}`,
+            platform() === 'win32' ? `where ${trimmed}` : `which ${trimmed}`,
             { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
         ).trim();
         return result.split('\n')[0] || null;
@@ -89,27 +100,29 @@ function getIdeVersion(cliCommand: string): string | null {
 function checkPathExists(paths: string[]): string | null {
     const home = homedir();
     for (const p of paths) {
-        if (p.includes('*')) {
+        const normalized = p.startsWith('~')
+            ? path.join(home, p.slice(1))
+            : p;
+        if (normalized.includes('*')) {
             // Wildcard expansion: replace `*` with the current user's home folder name
             // e.g. "C:\Users\*\AppData\..." → "C:\Users\vilmi\AppData\..."
             const username = home.split(/[\\/]/).pop() || '';
-            const resolved = p.replace('*', username);
+            const resolved = normalized.replace('*', username);
             if (existsSync(resolved)) return resolved;
         } else {
-            if (existsSync(p)) return p;
+            if (existsSync(normalized)) return normalized;
         }
     }
     return null;
 }
 
-export async function detectIDEs(): Promise<IDEInfo[]> {
+export async function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEInfo[]> {
     const os = platform() as 'darwin' | 'win32' | 'linux';
     const results: IDEInfo[] = [];
 
     for (const def of getMergedDefinitions()) {
-        const cliPath = findCliCommand(def.cli);
-        const appPath = checkPathExists(def.paths[os] || []);
-        const installed = !!(cliPath || appPath);
+        const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
+        const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os] || []) || []);
 
         let resolvedCli = cliPath;
 
@@ -136,6 +149,9 @@ export async function detectIDEs(): Promise<IDEInfo[]> {
             }
         }
 
+        const installed = os === 'darwin'
+            ? !!(resolvedCli || appPath)
+            : !!resolvedCli;
         const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
 
         results.push({

package/src/launch.ts

@@ -310,7 +310,7 @@ export async function launchWithCdp(options: LaunchOptions = {}): Promise<Launch
 
  // 1. IDE determine
     let targetIde: IDEInfo | undefined;
-    const ides = await detectIDEs();
+    const ides = await detectIDEs(getProviderLoader());
 
     if (options.ideId) {
         targetIde = ides.find(i => i.id === options.ideId && i.installed);

package/src/providers/acp-provider-instance.ts

@@ -327,8 +327,9 @@ export class AcpProviderInstance implements ProviderInstance {
  // Find configId for this category
         const opt = this.configOptions.find(c => c.category === category);
         if (!opt) {
-            this.log.warn(`[${this.type}] No config option for category: ${category}`);
-            return;
+            const message = `[${this.type}] No config option for category: ${category}`;
+            this.log.warn(message);
+            throw new Error(message);
         }
 
  // Static config mode: update selection and restart process
@@ -343,8 +344,9 @@ export class AcpProviderInstance implements ProviderInstance {
         }
 
         if (!this.connection || !this.sessionId) {
-            this.log.warn(`[${this.type}] Cannot set config: no active connection/session`);
-            return;
+            const message = `[${this.type}] Cannot set config: no active connection/session`;
+            this.log.warn(message);
+            throw new Error(message);
         }
 
         try {
@@ -361,7 +363,9 @@ export class AcpProviderInstance implements ProviderInstance {
             if (result?.configOptions) this.parseConfigOptions(result.configOptions);
             this.log.info(`[${this.type}] Config ${category} set to: ${value} | response: ${JSON.stringify(result)?.slice(0, 300)}`);
         } catch (e: any) {
-            this.log.warn(`[${this.type}] set_config_option failed: ${e?.message}`);
+            const message = e?.message || 'Unknown ACP config error';
+            this.log.warn(`[${this.type}] set_config_option failed: ${message}`);
+            throw new Error(message);
         }
     }
 
@@ -380,8 +384,9 @@ export class AcpProviderInstance implements ProviderInstance {
         }
 
         if (!this.connection || !this.sessionId) {
-            this.log.warn(`[${this.type}] Cannot set mode: no active connection/session`);
-            return;
+            const message = `[${this.type}] Cannot set mode: no active connection/session`;
+            this.log.warn(message);
+            throw new Error(message);
         }
 
         try {
@@ -392,7 +397,9 @@ export class AcpProviderInstance implements ProviderInstance {
             this.currentMode = modeId;
             this.log.info(`[${this.type}] Mode set to: ${modeId}`);
         } catch (e: any) {
-            this.log.warn(`[${this.type}] set_mode failed: ${e?.message}`);
+            const message = e?.message || 'Unknown ACP mode error';
+            this.log.warn(`[${this.type}] set_mode failed: ${message}`);
+            throw new Error(message);
         }
     }
 
@@ -447,7 +454,9 @@ export class AcpProviderInstance implements ProviderInstance {
             throw new Error(`[ACP:${this.type}] No spawn config defined`);
         }
 
-        const command = spawnConfig.command;
+        const command = typeof this.settings.executablePath === 'string' && this.settings.executablePath.trim()
+            ? this.settings.executablePath.trim()
+            : spawnConfig.command;
  // Static config: create args via spawnArgBuilder (when provider defines it)
         let baseArgs = spawnConfig.args || [];
         if (this.provider.spawnArgBuilder && Object.keys(this.selectedConfig).length > 0) {
@@ -822,7 +831,7 @@ export class AcpProviderInstance implements ProviderInstance {
 
     private permissionResolvers: ((approved: boolean) => void)[] = [];
 
-    private async resolvePermission(approved: boolean): Promise<void> {
+    async resolvePermission(approved: boolean): Promise<void> {
         const resolver = this.permissionResolvers.shift();
         if (resolver) {
             resolver(approved);

package/src/providers/cli-provider-instance.ts

@@ -60,6 +60,7 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     readonly instanceId: string;
+    private suppressIdleHistoryReplay = false;
 
     private presentationMode: 'terminal' | 'chat';
     private providerSessionId?: string;
@@ -135,7 +136,15 @@ export class CliProviderInstance implements ProviderInstance {
         await this.adapter.spawn();
         this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
+            this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
             const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
+            this.historyWriter.seedSessionHistory(
+                this.type,
+                restoredHistory.messages,
+                this.providerSessionId,
+                this.instanceId,
+            );
+            this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
             if (restoredHistory.messages.length > 0) {
                 this.adapter.seedCommittedMessages(
                     restoredHistory.messages.map((message) => ({
@@ -184,7 +193,7 @@ export class CliProviderInstance implements ProviderInstance {
             } else if (this.type === 'codex-cli') {
                 probedSessionId = this.probeSessionIdFromConfig({
                     dbPath: '~/.codex/state_5.sqlite',
-                    query: 'select id from threads where cwd in ({dirs}) and created_at >= ? and archived = 0 order by created_at desc limit 1',
+                    query: 'select id from threads where cwd in ({dirs}) and updated_at >= ? and archived = 0 order by updated_at desc limit 1',
                     timestampFormat: 'unix_s',
                 });
             } else if (this.type === 'goose-cli') {
@@ -260,6 +269,10 @@ export class CliProviderInstance implements ProviderInstance {
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
         if (parsedMessages.length > 0) {
+            const shouldSkipReplayPersist =
+                this.suppressIdleHistoryReplay
+                && adapterStatus.status === 'idle'
+                && parsedStatus?.status === 'idle';
             let messagesToSave = parsedMessages;
             if ((parsedStatus?.status === 'generating' || parsedStatus?.status === 'long_generating')) {
                 const lastIdx = messagesToSave.length - 1;
@@ -267,7 +280,7 @@ export class CliProviderInstance implements ProviderInstance {
                     messagesToSave = messagesToSave.slice(0, lastIdx);
                 }
             }
-            if (messagesToSave.length > 0) {
+            if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
                 this.historyWriter.appendNewMessages(
                     this.type,
                     messagesToSave,
@@ -374,6 +387,7 @@ export class CliProviderInstance implements ProviderInstance {
         if (newStatus !== this.lastStatus) {
             LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
             if (this.lastStatus === 'idle' && newStatus === 'generating') {
+                this.suppressIdleHistoryReplay = false;
                 // Cancel any pending completed event (multi-step: idle→generating resume)
                 if (this.completedDebouncePending) {
                     LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed generating)`);
@@ -394,6 +408,7 @@ export class CliProviderInstance implements ProviderInstance {
                     this.generatingDebounceTimer = null;
                 }, 1000);
             } else if (newStatus === 'waiting_approval') {
+                this.suppressIdleHistoryReplay = false;
                 // Flush pending generating_started if debounce still pending
                 if (this.generatingDebouncePending) {
                     if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }

package/src/providers/provider-loader.ts

@@ -24,12 +24,19 @@ import type {
   ProviderModule,
   ProviderCategory,
   ProviderScripts,
+  ProviderSettingDef,
   ProviderSettingSchema,
   ResolvedProvider,
 } from './contracts.js';
 
+interface ProviderAvailabilityState {
+  installed: boolean;
+  detectedPath: string | null;
+}
+
 export class ProviderLoader {
   private providers = new Map<string, ProviderModule>();
+  private providerAvailability = new Map<string, ProviderAvailabilityState>();
   private userDir: string;
   private upstreamDir: string;
   private disableUpstream: boolean;
@@ -152,6 +159,7 @@ export class ProviderLoader {
  */
   loadAll(): void {
     this.providers.clear();
+    this.providerAvailability.clear();
 
  // 1. Load upstream (GitHub auto-download — primary source)
     let upstreamCount = 0;
@@ -236,11 +244,12 @@ export class ProviderLoader {
         const versionCommand = typeof verCmdConfig === 'object' && verCmdConfig !== null
           ? verCmdConfig[process.platform]
           : verCmdConfig;
+        const command = this.getSpawnCommand(p.type, p.spawn.command);
         result.push({
           id: p.type,
           displayName: p.displayName || p.name,
           icon: p.icon || '🔧',
-          command: p.spawn.command,
+          command,
           category: p.category,
           ...(typeof versionCommand === 'string' && versionCommand.trim()
             ? { versionCommand: versionCommand.trim() }
@@ -386,6 +395,80 @@ export class ProviderLoader {
       .map(p => p.type);
   }
 
+  getSpawnCommand(type: string, fallback?: string): string {
+    const override = this.getOptionalStringSetting(type, 'executablePath');
+    if (override) return override;
+    return fallback || this.providers.get(type)?.spawn?.command || type;
+  }
+
+  getIdeCliCommand(type: string, fallback?: string | null): string | null {
+    const override = this.getOptionalStringSetting(type, 'cliPathOverride');
+    if (override) return override;
+    return fallback || this.providers.get(type)?.cli || null;
+  }
+
+  getIdePathCandidates(type: string, fallback?: string[]): string[] {
+    const override = this.getOptionalStringSetting(type, 'appPathOverride');
+    if (override) return [override];
+    if (fallback && fallback.length > 0) return fallback;
+    const osPaths = this.providers.get(type)?.paths?.[process.platform];
+    return Array.isArray(osPaths) ? [...osPaths] : [];
+  }
+
+  setProviderAvailability(type: string, state: { installed: boolean; detectedPath?: string | null }): void {
+    this.providerAvailability.set(type, {
+      installed: !!state.installed,
+      detectedPath: state.detectedPath ?? null,
+    });
+  }
+
+  setCliDetectionResults(results: Array<{ id: string; installed: boolean; path?: string }>, replace: boolean = true): void {
+    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 });
+        }
+      }
+    }
+    for (const result of results) {
+      this.setProviderAvailability(result.id, {
+        installed: !!result.installed,
+        detectedPath: result.path || null,
+      });
+    }
+  }
+
+  setIdeDetectionResults(results: Array<{ id: string; installed: boolean; path?: string | null; cliCommand?: string | null }>, replace: boolean = true): void {
+    if (replace) {
+      for (const provider of this.providers.values()) {
+        if (provider.category === 'ide') {
+          this.providerAvailability.set(provider.type, { installed: false, detectedPath: null });
+        }
+      }
+    }
+    for (const result of results) {
+      this.setProviderAvailability(result.id, {
+        installed: !!result.installed,
+        detectedPath: result.cliCommand || result.path || null,
+      });
+    }
+  }
+
+  getAvailableProviderInfos(): Array<ProviderModule & { installed?: boolean; detectedPath?: string | null }> {
+    return this.getAll().map((provider) => {
+      const availability = this.providerAvailability.get(provider.type);
+      return {
+        ...provider,
+        ...(availability
+          ? {
+              installed: availability.installed,
+              detectedPath: availability.detectedPath,
+            }
+          : {}),
+      };
+    });
+  }
+
  /**
  * Register IDE providers to core/detector registry
  * → Enables detectIDEs() to detect provider.js-based IDEs
@@ -888,9 +971,8 @@ export class ProviderLoader {
  * Get public settings schema for a provider (for dashboard UI rendering)
  */
   getPublicSettings(type: string): ProviderSettingSchema[] {
-    const provider = this.providers.get(type);
-    if (!provider?.settings) return [];
-    return Object.entries(provider.settings)
+    const settings = this.getSettingsSchema(type);
+    return Object.entries(settings)
       .filter(([, def]) => (def as any).public === true)
       .map(([key, def]) => ({ key, ...(def as any) }));
   }
@@ -911,8 +993,7 @@ export class ProviderLoader {
  * Resolved setting value for a provider (default + user override)
  */
   getSettingValue(type: string, key: string): any {
-    const provider = this.providers.get(type);
-    const schemaDef = provider?.settings?.[key];
+    const schemaDef = this.getSettingsSchema(type)[key];
     const defaultVal = schemaDef ? (schemaDef as any).default : undefined;
 
  // Load user-saved value
@@ -930,10 +1011,9 @@ export class ProviderLoader {
  * All resolved settings for a provider (default + user override)
  */
   getSettings(type: string): Record<string, any> {
-    const provider = this.providers.get(type);
-    if (!provider?.settings) return {};
+    const settings = this.getSettingsSchema(type);
     const result: Record<string, any> = {};
-    for (const [key, def] of Object.entries(provider.settings)) {
+    for (const [key] of Object.entries(settings)) {
       result[key] = this.getSettingValue(type, key);
     }
     return result;
@@ -943,8 +1023,7 @@ export class ProviderLoader {
  * Save provider setting value (writes to config.json)
  */
   setSetting(type: string, key: string, value: any): boolean {
-    const provider = this.providers.get(type);
-    const schemaDef = provider?.settings?.[key] as any;
+    const schemaDef = this.getSettingsSchema(type)[key] as any;
     if (!schemaDef) return false;
 
  // Non-public settings cannot be modified externally
@@ -952,6 +1031,7 @@ export class ProviderLoader {
 
  // Type validation
     if (schemaDef.type === 'boolean' && typeof value !== 'boolean') return false;
+    if (schemaDef.type === 'string' && typeof value !== 'string') return false;
     if (schemaDef.type === 'number') {
       if (typeof value !== 'number') return false;
       if (schemaDef.min !== undefined && value < schemaDef.min) return false;
@@ -974,6 +1054,59 @@ export class ProviderLoader {
     }
   }
 
+  private getOptionalStringSetting(type: string, key: string): string | null {
+    const value = this.getSettingValue(type, key);
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+
+  private getSettingsSchema(type: string): Record<string, ProviderSettingDef> {
+    const provider = this.providers.get(type);
+    if (!provider) return {};
+    return {
+      ...this.getSyntheticSettings(type, provider),
+      ...(provider.settings || {}),
+    };
+  }
+
+  private getSyntheticSettings(type: string, provider: ProviderModule): Record<string, ProviderSettingDef> {
+    const result: Record<string, ProviderSettingDef> = {};
+
+    if ((provider.category === 'cli' || provider.category === 'acp') && provider.spawn?.command && !provider.settings?.executablePath) {
+      result.executablePath = {
+        type: 'string',
+        default: '',
+        public: true,
+        label: 'Executable path',
+        description: 'Optional absolute path for this provider binary. Leave blank to use the default PATH lookup.',
+      };
+    }
+
+    if (provider.category === 'ide') {
+      if (provider.cli && !provider.settings?.cliPathOverride) {
+        result.cliPathOverride = {
+          type: 'string',
+          default: '',
+          public: true,
+          label: 'CLI path override',
+          description: 'Optional absolute path for the IDE CLI launcher. Leave blank to use the detected default.',
+        };
+      }
+      if (provider.paths && !provider.settings?.appPathOverride) {
+        result.appPathOverride = {
+          type: 'string',
+          default: '',
+          public: true,
+          label: 'App path override',
+          description: 'Optional absolute path for the IDE app bundle or executable. Leave blank to use the default install locations.',
+        };
+      }
+    }
+
+    return result;
+  }
+
  // ─── Private ───────────────────────────────────
 
   /**

package/src/shared-types.ts

@@ -136,6 +136,8 @@ export interface AvailableProviderInfo {
     category: 'ide' | 'extension' | 'cli' | 'acp';
     displayName: string;
     icon: string;
+    installed?: boolean;
+    detectedPath?: string | null;
 }
 
 /** ACP config option (model/mode/thought_level selection) */