@geminilight/mindos 0.6.76 → 0.6.77

package/app/__tests__/acp/subprocess.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { execFileSync, spawn } from 'child_process';
+import { spawnAcpAgent } from '../../lib/acp/subprocess';
+
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  execFile: vi.fn(),
+  execFileSync: vi.fn(),
+}));
+
+const mockSpawn = vi.mocked(spawn);
+const mockExecFileSync = vi.mocked(execFileSync);
+
+function makeChildProcess() {
+  return {
+    pid: 4321,
+    stdin: {},
+    stdout: {},
+    stderr: { on: vi.fn() },
+    on: vi.fn(),
+  } as any;
+}
+
+describe('spawnAcpAgent', () => {
+  const originalPlatform = process.platform;
+  const originalShell = process.env.SHELL;
+
+  beforeEach(() => {
+    mockExecFileSync.mockReset();
+    mockSpawn.mockReset();
+    mockSpawn.mockReturnValue(makeChildProcess());
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+    process.env.SHELL = originalShell;
+  });
+
+  it('spawns with the absolute executable resolved from the login shell on macOS', () => {
+    Object.defineProperty(process, 'platform', { value: 'darwin' });
+    process.env.SHELL = '/bin/zsh';
+
+    mockExecFileSync.mockImplementation((command, args) => {
+      if (command === 'which') throw new Error('not found');
+      if (command === '/bin/zsh' && Array.isArray(args) && String(args[1]).includes("command -v -- 'gemini'")) {
+        return '/Users/test/bin/gemini\n' as any;
+      }
+      throw new Error(`unexpected command: ${String(command)}`);
+    });
+
+    spawnAcpAgent({ id: 'gemini' } as any);
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      '/Users/test/bin/gemini',
+      ['--experimental-acp'],
+      expect.objectContaining({ shell: false }),
+    );
+  });
+
+  it('spawns Claude via the resolved npx executable instead of a bare command', () => {
+    Object.defineProperty(process, 'platform', { value: 'darwin' });
+    process.env.SHELL = '/bin/zsh';
+
+    mockExecFileSync.mockImplementation((command, args) => {
+      if (command === 'which') throw new Error('not found');
+      if (command === '/bin/zsh' && Array.isArray(args) && String(args[1]).includes("command -v -- 'npx'")) {
+        return '/Users/test/bin/npx\n' as any;
+      }
+      throw new Error(`unexpected command: ${String(command)}`);
+    });
+
+    spawnAcpAgent({ id: 'claude' } as any);
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      '/Users/test/bin/npx',
+      ['--yes', '@agentclientprotocol/claude-agent-acp'],
+      expect.objectContaining({ shell: false }),
+    );
+  });
+});

package/app/__tests__/api/acp-detect.test.ts

@@ -36,7 +36,7 @@ describe('detectLocalAcpAgents', () => {
     expect(result.installed.some((agent) => agent.id === 'gemini' && agent.binaryPath === '/usr/local/bin/gemini')).toBe(true);
   });
 
