@geminilight/mindos 0.6.76 → 0.6.78

package/app/app/api/obsidian/import/route.ts

@@ -0,0 +1,37 @@
+export const dynamic = 'force-dynamic';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { handleRouteErrorSimple } from '@/lib/errors';
+import { importObsidianPlugin, scanObsidianVaultPlugins } from '@/lib/obsidian-compat/obsidian-import';
+import { expandSetupPathHome } from '@/app/api/setup/path-utils';
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json() as { vaultRoot?: string; pluginId?: string; targetMindRoot?: string };
+    if (!body.vaultRoot || !body.pluginId) {
+      return NextResponse.json({ ok: false, error: 'Missing vaultRoot or pluginId' }, { status: 400 });
+    }
+
+    const vaultRoot = expandSetupPathHome(body.vaultRoot.trim());
+    const targetMindRoot = expandSetupPathHome((body.targetMindRoot ?? process.cwd()).trim());
+    const plugins = await scanObsidianVaultPlugins(vaultRoot);
+    const plugin = plugins.find((item) => item.id === body.pluginId);
+    if (!plugin) {
+      return NextResponse.json({ ok: false, error: 'Plugin not found in Obsidian vault' }, { status: 404 });
+    }
+
+    const imported = await importObsidianPlugin({
+      vaultRoot,
+      pluginId: body.pluginId,
+      targetMindRoot,
+    });
+
+    return NextResponse.json({
+      ok: true,
+      plugin,
+      imported,
+    });
+  } catch (err) {
+    return handleRouteErrorSimple(err);
+  }
+}

package/app/app/api/setup/check-path/route.ts

@@ -1,7 +1,7 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
 import { existsSync, readdirSync } from 'node:fs';
-import { expandSetupPathHome } from '../path-utils';
+import { expandSetupPathHome, validateMindRootPath } from '../path-utils';
 import { handleRouteErrorSimple } from '@/lib/errors';
 
 export async function POST(req: NextRequest) {
@@ -11,6 +11,20 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
     }
     const abs = expandSetupPathHome(path.trim());
+    
+    // Validate path is not inside dangerous directories
+    const validation = validateMindRootPath(abs);
+    if (!validation.safe) {
+      return NextResponse.json({
+        exists: false,
+        empty: true,
+        count: 0,
+        unsafe: true,
+        reason: validation.reason,
+        reasonZh: validation.reasonZh,
+      });
+    }
+    
     const exists = existsSync(abs);
     let empty = true;
     let count = 0;
@@ -24,7 +38,7 @@ export async function POST(req: NextRequest) {
         empty = false;
       }
     }
-    return NextResponse.json({ exists, empty, count });
+    return NextResponse.json({ exists, empty, count, unsafe: false });
   } catch (err) {
     return handleRouteErrorSimple(err);
   }

package/app/app/api/setup/path-utils.ts

@@ -1,8 +1,130 @@
 import { homedir } from 'node:os';
-import { resolve } from 'node:path';
+import path, { resolve } from 'node:path';
 
 export function expandSetupPathHome(p: string): string {
   if (p === '~') return homedir();
   if (p.startsWith('~/') || p.startsWith('~\\')) return resolve(homedir(), p.slice(2));
   return p;
 }