-  it('falls back to presence directories when PATH lookup fails', async () => {
+  it('does not mark directory-only detections as runnable when the launch command is unavailable', async () => {
     mockExecFile.mockImplementation((_command, _args, _options, callback) => {
       callback?.(new Error('not found'), '', '');
       return {} as never;
@@ -45,7 +45,8 @@ describe('detectLocalAcpAgents', () => {
 
     const result = await detectLocalAcpAgents({ acpAgents: {} } as any);
 
-    expect(result.installed.some((agent) => agent.id === 'cursor' && agent.binaryPath.includes('.cursor/extensions'))).toBe(true);
+    expect(result.installed.some((agent) => agent.id === 'cursor')).toBe(false);
+    expect(result.notInstalled.some((agent) => agent.id === 'cursor')).toBe(true);
   });
 
   it('treats an override command path as installed even when it is outside PATH', async () => {
@@ -81,7 +82,7 @@ describe('detectLocalAcpAgents', () => {
     expect(result.installed.some((agent) => agent.id === 'gemini' && agent.binaryPath === 'C:\\Tools\\gemini.cmd')).toBe(true);
   });
 
-  it('probes alternate command names such as qwen when the canonical binary is different', async () => {
+  it('can launch from an alternate detected executable when it matches the agent command family', async () => {
     mockExecFile.mockImplementation((_command, args, _options, callback) => {
       const binary = String(args?.[0] ?? '');
       const stdout = binary === 'qwen' ? '/usr/local/bin/qwen\n' : '';

package/app/__tests__/api/obsidian-compat-report.test.ts

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { NextRequest } from 'next/server';
+
+const scanObsidianVaultPlugins = vi.fn();
+
+vi.mock('@/lib/obsidian-compat/obsidian-import', () => ({
+  scanObsidianVaultPlugins,
+}));
+
+async function importRoute() {
+  return import('../../app/api/obsidian/compat-report/route');
+}
+
+describe('GET /api/obsidian/compat-report', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('rejects missing vaultRoot', async () => {
+    const { GET } = await importRoute();
+    const req = new NextRequest('http://localhost/api/obsidian/compat-report');
+    const res = await GET(req);
+
+    expect(res.status).toBe(400);
+    expect(await res.json()).toEqual({ ok: false, error: 'Missing vaultRoot' });
+  });
+
+  it('expands ~/ paths and returns compatibility summary', async () => {
+    scanObsidianVaultPlugins.mockResolvedValue([
+      {
+        id: 'style-settings-like',
+        manifest: { id: 'style-settings-like', name: 'Style Settings', version: '1.0.0' },
+        sourceDir: '/tmp/vault/.obsidian/plugins/style-settings-like',
+        compatibilityLevel: 'compatible',
+        compatibility: { obsidianApis: ['PluginSettingTab'], nodeModules: [], supportedApis: ['PluginSettingTab'], partialApis: [], blockers: [] },
+        hasStyles: true,
+        hasData: true,
+      },
+      {
+        id: 'desktop-only-like',
+        manifest: { id: 'desktop-only-like', name: 'Desktop Only', version: '1.0.0' },
+        sourceDir: '/tmp/vault/.obsidian/plugins/desktop-only-like',
+        compatibilityLevel: 'blocked',
+        compatibility: { obsidianApis: ['Plugin'], nodeModules: ['electron'], supportedApis: ['Plugin'], partialApis: [], blockers: ['Requires unsupported runtime module: electron'] },
+        hasStyles: false,
+        hasData: false,
+      },
+    ]);
+
+    const { GET } = await importRoute();
+    const req = new NextRequest('http://localhost/api/obsidian/compat-report?vaultRoot=~/vault');
+    const res = await GET(req);
+    const json = await res.json();
+
+    expect(res.status).toBe(200);
+    expect(json.ok).toBe(true);
+    expect(json.summary).toEqual({ total: 2, compatible: 1, partial: 0, blocked: 1 });
+    expect(json.plugins).toHaveLength(2);
+    expect(scanObsidianVaultPlugins).toHaveBeenCalledTimes(1);
+    expect(scanObsidianVaultPlugins.mock.calls[0][0]).not.toContain('~/');
+  });
+});

package/app/__tests__/api/obsidian-import.test.ts

@@ -0,0 +1,89 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { NextRequest } from 'next/server';
+
+const importObsidianPlugin = vi.fn();
+const scanObsidianVaultPlugins = vi.fn();
+
+vi.mock('@/lib/obsidian-compat/obsidian-import', () => ({
+  importObsidianPlugin,
+  scanObsidianVaultPlugins,
+}));
+
+async function importRoute() {
+  return import('../../app/api/obsidian/import/route');
+}
+
+describe('POST /api/obsidian/import', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('rejects missing vaultRoot or pluginId', async () => {
+    const { POST } = await importRoute();
+    const req = new NextRequest('http://localhost/api/obsidian/import', {
+      method: 'POST',
+      body: JSON.stringify({ vaultRoot: '~/vault' }),
+      headers: { 'content-type': 'application/json' },
+    });
+
+    const res = await POST(req);
+    expect(res.status).toBe(400);
+    expect(await res.json()).toEqual({ ok: false, error: 'Missing vaultRoot or pluginId' });
+  });
+
+  it('imports a plugin and returns compatibility details', async () => {
+    scanObsidianVaultPlugins.mockResolvedValue([
+      {
+        id: 'quickadd-like',
+        manifest: { id: 'quickadd-like', name: 'QuickAdd', version: '1.0.0' },
+        sourceDir: '/tmp/vault/.obsidian/plugins/quickadd-like',
+        compatibilityLevel: 'compatible',
+        compatibility: {
+          obsidianApis: ['Plugin', 'Modal', 'Notice', 'addCommand'],
+          nodeModules: [],
+          supportedApis: ['Plugin', 'Modal', 'Notice', 'addCommand'],
+          partialApis: [],
+          blockers: [],
+        },
+        hasStyles: false,
+        hasData: true,
+      },
+    ]);
+    importObsidianPlugin.mockResolvedValue({
+      pluginId: 'quickadd-like',
+      targetDir: '/tmp/mindRoot/.plugins/quickadd-like',
+    });
+
+    const { POST } = await importRoute();
+    const req = new NextRequest('http://localhost/api/obsidian/import', {
+      method: 'POST',
+      body: JSON.stringify({ vaultRoot: '~/vault', pluginId: 'quickadd-like', targetMindRoot: '~/mindRoot' }),
+      headers: { 'content-type': 'application/json' },
+    });
+
+    const res = await POST(req);
+    const json = await res.json();
+
+    expect(res.status).toBe(200);
+    expect(json.ok).toBe(true);
+    expect(json.plugin.id).toBe('quickadd-like');
+    expect(json.plugin.compatibilityLevel).toBe('compatible');
+    expect(json.imported.targetDir).not.toContain('~/');
+    expect(importObsidianPlugin).toHaveBeenCalledTimes(1);
+    expect(scanObsidianVaultPlugins).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns 404 when plugin is not found in the scanned vault', async () => {
+    scanObsidianVaultPlugins.mockResolvedValue([]);
+    const { POST } = await importRoute();
+    const req = new NextRequest('http://localhost/api/obsidian/import', {
+      method: 'POST',
+      body: JSON.stringify({ vaultRoot: '~/vault', pluginId: 'missing-plugin', targetMindRoot: '~/mindRoot' }),
+      headers: { 'content-type': 'application/json' },
+    });
+
+    const res = await POST(req);
+    expect(res.status).toBe(404);
+    expect(await res.json()).toEqual({ ok: false, error: 'Plugin not found in Obsidian vault' });
+  });
+});

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

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { validateMindRootPath, expandSetupPathHome } from '@/app/api/setup/path-utils';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+describe('path-utils', () => {
+  describe('expandSetupPathHome', () => {
+    it('expands ~ to home directory', () => {
+      expect(expandSetupPathHome('~')).toBe(homedir());
+    });
+
+    it('expands ~/path to home/path', () => {
+      expect(expandSetupPathHome('~/MindOS/mind')).toBe(path.resolve(homedir(), 'MindOS', 'mind'));
+    });
+
+    it('returns absolute paths unchanged', () => {
+      expect(expandSetupPathHome('/usr/local/share')).toBe('/usr/local/share');
+    });
+  });
+
+  describe('validateMindRootPath', () => {
+    const originalPlatform = process.platform;
+    const originalEnv = { ...process.env };
+
+    afterEach(() => {
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+      process.env = { ...originalEnv };
+    });
+
+    describe('cross-platform: ~/.mindos/', () => {
+      it('rejects ~/.mindos directory', () => {
+        const result = validateMindRootPath(path.join(homedir(), '.mindos'));
+        expect(result.safe).toBe(false);
+        expect(result.reason).toContain('system directory');
+      });
+
+      it('rejects ~/.mindos/runtime', () => {
+        const result = validateMindRootPath(path.join(homedir(), '.mindos', 'runtime'));
+        expect(result.safe).toBe(false);
+      });
+
+      it('rejects ~/.mindos/config.json subdirectory', () => {
+        const result = validateMindRootPath(path.join(homedir(), '.mindos', 'config', 'kb'));
+        expect(result.safe).toBe(false);
+      });
+    });
+
+    describe('Windows-specific', () => {
+      beforeEach(() => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        process.env.APPDATA = 'C:/Users/Test/AppData/Roaming';
+        process.env.LOCALAPPDATA = 'C:/Users/Test/AppData/Local';
+        process.env.ProgramFiles = 'C:/Program Files';
+        process.env['ProgramFiles(x86)'] = 'C:/Program Files (x86)';
+      });
+
+      it('rejects AppData/MindOS', () => {
+        const result = validateMindRootPath('C:/Users/Test/AppData/Roaming/mindos/kb');
+        expect(result.safe).toBe(false);
+        expect(result.reason).toContain('Electron app data');
+      });
+
+      it('rejects LocalAppData/MindOS', () => {
+        const result = validateMindRootPath('C:/Users/Test/AppData/Local/mindos/data');
+        expect(result.safe).toBe(false);
+      });
+
+      it('rejects Program Files', () => {
+        const result = validateMindRootPath('C:/Program Files/MindOS/data');
+        expect(result.safe).toBe(false);
+        expect(result.reason).toContain('Program Files');
+      });
+
+      it('rejects Program Files (x86)', () => {
+        const result = validateMindRootPath('C:/Program Files (x86)/MindOS/kb');
+        expect(result.safe).toBe(false);
+      });
+
+      it('allows D:/MindOS/mind', () => {
+        const result = validateMindRootPath('D:/MindOS/mind');
+        expect(result.safe).toBe(true);
+      });
+
+      it('allows C:/Users/Test/Documents/MindOS', () => {
+        const result = validateMindRootPath('C:/Users/Test/Documents/MindOS');
+        expect(result.safe).toBe(true);
+      });
+    });
+
+    describe('macOS-specific', () => {
+      beforeEach(() => {
+        Object.defineProperty(process, 'platform', { value: 'darwin' });
+      });
+
+      it('rejects paths inside .app bundles', () => {
+        const result = validateMindRootPath('/Applications/MindOS.app/Contents/Resources/kb');
+        expect(result.safe).toBe(false);
+        expect(result.reason).toContain('.app bundle');
+      });
+
+      it('rejects /Applications/MindOS', () => {
+        const result = validateMindRootPath('/Applications/MindOS/data');
+        expect(result.safe).toBe(false);
+      });
+
+      it('allows ~/MindOS/mind', () => {
+        const result = validateMindRootPath(path.join(homedir(), 'MindOS', 'mind'));
+        expect(result.safe).toBe(true);
+      });
+
+      it('allows ~/Documents/MindOS', () => {
+        const result = validateMindRootPath(path.join(homedir(), 'Documents', 'MindOS'));
+        expect(result.safe).toBe(true);
+      });
+    });
+
+    describe('Linux-specific', () => {
+      beforeEach(() => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+      });
+
+      it('rejects /opt/MindOS', () => {
+        const result = validateMindRootPath('/opt/mindos/data');
+        expect(result.safe).toBe(false);
+      });
+
+      it('rejects /usr/share/MindOS', () => {
+        const result = validateMindRootPath('/usr/share/mindos/kb');
+        expect(result.safe).toBe(false);
+      });
+
+      it('allows ~/MindOS/mind', () => {
+        const result = validateMindRootPath(path.join(homedir(), 'MindOS', 'mind'));
+        expect(result.safe).toBe(true);
+      });
+    });
+
+    describe('dynamic Desktop install directory', () => {
+      afterEach(() => {
+        delete process.env.MINDOS_INSTALL_DIR;
+      });
+
+      it('rejects install directory itself', () => {
+        process.env.MINDOS_INSTALL_DIR = 'D:/MindOS';
+        const result = validateMindRootPath('D:/MindOS');
+        expect(result.safe).toBe(false);
+        expect(result.reason).toContain('installation directory');
+      });
+
+      it('rejects paths inside install directory', () => {
+        process.env.MINDOS_INSTALL_DIR = 'D:/MindOS';
+        const result = validateMindRootPath('D:/MindOS/data/kb');
+        expect(result.safe).toBe(false);
+        expect(result.reason).toContain('reinstalling or uninstalling');
+      });
+
+      it('allows sibling paths outside install directory', () => {
+        process.env.MINDOS_INSTALL_DIR = 'D:/MindOS';
+        const result = validateMindRootPath('D:/MindOS-Data/kb');
+        expect(result.safe).toBe(true);
+      });
+
+      it('allows safe user data paths when install dir is set', () => {
+        process.env.MINDOS_INSTALL_DIR = 'D:/MindOS';
+        const result = validateMindRootPath('D:/MyNotes/MindOS');
+        expect(result.safe).toBe(true);
+      });
+    });
+
+    describe('safe paths', () => {
+      it('allows default ~/MindOS/mind', () => {
+        const result = validateMindRootPath(path.join(homedir(), 'MindOS', 'mind'));
+        expect(result.safe).toBe(true);
+      });
+
+      it('allows ~/Documents/notes', () => {
+        const result = validateMindRootPath(path.join(homedir(), 'Documents', 'notes'));
+        expect(result.safe).toBe(true);
+      });
+
+      it('allows /data/kb on Linux', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        const result = validateMindRootPath('/data/kb');
+        expect(result.safe).toBe(true);
+      });
+    });
+  });
+});

package/app/__tests__/ask/agent-selector-capsule.test.tsx

@@ -0,0 +1,34 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from 'vitest';
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import AgentSelectorCapsule from '@/components/ask/AgentSelectorCapsule';
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    t: {
+      panels: {
+        agents: {
+          acpDefaultAgent: 'MindOS',
+          acpSelectAgent: 'Select Agent',
+          acpChangeAgent: 'Change agent',
+        },
+      },
+    },
+  }),
+}));
+
+describe('AgentSelectorCapsule', () => {
+  it('renders the default MindOS capsule even when no ACP agents are installed', () => {
+    const html = renderToStaticMarkup(
+      <AgentSelectorCapsule
+        selectedAgent={null}
+        onSelect={vi.fn()}
+        installedAgents={[]}
+        loading={false}
+      />,
+    );
+
+    expect(html).toContain('MindOS');
+  });
+});

package/app/__tests__/ask/ask-content-agent-capsule-visibility.test.tsx

@@ -0,0 +1,195 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import AskContent from '@/components/ask/AskContent';
+
+const mockInstalledAgents: Array<{ id: string; name: string; binaryPath: string }> = [];
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    t: {
+      ask: {
+        title: 'MindOS',
+        placeholder: 'Ask a question...',
+        send: 'send',
+        newlineHint: 'new line',
+        panelComposerResize: 'Resize input',
+        panelComposerResetHint: 'Double click reset',
+        panelComposerKeyboard: 'Arrow keys',
+        attachFile: 'attach file',
+        attachFileLabel: 'Document',
+        attachImageLabel: 'Image',
+        stopTitle: 'Stop',
+        cancelReconnect: 'Cancel reconnect',
+        connecting: 'connecting',
+        thinking: 'thinking',
+        generating: 'generating',
+        reconnecting: (attempt: number, max: number) => `retry ${attempt}/${max}`,
+        stopped: 'stopped',
+        errorNoResponse: 'no response',
+        emptyPrompt: 'empty',
+        suggestions: [],
+        copyMessage: 'Copy',
+      },
+      search: { close: 'close' },
+      hints: {
+        typeMessage: 'Type a message',
+        mentionInProgress: 'Mention or command in progress',
+        sessionHistory: 'Session history',
+        newSession: 'New session',
+        attachFile: 'Attach local file',
+        maximizePanel: 'Maximize panel',
+        restorePanel: 'Restore panel',
+        dockToSide: 'Dock to side panel',
+        openAsPopup: 'Open as popup',
+        closePanel: 'Close',
+      },
+      fileImport: { unsupported: 'Unsupported file type' },
+      panels: { agents: { acpDefaultAgent: 'MindOS' } },
+    },
+  }),
+}));
+
+vi.mock('@/hooks/useAskSession', () => ({
+  useAskSession: () => ({
+    messages: [],
+    sessions: [],
+    activeSession: null,
+    activeSessionId: 's1',
+    initSessions: vi.fn(),
+    persistSession: vi.fn(),
+    clearPersistTimer: vi.fn(),
+    setMessages: vi.fn(),
+    setSessionDefaultAcpAgent: vi.fn(),
+    resetSession: vi.fn(),
+    loadSession: vi.fn(),
+    deleteSession: vi.fn(),
+    renameSession: vi.fn(),
+    togglePinSession: vi.fn(),
+    clearAllSessions: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useFileUpload', () => ({
+  useFileUpload: () => ({
+    localAttachments: [],
+    uploadError: '',
+    uploadInputRef: { current: null },
+    clearAttachments: vi.fn(),
+    removeAttachment: vi.fn(),
+    pickFiles: vi.fn(),
+    injectFiles: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useImageUpload', () => ({
+  useImageUpload: () => ({
+    images: [],
+    imageError: '',
+    clearImages: vi.fn(),
+    removeImage: vi.fn(),
+    handlePaste: vi.fn(),
+    handleDrop: vi.fn(),
+    handleFileSelect: vi.fn(),
+    addImages: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useMention', () => ({
+  useMention: () => ({
+    mentionQuery: null,
+    mentionResults: [],
+    mentionIndex: 0,
+    resetMention: vi.fn(),
+    updateMentionFromInput: vi.fn(),
+    navigateMention: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useSlashCommand', () => ({
+  useSlashCommand: () => ({
+    slashQuery: null,
+    slashResults: [],
+    slashIndex: 0,
+    resetSlash: vi.fn(),
+    updateSlashFromInput: vi.fn(),
+    navigateSlash: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useAcpDetection', () => ({
+  useAcpDetection: () => ({
+    installedAgents: mockInstalledAgents,
+    notInstalledAgents: [],
+    loading: false,
+    error: null,
+    refresh: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useAskChat', () => ({
+  useAskChat: () => ({
+    isLoading: false,
+    isLoadingRef: { current: false },
+    loadingPhase: 'connecting',
+    reconnectAttempt: 0,
+    reconnectMaxRef: { current: 3 },
+    abortRef: { current: null },
+    firstMessageFired: { current: false },
+    submit: (e: Event) => e.preventDefault(),
+    stop: vi.fn(),
+  }),
+}));
+
+vi.mock('@/components/ask/MessageList', () => ({ default: () => <div /> }));
+vi.mock('@/components/ask/MentionPopover', () => ({ default: () => null }));
+vi.mock('@/components/ask/SlashCommandPopover', () => ({ default: () => null }));
+vi.mock('@/components/ask/SessionHistory', () => ({ default: () => null }));
+vi.mock('@/components/ask/SessionHistoryPanel', () => ({ default: () => null }));
+vi.mock('@/components/ask/AskHeader', () => ({ default: () => <div /> }));
+vi.mock('@/components/ask/FileChip', () => ({ default: () => null }));
+vi.mock('@/components/ask/ModeCapsule', () => ({
+  default: () => <div data-testid="mode-capsule">mode</div>,
+  getPersistedMode: () => 'agent',
+}));
+vi.mock('@/components/ask/ProviderModelCapsule', () => ({
+  default: () => <div data-testid="provider-capsule">provider</div>,
+  getPersistedProviderModel: () => ({ provider: null, model: null }),
+}));
+vi.mock('@/components/ask/AgentSelectorCapsule', () => ({
+  default: ({ selectedAgent }: { selectedAgent: { id: string; name: string } | null }) => (
+    <div data-testid="agent-selector">{selectedAgent?.name ?? 'MindOS'}</div>
+  ),
+}));
+vi.mock('@/lib/utils', () => ({ cn: (...parts: Array<string | false | null | undefined>) => parts.filter(Boolean).join(' ') }));
+
+describe('AskContent agent selector capsule visibility', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockInstalledAgents.length = 0;
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  it('keeps the agent selector capsule visible in panel mode even with no detected ACP agents', async () => {
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<AskContent visible variant="panel" />);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(host.querySelector('[data-testid="mode-capsule"]')).toBeTruthy();
+    expect(host.querySelector('[data-testid="provider-capsule"]')).toBeTruthy();
+    expect(host.querySelector('[data-testid="agent-selector"]')?.textContent).toBe('MindOS');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});