+
+/**
+ * List of dangerous path prefixes where knowledge base should NEVER be placed.
+ * These paths get cleared during install/update/uninstall and would cause data loss.
+ * 
+ * Windows:
+ *   - %APPDATA%\MindOS     (Electron userData, may be cleared on uninstall)
+ *   - %LOCALAPPDATA%\MindOS
+ *   - Program Files        (install directories, cleared on reinstall)
+ *   - ~/.mindos/runtime    (updater-managed, cleared on core update)
+ * 
+ * macOS/Linux:
+ *   - ~/.mindos/runtime    (updater-managed)
+ *   - /Applications/MindOS.app (install directory)
+ *   - /opt/MindOS          (Linux install directory)
+ */
+export interface PathValidationResult {
+  safe: boolean;
+  reason?: string;
+  reasonZh?: string;
+}
+
+function normalizeForPathCheck(p: string): string {
+  return path.normalize(p).toLowerCase().replace(/\\/g, '/');
+}
+
+function isSameOrSubPath(candidate: string, parent: string): boolean {
+  return candidate === parent || candidate.startsWith(parent + '/');
+}
+
+/**
+ * Check if a knowledge base path is safe (not inside install/system directories).
+ * Returns { safe: true } if OK, or { safe: false, reason, reasonZh } if dangerous.
+ */
+export function validateMindRootPath(absPath: string): PathValidationResult {
+  const normalized = normalizeForPathCheck(absPath);
+  const home = homedir();
+  const homeNorm = normalizeForPathCheck(home);
+
+  // ── 1. ~/.mindos/ system directory (updater, config, cache) ──
+  const mindosDir = homeNorm + '/.mindos';
+  if (isSameOrSubPath(normalized, mindosDir)) {
+    return {
+      safe: false,
+      reason: 'Cannot use ~/.mindos/ — this is the MindOS system directory (config, cache, updater). It gets modified during updates.',
+      reasonZh: '不能使用 ~/.mindos/ 目录——这是 MindOS 系统目录（配置、缓存、更新器），更新时会被修改。',
+    };
+  }
+
+  // ── 2. Windows-specific dangerous paths ──
+  if (process.platform === 'win32') {
+    const appData = normalizeForPathCheck(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'));
+    const localAppData = normalizeForPathCheck(process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'));
+
+    // Electron userData: %APPDATA%\MindOS or %LOCALAPPDATA%\MindOS
+    const electronUserData = appData + '/mindos';
+    const electronLocalData = localAppData + '/mindos';
+    if (isSameOrSubPath(normalized, electronUserData) || isSameOrSubPath(normalized, electronLocalData)) {
+      return {
+        safe: false,
+        reason: 'Cannot use AppData\\MindOS — this is the Electron app data directory. It may be cleared when uninstalling.',
+        reasonZh: '不能使用 AppData\\MindOS 目录——这是 Electron 应用数据目录，卸载时可能被清除。',
+      };
+    }
+
+    // Program Files (default and x86)
+    const programFiles = normalizeForPathCheck(process.env.ProgramFiles || 'C:\\Program Files');
+    const programFilesX86 = normalizeForPathCheck(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)');
+    if (isSameOrSubPath(normalized, programFiles) || isSameOrSubPath(normalized, programFilesX86)) {
+      return {
+        safe: false,
+        reason: 'Cannot use Program Files — this is the Windows application directory. It gets cleared when reinstalling apps.',
+        reasonZh: '不能使用 Program Files 目录——这是 Windows 应用程序目录，重装时会被清除。',
+      };
+    }
+  }
+
+  // ── 3. macOS .app bundle ──
+  if (process.platform === 'darwin') {
+    if (normalized.includes('.app/') || normalized.endsWith('.app')) {
+      return {
+        safe: false,
+        reason: 'Cannot use a path inside an .app bundle — it gets replaced when updating the app.',
+        reasonZh: '不能使用 .app 包内的路径——更新应用时会被替换。',
+      };
+    }
+    // /Applications/MindOS.app adjacent directory
+    if (normalized.startsWith('/applications/mindos')) {
+      return {
+        safe: false,
+        reason: 'Cannot use /Applications/MindOS — this is the app install location. Use ~/MindOS/mind or ~/Documents instead.',
+        reasonZh: '不能使用 /Applications/MindOS——这是应用安装位置。请使用 ~/MindOS/mind 或 ~/Documents。',
+      };
+    }
+  }
+
+  // ── 4. Linux install directories ──
+  if (process.platform === 'linux') {
+    if (normalized.startsWith('/opt/mindos') || normalized.startsWith('/usr/share/mindos')) {
+      return {
+        safe: false,
+        reason: 'Cannot use /opt/MindOS or /usr/share/MindOS — these are system install directories. Use ~/MindOS/mind instead.',
+        reasonZh: '不能使用 /opt/MindOS 或 /usr/share/MindOS——这些是系统安装目录。请使用 ~/MindOS/mind。',
+      };
+    }
+  }
+
+  // ── 5. Actual Desktop install directory (dynamic, covers custom install paths) ──
+  const installDir = process.env.MINDOS_INSTALL_DIR;
+  if (installDir) {
+    const installDirNorm = normalizeForPathCheck(installDir);
+    if (isSameOrSubPath(normalized, installDirNorm)) {
+      return {
+        safe: false,
+        reason: 'Cannot use a path inside the MindOS Desktop installation directory — it gets deleted when reinstalling or uninstalling the app.',
+        reasonZh: '不能使用 MindOS Desktop 安装目录内的路径——重装或卸载应用时会被删除。',
+      };
+    }
+  }
+
+  return { safe: true };
+}

package/app/app/api/setup/route.ts

@@ -4,7 +4,7 @@ import fs from 'fs';
 import os from 'os';
 import { readSettings, writeSettings, ServerSettings } from '@/lib/settings';
 import { applyTemplate } from '@/lib/template';
-import { expandSetupPathHome } from './path-utils';
+import { expandSetupPathHome, validateMindRootPath } from './path-utils';
 import { type ProviderId, isProviderId, PROVIDER_PRESETS } from '@/lib/agent/providers';
 import { type Provider, generateProviderId, findProvider } from '@/lib/custom-endpoints';
 import { handleRouteErrorSimple } from '@/lib/errors';
@@ -60,6 +60,16 @@ export async function POST(req: NextRequest) {
 
     const resolvedRoot = expandSetupPathHome(mindRoot.trim());
 
+    // Validate path is not inside dangerous directories (install dirs, system dirs)
+    const pathValidation = validateMindRootPath(resolvedRoot);
+    if (!pathValidation.safe) {
+      return NextResponse.json({
+        error: pathValidation.reason,
+        errorZh: pathValidation.reasonZh,
+        unsafePath: true,
+      }, { status: 400 });
+    }
+
     // Validate ports
     const webPort = typeof port === 'number' ? port : 3456;
     const mcpPortNum = typeof mcpPort === 'number' ? mcpPort : 8781;

package/app/components/ask/AgentSelectorCapsule.tsx

@@ -27,7 +27,11 @@ export default function AgentSelectorCapsule({
   loading = false,
 }: AgentSelectorCapsuleProps) {
   const { t } = useLocale();
-  const p = t.panels.agents;
+  const p = t.panels?.agents ?? {
+    acpDefaultAgent: 'MindOS',
+    acpSelectAgent: 'Select Agent',
+    acpChangeAgent: 'Change agent',
+  };
   const [open, setOpen] = useState(false);
   const [pos, setPos] = useState<DropdownPos | null>(null);
   const triggerRef = useRef<HTMLButtonElement>(null);
@@ -117,9 +121,6 @@ export default function AgentSelectorCapsule({
   const isDefault = !selectedAgent;
   const displayName = selectedAgent?.name ?? p.acpDefaultAgent;
 
-  // Only show if there are installed agents to choose from
-  if (!loading && installedAgents.length === 0 && !selectedAgent) return null;
-
   const dropdown = open && pos ? (
     <div
       ref={dropdownRef}

package/app/components/ask/AskContent.tsx

@@ -183,7 +183,7 @@ export default function AskContent({ visible, currentFile, initialMessage, initi
     session.setSessionDefaultAcpAgent(agent);
   }, [session]);
   const hasLoadingAttachments = upload.localAttachments.some((f) => f.status === 'loading');
-  const composerStatusMessage = upload.uploadError || imageUpload.imageError || (hasLoadingAttachments ? (t.ask.uploadsProcessing ?? 'Wait for uploaded files to finish processing before sending.') : '');
+  const composerStatusMessage = upload.uploadError || imageUpload.imageError || '';
 
   useEffect(() => {
     const handler = (e: Event) => {
@@ -815,7 +815,7 @@ export default function AskContent({ visible, currentFile, initialMessage, initi
           <div className={cn('flex items-center justify-between border-t border-border/10', isPanel ? 'px-2 pb-1.5 pt-1 gap-1' : 'px-3 pb-2 pt-1.5')}>
             <div className={cn('flex items-center flex-wrap', isPanel ? 'gap-1' : 'gap-2')}>
               <ModeCapsule mode={chatMode} onChange={setChatMode} disabled={isLoading} />
-            {mounted && acpDetection.installedAgents.length > 0 && (
+            {mounted && (
               <AgentSelectorCapsule
                 selectedAgent={selectedAcpAgent}
                 onSelect={handleSelectAcpAgent}

package/app/components/setup/StepKB.tsx

@@ -1,12 +1,23 @@
 'use client';
 
 import { useState, useEffect, useRef } from 'react';
-import { AlertCircle } from 'lucide-react';
+import { AlertCircle, FolderOpen } from 'lucide-react';
 import { Field } from '@/components/settings/Primitives';
 import type { Messages } from '@/lib/i18n';
+import { useLocale } from '@/lib/stores/locale-store';
 import type { SetupState } from './types';
 import { TEMPLATES } from './constants';
 
+// Desktop bridge for folder picker (Electron only)
+interface MindosDesktopBridge {
+  selectDirectory?: () => Promise<string | null>;
+}
+function getDesktopBridge(): MindosDesktopBridge | null {
+  if (typeof window === 'undefined') return null;
+  const w = window as unknown as { mindos?: MindosDesktopBridge };
+  return w.mindos ?? null;
+}
+
 // Derive parent dir from current input for ls — supports both / and \ separators
 function getParentDir(p: string): string {
   if (!p.trim()) return '';
@@ -26,13 +37,15 @@ export interface StepKBProps {
 }
 
 export default function StepKB({ state, update, t, homeDir }: StepKBProps) {
+  const { locale } = useLocale();
+  const isZh = locale === 'zh';
   const s = t.setup;
   const [passwordTouched, setPasswordTouched] = useState(false);
   // Build platform-aware placeholder, e.g. /Users/alice/MindOS/mind or C:\Users\alice\MindOS\mind
   // Windows homedir always contains \, e.g. C:\Users\Alice — safe to detect by separator
   const sep = homeDir.includes('\\') ? '\\' : '/';
   const placeholder = homeDir !== '~' ? [homeDir, 'MindOS', 'mind'].join(sep) : s.kbPathDefault;
-  const [pathInfo, setPathInfo] = useState<{ exists: boolean; empty: boolean; count: number } | null>(null);
+  const [pathInfo, setPathInfo] = useState<{ exists: boolean; empty: boolean; count: number; unsafe?: boolean; reason?: string; reasonZh?: string } | null>(null);
   const [suggestions, setSuggestions] = useState<string[]>([]);
   const [showSuggestions, setShowSuggestions] = useState(false);
   const [activeSuggestion, setActiveSuggestion] = useState(-1);
@@ -126,21 +139,42 @@ export default function StepKB({ state, update, t, homeDir }: StepKBProps) {
     <div className="space-y-6">
       <Field label={s.kbPath} hint={s.kbPathHint}>
         <div className="relative">
-          <input
-            ref={inputRef}
-            value={state.mindRoot}
-            onChange={e => { update('mindRoot', e.target.value); setShowSuggestions(true); }}
-            onKeyDown={handleKeyDown}
-            onBlur={() => setTimeout(() => hideSuggestions(), 150)}
-            onFocus={() => suggestions.length > 0 && setShowSuggestions(true)}
-            placeholder={placeholder}
-            className="w-full px-3 py-2 text-sm rounded-lg border outline-none transition-colors focus-visible:ring-1 focus-visible:ring-ring"
-            style={{
-              background: 'var(--input, var(--card))',
-              borderColor: 'var(--border)',
-              color: 'var(--foreground)',
-            }}
-          />
+          <div className="flex gap-2">
+            <input
+              ref={inputRef}
+              value={state.mindRoot}
+              onChange={e => { update('mindRoot', e.target.value); setShowSuggestions(true); }}
+              onKeyDown={handleKeyDown}
+              onBlur={() => setTimeout(() => hideSuggestions(), 150)}
+              onFocus={() => suggestions.length > 0 && setShowSuggestions(true)}
+              placeholder={placeholder}
+              className="flex-1 px-3 py-2 text-sm rounded-lg border outline-none transition-colors focus-visible:ring-1 focus-visible:ring-ring"
+              style={{
+                background: 'var(--input, var(--card))',
+                borderColor: 'var(--border)',
+                color: 'var(--foreground)',
+              }}
+            />
+            {/* Folder picker button — Desktop (Electron) only */}
+            {getDesktopBridge()?.selectDirectory && (
+              <button
+                type="button"
+                onClick={async () => {
+                  const selected = await getDesktopBridge()?.selectDirectory?.();
+                  if (selected) {
+                    justSelectedRef.current = true;
+                    update('mindRoot', selected);
+                    hideSuggestions();
+                  }
+                }}
+                className="px-3 py-2 rounded-lg border transition-colors hover:bg-muted/50"
+                style={{ borderColor: 'var(--border)' }}
+                title={s.kbPathBrowse ?? 'Browse...'}
+              >
+                <FolderOpen size={16} style={{ color: 'var(--muted-foreground)' }} />
+              </button>
+            )}
+          </div>
           {showSuggestions && suggestions.length > 0 && (
             <div
               role="listbox"
@@ -179,6 +213,21 @@ export default function StepKB({ state, update, t, homeDir }: StepKBProps) {
             {s.kbPathUseDefault(placeholder)}
           </button>
         )}
+        {/* ⚠️ Unsafe path warning — blocks setup until user picks a safe path */}
+        {pathInfo?.unsafe && (
+          <div className="mt-3 rounded-lg border p-3 text-sm flex gap-2 items-start"
+            style={{ borderColor: 'var(--error)', background: 'color-mix(in srgb, var(--error) 8%, transparent)' }}>
+            <AlertCircle size={16} className="flex-shrink-0 mt-0.5" style={{ color: 'var(--error)' }} />
+            <div>
+              <p className="font-medium" style={{ color: 'var(--error)' }}>
+                {isZh ? '路径不安全' : 'Unsafe Path'}
+              </p>
+              <p className="mt-1" style={{ color: 'var(--muted-foreground)' }}>
+                {isZh ? pathInfo.reasonZh : pathInfo.reason}
+              </p>
+            </div>
+          </div>
+        )}
       </Field>
       {/* Template selection — conditional on directory state */}
       {pathInfo && pathInfo.exists && !pathInfo.empty && !showTemplatePickerAnyway ? (

package/app/components/setup/index.tsx

@@ -157,6 +157,7 @@ export default function SetupWizard() {
 
   const [webPortStatus, setWebPortStatus] = useState<PortStatus>({ checking: false, available: null, isSelf: false, suggestion: null });
   const [mcpPortStatus, setMcpPortStatus] = useState<PortStatus>({ checking: false, available: null, isSelf: false, suggestion: null });
+  const [pathUnsafe, setPathUnsafe] = useState(false); // Track if mindRoot is in a dangerous location
 
   const [agents, setAgents] = useState<AgentEntry[]>([]);
   const [agentsLoading, setAgentsLoading] = useState(false);
@@ -251,6 +252,22 @@ export default function SetupWizard() {
     }
   }, [step, agentsLoaded, agentsLoading]);
 
+  // Check path safety when mindRoot changes
+  useEffect(() => {
+    if (!state.mindRoot.trim()) { setPathUnsafe(false); return; }
+    const timer = setTimeout(() => {
+      fetch('/api/setup/check-path', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: state.mindRoot }),
+      })
+        .then(r => r.json())
+        .then(d => setPathUnsafe(!!d.unsafe))
+        .catch(() => setPathUnsafe(false));
+    }, 400);
+    return () => clearTimeout(timer);
+  }, [state.mindRoot]);
+
   const update = useCallback(<K extends keyof SetupState>(key: K, val: SetupState[K]) => {
     setState(prev => ({ ...prev, [key]: val }));
   }, []);
@@ -305,7 +322,8 @@ export default function SetupWizard() {
 
   const canNext = () => {
     if (step === STEP_KB) {
-      // KB path required + password required
+      // KB path required + password required + path must be safe
+      if (pathUnsafe) return false;
       return state.mindRoot.trim().length > 0 && state.webPassword.trim().length > 0;
     }
     if (step === STEP_AI) {

package/app/lib/acp/detect-local.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import os from 'os';
-import { execFile } from 'child_process';
+import { execFile, execFileSync } from 'child_process';
 import { findUserOverride, getDetectableAgents, resolveAgentCommand } from './agent-descriptors';
 import { readSettings } from '@/lib/settings';
 
@@ -22,17 +22,17 @@ export interface NotInstalledAgent {
   packageName?: string;
 }
 
-function expandHome(filePath: string): string {
+export function expandHome(filePath: string): string {
   if (filePath === '~') return os.homedir();
   if (filePath.startsWith('~/')) return `${os.homedir()}/${filePath.slice(2)}`;
   return filePath;
 }
 
-function isPathLikeCommand(command: string): boolean {
+export function isPathLikeCommand(command: string): boolean {
   return command.startsWith('~/') || command.startsWith('/') || command.startsWith('./') || command.startsWith('../') || command.includes('\\') || /^[A-Za-z]:[\\/]/.test(command);
 }
 
-function resolveDirectCommandPath(command: string | undefined): string | null {
+export function resolveDirectCommandPath(command: string | undefined): string | null {
   if (!command) return null;
   const trimmed = command.trim();
   if (!trimmed || !isPathLikeCommand(trimmed)) return null;
@@ -40,7 +40,7 @@ function resolveDirectCommandPath(command: string | undefined): string | null {
   return fs.existsSync(expanded) ? expanded : null;
 }
 
-function resolveExistingPresenceDir(paths: string[] | undefined): string | null {
+export function resolveExistingPresenceDir(paths: string[] | undefined): string | null {
   if (!paths || paths.length === 0) return null;
   for (const candidate of paths) {
     const expanded = expandHome(candidate);
@@ -49,28 +49,103 @@ function resolveExistingPresenceDir(paths: string[] | undefined): string | null
   return null;
 }
 
-function lookupCommandPath(command: string): Promise<string | null> {
-  const trimmed = command.trim();
-  if (!trimmed || isPathLikeCommand(trimmed)) return Promise.resolve(null);
+function parseResolvedPath(stdout: string): string | null {
+  const candidates = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (const candidate of candidates) {
+    const expanded = expandHome(candidate);
+    if (isPathLikeCommand(expanded) && fs.existsSync(expanded)) return expanded;
+  }
+  for (const candidate of candidates) {
+    if (isPathLikeCommand(candidate)) return expandHome(candidate);
+  }
+  return null;
+}
+
+function shellEscape(command: string): string {
+  return `'${command.replace(/'/g, `'\\''`)}'`;
+}
 
+function getLoginShells(): string[] {
+  if (process.platform === 'win32') return [];
+  return [...new Set([
+    process.env.SHELL,
+    process.platform === 'darwin' ? '/bin/zsh' : undefined,
+    '/bin/bash',
+    '/bin/sh',
+  ].filter((shell): shell is string => Boolean(shell)))];
+}
+
+function execFileText(command: string, args: string[]): Promise<string | null> {
   return new Promise((resolve) => {
-    execFile(process.platform === 'win32' ? 'where' : 'which', [trimmed], { encoding: 'utf-8', timeout: 3000 }, (err, stdout) => {
+    execFile(command, args, { encoding: 'utf-8', timeout: 3000 }, (err, stdout) => {
       if (err) {
         resolve(null);
         return;
       }
-      const firstMatch = stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .find(Boolean);
-      resolve(firstMatch ?? null);
+      resolve(stdout);
     });
   });
 }
 
+function execFileTextSync(command: string, args: string[]): string | null {
+  try {
+    return execFileSync(command, args, { encoding: 'utf-8', timeout: 3000 });
+  } catch {
+    return null;
+  }
+}
+
+async function lookupCommandPathCurrentEnv(command: string): Promise<string | null> {
+  const stdout = await execFileText(process.platform === 'win32' ? 'where' : 'which', [command]);
+  return stdout ? parseResolvedPath(stdout) : null;
+}
+
+function lookupCommandPathCurrentEnvSync(command: string): string | null {
+  const stdout = execFileTextSync(process.platform === 'win32' ? 'where' : 'which', [command]);
+  return stdout ? parseResolvedPath(stdout) : null;
+}
+
+async function lookupCommandPathLoginShell(command: string): Promise<string | null> {
+  for (const shell of getLoginShells()) {
+    const stdout = await execFileText(shell, ['-lic', `command -v -- ${shellEscape(command)}`]);
+    if (!stdout) continue;
+    const resolved = parseResolvedPath(stdout);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+
+function lookupCommandPathLoginShellSync(command: string): string | null {
+  for (const shell of getLoginShells()) {
+    const stdout = execFileTextSync(shell, ['-lic', `command -v -- ${shellEscape(command)}`]);
+    if (!stdout) continue;
+    const resolved = parseResolvedPath(stdout);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+
+export async function resolveCommandPath(command: string | undefined): Promise<string | null> {
+  if (!command) return null;
+  const direct = resolveDirectCommandPath(command);
+  if (direct) return direct;
+  const trimmed = command.trim();
+  if (!trimmed || isPathLikeCommand(trimmed)) return null;
+  return await lookupCommandPathCurrentEnv(trimmed) ?? await lookupCommandPathLoginShell(trimmed);
+}
+
+export function resolveCommandPathSync(command: string | undefined): string | null {
+  if (!command) return null;
+  const direct = resolveDirectCommandPath(command);
+  if (direct) return direct;
+  const trimmed = command.trim();
+  if (!trimmed || isPathLikeCommand(trimmed)) return null;
+  return lookupCommandPathCurrentEnvSync(trimmed) ?? lookupCommandPathLoginShellSync(trimmed);
+}
+
 async function lookupCommandPaths(commands: string[]): Promise<Map<string, string | null>> {
   const unique = [...new Set(commands.map((command) => command.trim()).filter(Boolean))];
-  const entries = await Promise.all(unique.map(async (command) => [command, await lookupCommandPath(command)] as const));
+  const entries = await Promise.all(unique.map(async (command) => [command, await resolveCommandPath(command)] as const));
   return new Map(entries);
 }
 
@@ -80,29 +155,35 @@ export async function detectLocalAcpAgents(settings = readSettings()): Promise<{
   const plans = agents.map((agent) => {
     const userOverride = findUserOverride(agent.id, settings.acpAgents);
     const resolved = resolveAgentCommand(agent.id, undefined, userOverride);
-    const directPath = resolveDirectCommandPath(userOverride?.command);
-    const commandCandidates = [...new Set([
+    const directOverridePath = resolveDirectCommandPath(userOverride?.command);
+    const presenceCommands = [...new Set([
       ...(agent.detectCommands ?? [agent.binary]),
       ...(userOverride?.command && !isPathLikeCommand(userOverride.command) ? [userOverride.command] : []),
     ])];
-    return { agent, resolved, directPath, commandCandidates };
+    return { agent, resolved, directOverridePath, presenceCommands };
   });
 
-  const commandLookup = await lookupCommandPaths(plans.flatMap((plan) => plan.commandCandidates));
+  const presenceLookup = await lookupCommandPaths(plans.flatMap((plan) => plan.presenceCommands));
+  const launchLookup = await lookupCommandPaths(plans.map((plan) => plan.resolved.cmd));
 
   const installed: InstalledAgent[] = [];
   const notInstalled: NotInstalledAgent[] = [];
 
-  for (const { agent, resolved, directPath, commandCandidates } of plans) {
-    const binaryPath = directPath
-      ?? commandCandidates.map((command) => commandLookup.get(command) ?? null).find(Boolean)
+  for (const { agent, resolved, directOverridePath, presenceCommands } of plans) {
+    const detectedCommandPath = presenceCommands.map((command) => presenceLookup.get(command) ?? null).find(Boolean);
+    const presencePath = directOverridePath
+      ?? detectedCommandPath
       ?? resolveExistingPresenceDir(agent.presenceDirs);
+    const launchPath = directOverridePath
+      ?? launchLookup.get(resolved.cmd)
+      ?? (presenceCommands.includes(resolved.cmd) ? detectedCommandPath : null)
+      ?? null;
 
-    if (binaryPath) {
+    if (presencePath && launchPath) {
       installed.push({
         id: agent.id,
         name: agent.name,
-        binaryPath,
+        binaryPath: launchPath,
         resolvedCommand: { cmd: resolved.cmd, args: resolved.args, source: resolved.source },
       });
     } else {

package/app/lib/acp/subprocess.ts

@@ -34,6 +34,7 @@ import {
 } from '@agentclientprotocol/sdk';
 import type { AcpRegistryEntry } from './types';
 import { resolveAgentCommand, findUserOverride } from './agent-descriptors';
+import { resolveCommandPathSync } from './detect-local';
 import { readSettings } from '../settings';
 
 /* ── Types ─────────────────────────────────────────────────────────────── */
@@ -106,7 +107,7 @@ export function spawnAcpAgent(
   const settings = readSettings();
   const userOverride = findUserOverride(entry.id, settings.acpAgents);
   const resolved = resolveAgentCommand(entry.id, entry, userOverride);
-  const { cmd, args } = { cmd: resolved.cmd, args: resolved.args };
+  const { cmd, args } = { cmd: resolveCommandPathSync(resolved.cmd) ?? resolved.cmd, args: resolved.args };
 
   const mergedEnv = {
     ...process.env,

package/app/lib/agent/model.ts

@@ -47,9 +47,10 @@ export function getModelConfig(options?: ModelConfigOverrides): {
   baseUrl: string;
 } {
   const saved = effectiveAiConfig(options?.provider);
+  const provider = options?.provider ?? saved.provider;
 
   const cfg = {
-    provider: saved.provider,
+    provider,
     apiKey: options?.apiKey ?? saved.apiKey,
     model: options?.model ?? saved.model,
     baseUrl: options?.baseUrl ?? saved.baseUrl,